In version 2 of WebForms Core technology, the client-side WebFormsJS library has been fundamentally rewritten. This is in addition to adding new features and capabilities.

Improved browser support checking for modern JavaScript features.

In this release, we have improved browser support checking and created a list to log APIs and features that are not supported by the browser. This structure is designed to check browser support for a set of modern web features. First, a list of important features is defined, including DOM and form APIs such as FormData, ES6 JavaScript language features such as let/const, Promise, Map, Set and BigInt, web APIs such as fetch, WebSocket, ServiceWorker and WebRTC, UI observers such as IntersectionObserver and MutationObserver, media and sharing features such as Clipboard API and Web Share API, local storage (localStorage) and internationalization support (Intl API). The user’s browser is then checked to see which of these features are not supported, and if there are any incompatibilities, a warning is given that the browser is outdated and may have poor performance when running WebForms Core-based applications.

Improved data encoding for GET (and similar) method submissions.

In this release, we fixed a bug in sending data via the GET method by implementing the encodeURIComponent function. The encodeURIComponent function is used to encode a portion of a URL to ensure that the data is correctly and without errors in the URL. This function converts characters such as spaces (``), equals signs (=), question marks (?), ampersands (&), and other special characters into a safe form so that the browser treats them as data, not as commands or delimiters. For example, if you want to send a form value or parameter in a URL, using encodeURIComponent ensures that the value is transmitted correctly and the URL structure is not broken. This function is usually used in combination with encodeURI or when constructing a query string for HTTP requests.

Added error display section in the Message section of WebFormsJS.

In this version, it is possible to customize errors by integrating the connection error display in the WebFormsJS settings section. For error display, the cb_ShowConnectionError function has been added to handle and display network connection errors, especially in xmlHttpRequest requests. This function generates an error message titled “Connection Error” and, if there is an error code, it is added to the message and displayed to the user via the cb_ShowMessage function. This message usually appears as a warning or notification in the user interface to inform the user of the connection problem. This method is fully editable; you can change the way the message is displayed, the error text, the message type (e.g. warning, error, notification), the display duration, or even side behaviors such as logging or sending to the server. This flexibility allows you to tailor the user experience to suit the needs of your project or audience.

Improved WebSocket data sending

In this update, sending data via WebSocket has been improved to better recognize the type of data being sent. By adding the string ``form=true&‘’ to the beginning of the serialized data, it is clear that this data is the result of a form submission. This helps the server or receiver process the received data as form information, and not as regular data or other messages. This method increases the accuracy of handling different data types in WebSocket communications and allows for appropriate responses to form requests.

Note: The CodeBehind 4.4 update will also coincide with the release of WebForms Core 2. On the server side, we also support this structure in CodeBehind and initialize the form data by recognizing the string ``form=true&‘’. Please note that for WebSocket sends to different backends, you need to manage this structure yourself.

Retry Mechanism

The Retry Mechanism in the WebFormsJS library allows the system to automatically retry a network request (such as xmlHttpRequest) if it fails. This feature is controlled by three settings:

UseRetryRequest: whether retry is enabled or disabled;

MaxRetryCount: the maximum number of times we are allowed to retry;

RetryRequestInterval: the time interval between each retry (in milliseconds).

If this feature is enabled and the maximum number of retries is not reached, the request is retried with the specified delay. If the attempts fail, a connection error message is displayed and UI elements such as the progress bar and button type are reset.

New Logs

In this release, more logs are provided for better error analysis, which helps developers identify and fix the source of problems faster. The effective use of the try-catch structure has led to errors not only being correctly identified, but also being recorded and managed in more detail. This approach allows for more detailed analysis of system behavior in critical situations, which increases the stability and reliability of the application. Also, by examining the logs, developers can identify error patterns and provide more optimal solutions to prevent their recurrence.

In this release, a set of warning messages (console.warn) and error notifications in the WebFormsJS library have been designed to more accurately report execution problems. The messages specifically refer to errors that occur when executing commands related to initialization, storage, condition checking, method calls, or module loading. Also, restrictions such as the eval method being disabled or attempts to access methods and modules that are not allowed are detected and warned. This reporting structure helps developers to detect, analyze, and fix errors faster.

New settings for displaying messages

In the new version of WebFormsJS, the settings for displaying messages have been improved directly in the user interface (not in the console) to inform about various system states in a clear and understandable way. These settings include the duration of displaying messages (MessageDuration) and enabling or disabling specific messages for events such as connection error (ConnectionErrorMessage), WebSocket connection start or stop, WebSocket errors, and various SSE (Server-Sent Events) related states. For each event, if the corresponding option is enabled, the cb_ShowMessage function displays an appropriate message of a specific type (such as success'',problem’‘, help'' ornone’’) on the screen.

In the new version of WebFormsJS, displaying user-friendly messages has been widely implemented in key parts of the system. These parts include specifying form elements, setting inputs, storing data, checking logical conditions, and retrieving values. For each of these operations, specific settings are defined in WebFormsOptions that, if enabled, display specific messages in the user interface via the cb_ShowMessage function when an error or incomprehensible execution occurs. These messages can include warnings, help, or information and help the user to be aware of the system status. This approach not only increases transparency in the internal processes of the application, but also improves the user experience and makes troubleshooting easier for developers. Also, by being able to enable or disable these messages, developers can have precise control over the amount and type of feedback displayed and adjust them according to the needs of the project or the level of access of users.

In the new version of WebFormsJS, the display settings of user-friendly messages can be controlled separately for different parts of the system. Below is the complete list of these sections:

✅ List of sections that have message settings:

📦 Basic Form Operations

• Element Detection
• Set Value to Input
• Fetch Value
• Save Value
• Check Condition

🌐 Network Communications

• Connection Error
• WebSocket:
• Initializing
• Open
• Close
• Error
• SSE (Server-Sent Events):
• Initializing
• Connect
• Disconnect
• Reconnect
• Close
• CloseAll

⚠️ Incomprehensible Errors

• Incomprehensible WebForms Initialization
• Incomprehensible Inputs Initialization
• Get Incomprehensible value
• Incomprehensible storage
• Incomprehensible condition check

❌ Execution errors

• Error in initializing WebForms
• Error in initializing inputs
• Error in receiving value
• Error in storage
• Error in condition check

Support for submit buttons

In this version, submit buttons will also receive the PostBack method like submit inputs, which means that when these buttons are clicked, the request sent to the server is made via the PostBack method and the form submission and data processing process is done correctly and seamlessly. This structure allows developers to easily and without the need for special settings, use all form elements uniformly to send data to the server, which increases the efficiency and capabilities of web application development.

Rewrite the server connection section to record errors and network problems.

In this version of WebFormsJS, the server connection section has been rewritten to handle HTTP responses with more accuracy and flexibility. One of the important changes is Adding support for the range of success statuses between 200 and 299; In previous versions, only status 200 could be checked, but now all successful responses (such as 201 Created or 206 Partial Content) are correctly recognized and processed. Also, special statuses such as 202 (Accepted) and 204 (No Content) are handled separately to avoid unnecessary processing.

In addition, the error handling structure has been improved:

• Client errors (400–499) are accompanied by a connection error message to the user.
• Server errors (500–599) first trigger a retry (if set), and if unsuccessful, an error message is displayed.
• In both cases, form elements are reset and loading is stopped to prevent UI hangs.

This rewrite has increased stability, accuracy in detecting response status, and improved user experience in the face of network errors.

WebFormsJS library reload warning.

In this version of WebFormsJS, the warning mechanism for reloading the library is intelligently designed to prevent serious performance errors. If the library has already been loaded and is called again, the system automatically warns in the console that this action can cause code execution disruption and instability in application behavior. This warning helps developers to more quickly identify and fix problems caused by incorrect configuration or repeated loading. Such an approach plays an important role in maintaining system integrity and preventing unwanted collisions in complex environments.

Rewrite of the serialization method (for submitting data)

In the new version of WebFormsJS, the serialization method of forms for submitting data has been completely rewritten to bring its behavior as close as possible to the default HTML behavior. This rewrite includes several important improvements:

✅ Ignoring disabled fields: Now fields with the disabled attribute are excluded from the serialization process, even if they are inside a disabled fieldset. This behavior is in line with the HTML standard and prevents invalid data from being submitted.

✅ Output field support: For the first time, output fields are also supported in serialization. This feature allows developers to include calculated or representational values ​​in the submitted data.

This rewrite has made the serialization method in WebFormsJS not only more accurate and standardized, but also provides more flexibility to manage complex forms and optimize data submission.

Improved Settings Section Structure

In the new version of WebFormsJS, the settings section structure has been significantly improved and organized into categories. This change has made managing settings much easier, more readable, and more maintainable. Instead of placing all the options scattered around, settings are now grouped into specific groups such as Initialization, Send, Response, State, Message, Style, Console Message, Non-Response Management, Animation, Compress, and Security.

This new structure not only helps developers find and change the settings they need faster, but also allows for extensibility and the addition of new options. Each category clearly indicates the purpose and use of the settings in that section; For example, message settings are now under the Message section, and security settings are now under the Security section.

This redesign is a significant step towards making the library more professional and more usable in large, complex projects. Developers can now fine-tune the behavior of the system to their specific needs with more precision and control, providing a more consistent and predictable experience for end users.

WebFormsJS rewrite progress at a glance

Aspect	Level of Progress	Explanation
Performance	⭐⭐⭐⭐☆	Network improvements, Retry, WebSocket
Architecture	⭐⭐⭐⭐⭐	Complete rewrite and new settings structure
Maintainability	⭐⭐⭐⭐⭐	Cleaner code and grouped settings
User Experience (UX)	⭐⭐⭐⭐☆	Clear messages, user-friendly errors
Extensibility	⭐⭐⭐⭐☆	Solid foundation for future plugins and updates

Conclusion

The WebForms Core 2 update with a fundamental rewrite of the WebFormsJS library is not a regular update, but a structural transformation that brings this framework to a new level of technical maturity. What we see in this version is a smart focus on the four fundamental foundations of modern web software development:

Stability and reliability - with a request retry mechanism, intelligent management of server responses and accurate error logging 1.

Developer experience - with a well-structured configuration structure, intelligent alerts and rich internal documentation 1.

User experience - with a transparent messaging system and standard behavior in form interactions 1.

Performance and standards - with a core rewrite, communication optimization and compliance with modern web standards

This update shows that WebForms Core is no longer just a simple tool for managing forms, but a comprehensive platform for developing enterprise web applications that can work well in large and complex projects. Attention to technical details, along with consideration of end-user needs, makes this release a logical and forward-thinking choice for development teams.

By migrating to this release, developers will not only benefit from immediate stability and performance benefits, but will also have a solid foundation for future scalability and development of their product.