@magic-xpa/engine 4.1200.0-dev4120.99 → 4.1200.0-ec.131.0

package/fesm2022/magic-xpa-engine.mjs

@@ -288,6 +288,9 @@ class ConstInterface {
     static MG_ATTR_CPY_GLB_PRMS = "copy_global_params";
     static MG_TAG_GLOBALPARAMS = "globalparams";
     static MG_TAG_GLOBALPARAMSCHANGES = "globalParamChanges";
+    static MG_ATTR_FILE_PATH = "filepath";
+    static MG_TAG_CACHED_FILE = "cachedFile";
+    static MG_ATTR_CACHE_URL = "cacheUrl";
     static MG_TAG_PARAM = "param";
     static MG_ATTR_IME_AUTO_OFF = "imeAutoOff";
     static MG_ATTR_LOCAL_AS400SET = "local_as400set";
@@ -583,6 +586,7 @@ class ConstInterface {
     static MG_ATTR_VAL_EVENT = "event";
     static MG_ATTR_VAL_EXEC_OPER = "execoper";
     static MG_ATTR_VAL_QUERY = "query";
+    static MG_ATTR_VAL_QUERY_CACHED_FILE = "cachedFile";
     static MG_ATTR_VAL_QUERY_GLOBAL_PARAMS = "globalparams";
     static MG_ATTR_VAL_QUERY_TYPE = "query_type";
     static MG_ATTR_VAL_RECOMP = "recompute";
@@ -599,6 +603,7 @@ class ConstInterface {
     static MG_ATTR_SPECIAL_DOTNET_ALLOW_ZERO_DATE = "SpecialDotNetAllowZeroDate";
     static MG_ATTR_SPECIAL_REUSE_TABLE_EDITOR = "SpecialReuseTableEditor";
     static MG_TAG_LAST_ROUTE = "LastRoute";
+    static RC_TOKEN_CACHED_FILE = "CACHE=";
 }
 
 /// <summary>
@@ -5467,6 +5472,12 @@ class CommandsProcessorBase {
     /// <param name="requestedURL">URL to be accessed.</param>
     /// <returns>response (from the server).</returns>
     async GetContent(requestedURL, useCache) {
+        return Promise.resolve(null);
+    }
+    /// <summary> Invoke the request URL & return the response.</summary>
+    /// <param name="requestedURL">URL to be accessed.</param>
+    /// <returns>response (from the server).</returns>
+    async GetContentAsString(requestedURL, useCache) {
         return Promise.resolve('');
     }
     /// <summary> unscramble servers response</summary>
@@ -5788,12 +5799,7 @@ class HttpClientAsync extends HttpClientBase {
         return httpHeaders;
     }
     async sendRequestToServer(httpMethod, urlString, httpHeaders, requestContent, contentFromServer) {
-        let contents = requestContent;
-        let responseType = "text";
-        if (requestContent instanceof ArrayBuffer) {
-            responseType = "arraybuffer";
-        }
-        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: responseType, observe: "response", body: contents }).toPromise();
+        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: "arraybuffer", observe: "response", body: requestContent }).toPromise();
         contentFromServer.value = httpResponse.body;
         return httpResponse;
     }
@@ -5933,10 +5939,19 @@ class HttpManager {
     /// <returns>if the response contains the error indicator - the error indicator is truncated and the remaining is returned.
     /// otherwise - null (indicating that the 'http Response' didn't contain an error).</returns>
     static CheckAndGetErrorResponse(httpResponse) {
+        const errorResponseIndicator = Encoding.UTF8.GetBytes(ConstInterface.V24_RIA_ERROR_PREFIX);
         let errorResponse = null;
-        httpResponse = httpResponse instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(httpResponse) : httpResponse;
-        if (httpResponse.startsWith(ConstInterface.V24_RIA_ERROR_PREFIX))
-            errorResponse = httpResponse.substr(ConstInterface.V24_RIA_ERROR_PREFIX.length);
+        const httpResponseBytes = new Uint8Array(httpResponse);
+        // Find 'errorResponseIndicator' in 'httpResponse', starting from the start index
+        let i;
+        for (i = 0; i < errorResponseIndicator.length; i++) {
+            if (httpResponseBytes[i] !== errorResponseIndicator[i]) {
+                break;
+            }
+        }
+        if (i === errorResponseIndicator.length) {
+            errorResponse = httpResponse.slice(errorResponseIndicator.length);
+        }
         return errorResponse;
     }
     static LogAccessToServer(msg, requestContent) {
@@ -5944,7 +5959,6 @@ class HttpManager {
             if (!NString.IsNullOrEmpty(msg)) {
                 msg = msg + "; accessing server ...";
             }
-            requestContent = requestContent instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(requestContent) : requestContent;
             if (requestContent === null) {
                 if (!NString.IsNullOrEmpty(msg)) {
                     Logger.Instance.WriteServerToLog(msg);
@@ -5954,11 +5968,24 @@ class HttpManager {
                 if (!NString.IsNullOrEmpty(msg)) {
                     msg = msg + " ";
                 }
-                msg = msg + "uploading " + requestContent.length + " bytes";
+                msg = msg + "uploading " + HttpManager.GetRequestContentLength(requestContent) + " bytes";
                 Logger.Instance.WriteServerToLog(msg);
             }
         }
     }
+    /// <summary>
+    /// <returns>the length of 'requestContent'.</returns>
+    /// <summary>
+    static GetRequestContentLength(requestContent) {
+        let length = 0;
+        if (requestContent instanceof ArrayBuffer) {
+            length = requestContent.byteLength;
+        }
+        else {
+            length = requestContent.length;
+        }
+        return length;
+    }
 }
 
 class ServerConfig {
@@ -6614,6 +6641,12 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     SessionId;
     DelayCommandExecution = false;
     _requestInfo = new RequestInfo();
+    // After the expression is evaluated, we obtain local file path. But to fetch this resource from server,
+    // cache path is needed. If cache path isn't found in cachedFilesMap, then query server for cachedFile.
+    // Later again if the expression is evaluated to the same path, no need to query server for cache path.
+    // e.g. for server-file path = "C:\\Blue_hills.jpg"
+    // cache path = "/MagicScripts/mgrqispi.dll?CTX=10430335172368&CACHE=agent_3572_C__Blue_hills.jpg|06/10/2009%2016:36:16"
+    serverFilesToClientFiles = new Map(); // Map between server-file path and cachedFileUrl
     static GetInstance() {
         if (RemoteCommandsProcessor._instance === null) {
             RemoteCommandsProcessor._instance = new RemoteCommandsProcessor();
@@ -7279,6 +7312,45 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         }
         return response;
     }
+    async DownloadFileFromServer(serverFileName) {
+        let fileContent = new ArrayBuffer(0);
+        let cmd = CommandFactory.CreateQueryCachedFileCommand(serverFileName);
+        AccessHelper.mgDataTable.getCurrMGData().CmdsToServer.Add(cmd);
+        this.serverFilesToClientFiles.delete(serverFileName);
+        await this.Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);
+        //Check what url value is getting in the below line.(file path or the url starts with ?)
+        let serverCachedFilePath = this.serverFilesToClientFiles.has(serverFileName) ? this.serverFilesToClientFiles.get(serverFileName) : null;
+        if (serverCachedFilePath) {
+            // let url: string = serverCachedFilePath;
+            fileContent = await this.GetContent(serverCachedFilePath, false);
+        }
+        return fileContent;
+    }
+    fillCacheFilesMap(parser) {
+        const xmlData = parser.getXMLdata();
+        let endContext = xmlData.indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < xmlData.length) {
+            // Find last position of its tag
+            const tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CACHED_FILE) + ConstInterface.MG_TAG_CACHED_FILE.length);
+            const tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            // Verify token names
+            console.assert(tokensVector[0] === ConstInterface.MG_ATTR_FILE_PATH, 'Invalid token for file path');
+            console.assert(tokensVector[2] === ConstInterface.MG_ATTR_CACHE_URL, 'Invalid token for cache URL');
+            // Get token values
+            const fileName = tokensVector[1];
+            const fileUrl = tokensVector[3];
+            if (fileUrl.trim() !== '') {
+                // Store file path and cache retrieval URL in dictionary
+                this.serverFilesToClientFiles.set(fileName, fileUrl);
+            }
+            endContext = xmlData.indexOf(XMLConstants.TAG_OPEN, endContext);
+            if (endContext === -1) {
+                endContext = xmlData.length;
+            }
+            parser.setCurrIndex(endContext);
+        }
+    }
     // <summary> If any items are stored on local storage clear it now as session cannot continued.
     // Clearing only the local storage items which are stored by magic library.
     clearLocalStorage() {
@@ -7296,30 +7368,28 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     /// an xml/html error</summary>
     /// <param name="response"></param>
     HandleErrorResponse(response) {
-        if (response instanceof ArrayBuffer)
-            response = this.ArrayBufferToString(response);
+        let responseStr = this.ArrayBufferToString(response);
         try {
             // error responses are always scrambled by the web server.
-            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + response);
-            response = CommandsProcessorBase.UnScramble(response);
-            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + StrUtil.getConsoleErorString(response));
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + responseStr);
+            responseStr = CommandsProcessorBase.UnScramble(responseStr);
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + StrUtil.getConsoleErorString(responseStr));
         }
         catch (ex) {
         }
-        if (response.startsWith("<xmlerr")) {
-            let errorMessageXml = new ErrorMessageXml(response, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());
+        if (responseStr.startsWith("<xmlerr")) {
+            let errorMessageXml = new ErrorMessageXml(responseStr, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());
             throw new ServerError(errorMessageXml.GetMessage(), errorMessageXml.GetCode());
         }
-        else if (response.toUpperCase().startsWith("<HTML")) {
-            throw new ServerError(response);
+        else if (responseStr.toUpperCase().startsWith("<HTML")) {
+            throw new ServerError(responseStr);
         }
     }
     // <summary>
     // Converts an ArrayBuffer to a UTF-8 encoded string.
     // </summary>
     ArrayBufferToString(arrayBuffer) {
-        const decoder = new TextDecoder('utf-8');
-        return decoder.decode(arrayBuffer);
+        return Encoding.UTF8.GetString(new Uint8Array(arrayBuffer), 0, arrayBuffer.byteLength);
     }
     /// <summary>send 'encodedBody' to 'url' and receive a response.
     /// </summary>
@@ -7327,29 +7397,36 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     /// <param name="encodedBody">In case of POST, content to be sent to server. For other methods, null.</param>
     /// <returns>the response from the server</returns>
     async ExecuteRequest(url, encodedBody) {
-        let response = await this.GetContent(url, false, encodedBody);
-        return response instanceof ArrayBuffer ? this.ArrayBufferToString(response) : response;
+        return await this.GetContentAsString(url, false, encodedBody);
+    }
+    async GetContentAsString(requestedURL, useCache, requestContent, requestContentType) {
+        let response = await this.GetContent(requestedURL, useCache, requestContent, requestContentType);
+        return this.ArrayBufferToString(response);
     }
     async GetContent(requestedURL, useCache, requestContent, requestContentType) {
         if (isUndefined(requestContent))
             requestContent = null;
         if (isUndefined(requestContentType))
             requestContentType = null;
-        let responseStr;
+        let response;
         try {
             // if relative, prefix with the 'protocol://server/' from which the rich-client was activated
             if (requestedURL.startsWith("/"))
                 requestedURL = ServerConfig.Instance.getProtocol() + "://" + ServerConfig.Instance.getServer() + requestedURL;
+            else if (requestedURL.startsWith("?")) {
+                requestedURL = this.ServerUrl + requestedURL;
+                requestedURL = this.validateURL(requestedURL, this._sessionCounter, this.SessionId);
+            }
             var spinnerTimer = timer(50, 50);
             var spinnerTimerSubscription = spinnerTimer.subscribe(() => {
                 AccessHelper.eventsManager.CheckAndShowSpinner(true);
             });
             let isError = new RefParam(false);
-            responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, requestContentType, useCache, isError);
+            response = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, requestContentType, useCache, isError);
             spinnerTimerSubscription.unsubscribe();
             spinnerTimerSubscription = null;
             if (isError.value) {
-                this.HandleErrorResponse(responseStr);
+                this.HandleErrorResponse(response);
             }
         }
         catch (ex) {
@@ -7367,7 +7444,75 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
             if (spinnerTimerSubscription != null)
                 spinnerTimerSubscription.unsubscribe();
         }
-        return responseStr;
+        return response;
+    }
+    validateURL(url, sessionCounter, sessionId) {
+        // const utf8Encoding = 'utf-8';  // UTF-8 encoding is used in the context of web APIs, but not directly needed in JavaScript/TypeScript
+        // Create URL object from string
+        const u = new URL(url);
+        // Assert protocol (http, https, or file)
+        if (!(u.protocol === "http:" || u.protocol === "https:" || u.protocol === "file:")) {
+            throw new Error("Invalid protocol. Expected http, https, or file.");
+        }
+        // Add protocol as is
+        let validURL = u.protocol + "//";
+        // Encode host
+        validURL += encodeURIComponent(u.hostname);
+        // If port is specified, append it
+        const port = u.port;
+        if (port) {
+            validURL += `:${port}`;
+        }
+        // Get path (e.g., alias/dir1/dir2/file)
+        let path = u.pathname;
+        if (!path.startsWith("/")) {
+            validURL += "/";
+        }
+        // Tokenize the path and encode each part
+        const pathParts = path.split("/");
+        // Recompose the URL (path is already encoded by `encodeURIComponent`)
+        for (let i = 0; i < pathParts.length; i++) {
+            validURL += encodeURIComponent(pathParts[i]) + "/";
+        }
+        // Remove last "/"
+        if (validURL.endsWith("/")) {
+            validURL = validURL.slice(0, validURL.length - 1);
+        }
+        // Replace "+" with "%20" (standard for spaces in URLs)
+        validURL = validURL.replace(/\+/g, "%20");
+        // Add the query string
+        if (u.search) {
+            let modifiedQuery = u.search;
+            const CTX_ID_PLACEHOLDER = "CTX=&";
+            const ctxIdIdx = u.search.indexOf(CTX_ID_PLACEHOLDER);
+            if (ctxIdIdx > -1) {
+                // Add context ID
+                // const queryString = `${ClientManager.Instance.RuntimeCtx.ContextID}`;
+                // Append session ID if provided
+                let queryParams = `${ClientManager.Instance.GetRuntimeCtxID()}`;
+                if (sessionId) {
+                    queryParams += `&${ConstInterface.RC_TOKEN_SESSION_ID}=${sessionId}`;
+                }
+                queryParams += `&${ConstInterface.RC_TOKEN_SESSION_COUNT}${sessionCounter}`;
+                // Insert query parameters in the query string
+                modifiedQuery = u.search.substring(0, ctxIdIdx + CTX_ID_PLACEHOLDER.length - 1) + queryParams + u.search.substring(ctxIdIdx + CTX_ID_PLACEHOLDER.length - 1);
+                // modifiedQuery is updated with file name with base64 encoded.
+                let indexOfCacheToken = modifiedQuery.indexOf(ConstInterface.RC_TOKEN_CACHED_FILE);
+                if (indexOfCacheToken !== -1) {
+                    let url = modifiedQuery;
+                    const cacheRegex = /CACHE=([^&]+)/;
+                    const match = url.match(cacheRegex);
+                    if (match && match[1]) {
+                        const cacheFileName = match[1].split('|')[0];
+                        const base64CacheFileName = btoa(cacheFileName);
+                        modifiedQuery = url.replace(`CACHE=${match[1]}`, `CACHE=${base64CacheFileName}`);
+                    }
+                }
+            }
+            validURL += modifiedQuery;
+            validURL = validURL.replace(/\|/g, "%7C");
+        }
+        return validURL;
     }
     // <summary> Upload contents to a file on server </summary>
     // <param name="serverFileName">filename to be saved on the server.</param>
@@ -7383,11 +7528,8 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_TARGET_FILE}${encodedName}`;
         const url = ServerConfig.Instance.getServerURL() + queryStr;
         let response = await this.GetContent(url, false, fileContent, contentType);
-        if (response instanceof ArrayBuffer) {
-            let uInt8Array = new Uint8Array(response);
-            return uInt8Array[0];
-        }
-        return response;
+        let uInt8Array = new Uint8Array(response);
+        return uInt8Array[0];
     }
     ClientActivated() {
         // log the values as client is active again
@@ -8032,8 +8174,15 @@ class CommandsProcessorManager {
     /// <param name="requestedURL"></param>
     /// <returns></returns>
     static async GetContent(requestedURL, useCache) {
-        let ret = await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
-        return ret;
+        return await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
+    }
+    /// <summary>
+    /// get the URL content according to the active commands processor
+    /// </summary>
+    /// <param name="requestedURL"></param>
+    /// <returns></returns>
+    static async GetContentString(requestedURL, useCache) {
+        return await (CommandsProcessorManager.GetCommandsProcessor().GetContentAsString(requestedURL, useCache));
     }
     /// <summary>
     /// Start session
@@ -8187,7 +8336,7 @@ class LanguageData {
                 if (this._constMessagesUrl != null) {
                     try {
                         // get the content from the server
-                        msgsInCommentString = await CommandsProcessorManager.GetContent(this._constMessagesUrl, true);
+                        msgsInCommentString = await CommandsProcessorManager.GetContentString(this._constMessagesUrl, true);
                     }
                     catch (err) {
                         Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unknown message file: \"{0}\"", this._constMessagesUrl));
@@ -8198,7 +8347,6 @@ class LanguageData {
                     msgsInCommentString = this._constMessagesContent;
                 }
                 if (msgsInCommentString != null) {
-                    msgsInCommentString = msgsInCommentString instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(msgsInCommentString) : msgsInCommentString;
                     // ignore the comment wrapper
                     let startData = msgsInCommentString.indexOf(START_TAG);
                     let endData = msgsInCommentString.indexOf(END_TAG) + END_TAG.length;
@@ -8288,9 +8436,9 @@ class LanguageData {
             else if (this._mlsFileUrl != null) {
                 if (this._mlsFileUrl.startsWith("./"))
                     this._mlsFileUrl = NString.Replace(this._mlsFileUrl, './', ClientManager.GetAssetsURL() + '/cache/');
-                let buffer = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
-                buffer = buffer instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(buffer) : buffer;
-                if (buffer != null && buffer.length > 0) {
+                let arrayBuffer = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
+                if (arrayBuffer != null && arrayBuffer.byteLength > 0) {
+                    let buffer = Encoding.Unicode.GetString(new Uint8Array(arrayBuffer), 0, arrayBuffer.byteLength);
                     let contentLen = buffer.length;
                     this._mlsStrings = new Hashtable();
                     // read the last line
@@ -10414,6 +10562,24 @@ class ControlItemsRefreshCommand extends DataviewCommand {
     }
 }
 
+class CachedFileQueryCommand extends QueryCommand {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    /**
+     * Serializes the query command data
+     */
+    SerializeQueryCommandData() {
+        let message = ConstInterface.MG_ATTR_VAL_QUERY_CACHED_FILE + '"';
+        let helper = new CommandSerializationHelper();
+        helper.SerializeAttribute(ConstInterface.MG_ATTR_FILE_PATH, this.text);
+        message += helper.GetString();
+        return message;
+    }
+}
+
 /// <summary>
 /// factory class for creating commands
 /// </summary>
@@ -10810,6 +10976,9 @@ class CommandFactory {
         iniputForceWriteCommand.Text = param;
         return iniputForceWriteCommand;
     }
+    static CreateQueryCachedFileCommand(cachedFileName) {
+        return new CachedFileQueryCommand(cachedFileName);
+    }
 }
 
 var ParamParseResult;
@@ -11306,13 +11475,12 @@ class Environment {
                 // in which case the current error message will be matched with an error in the xpa server's log file (GeneralErrorLog=)).
                 Logger.Instance.WriteErrorToLog(NString.Format("Empty cached file URL: '{0}'", tagAndAttributes.trim()));
             else {
-                let Content = await CommandsProcessorManager.GetContent(cachedFileUrl, true);
+                let Content = await CommandsProcessorManager.GetContentString(cachedFileUrl, true);
                 try {
                     switch (tagName) {
                         case ConstInterface.MG_TAG_KBDMAP_URL:
                             break;
                         case ConstInterface.MG_TAG_ENV_PARAM_URL:
-                            Content = Content instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(Content) : Content;
                             let innerXmlParser = new XmlParser(Content);
                             while (AccessHelper.envParamsTable.mirrorFromXML(innerXmlParser.getNextTag(), innerXmlParser)) {
                             }
@@ -27202,9 +27370,8 @@ class TableCacheManager {
             // get the table
             let current = this._tables.get_Item(tableUId);
             try {
-                let residentTableContentStr = await server.GetContent(tableUId, true);
+                let residentTableContentStr = await server.GetContentAsString(tableUId, true);
                 try {
-                    residentTableContentStr = residentTableContentStr instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(residentTableContentStr) : residentTableContentStr;
                     RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);
                 }
                 catch (innerException) {
@@ -32839,8 +33006,7 @@ class Task extends TaskBase {
             // bring the data
             if (taskCacheURL.startsWith("./"))
                 taskCacheURL = NString.Replace(taskCacheURL, './', ClientManager.GetAssetsURL() + '/cache/');
-            taskContentOriginal = await Task.CommandsProcessor.GetContent(taskCacheURL, true);
-            taskContentOriginal = taskContentOriginal instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(taskContentOriginal) : taskContentOriginal;
+            taskContentOriginal = await Task.CommandsProcessor.GetContentAsString(taskCacheURL, true);
         }
         // prefix the original data till the start of the current <taskURL>
         let taskContentFinal = new StringBuilder(xmlData.substr(0, RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1)), taskContentOriginal.length);
@@ -33358,6 +33524,9 @@ class MGData {
                 Logger.Instance.WriteDevToLog("processing base64 encoded image of all global params from the server");
                 this.fillGlobalParams(parser);
                 break;
+            case ConstInterface.MG_TAG_CACHED_FILE:
+                RemoteCommandsProcessor.GetInstance().fillCacheFilesMap(parser);
+                break;
             case ConstInterface.MG_TAG_ENV_PARAM_URL:
                 Logger.Instance.WriteDevToLog("goes to env params name ");
                 await Environment.Instance.fillFromUrl(foundTagName, parser);
@@ -39338,7 +39507,7 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.1200.0-dev4120.99';
+let CurrentClientVersion = '4.1200.0-ec.131.0';
 
 // @dynamic
 class ClientManager {
@@ -39692,13 +39861,8 @@ class ClientManager {
             // isError cannot be true here, because it is returned by runtime engine and to read execution properties, we do not reach the engine.
             let isError = new RefParam(false);
             response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, null, false, isError);
-            if (response instanceof ArrayBuffer) {
-                const decoder = new TextDecoder('utf-8');
-                ServerConfig.Instance.Init(JSON.parse(decoder.decode(response)));
-            }
-            else {
-                ServerConfig.Instance.Init(JSON.parse(response));
-            }
+            const responseStr = Encoding.UTF8.GetString((new Uint8Array(response)), 0, response.byteLength);
+            ServerConfig.Instance.Init(JSON.parse(responseStr));
             let assetsURL = ServerConfig.Instance.getAssetsURL();
             if (assetsURL !== null) {
                 ClientManager.assetsURL = assetsURL;
@@ -39735,6 +39899,9 @@ class ClientManager {
     static UploadFileToServer(fileContent, serverFileName) {
         return RemoteCommandsProcessor.GetInstance().UploadFileToServer(fileContent, serverFileName);
     }
+    static async DownloadFileFromServer(serverFileName) {
+        return await RemoteCommandsProcessor.GetInstance().DownloadFileFromServer(serverFileName);
+    }
     /// <summary>
     ///   Get formatted value
     /// </summary>
@@ -39885,6 +40052,9 @@ class MagicBridge {
     static UploadFileToServer(fileContent, serverFileName) {
         return ClientManager.UploadFileToServer(fileContent, serverFileName);
     }
+    static async DownloadFileFromServer(serverFileName) {
+        return await ClientManager.DownloadFileFromServer(serverFileName);
+    }
     static GetFormattedValue(taskId, controlName, value, rowId) {
         return ClientManager.GetFormattedValue(taskId, controlName, value, rowId);
     }
@@ -39951,5 +40121,5 @@ class DataSourceIdKey {
  * Generated bundle index. Do not edit.
  */
 
-export { AbortCommand, AccessHelper, ActionManager, AddLocateCommand, AddRangeCommand, AddSortCommand, AddUserLocateDataViewCommand, AddUserLocateRemoteDataViewCommand, AddUserRangeDataviewCommand, AddUserRangeRemoteDataViewCommand, AddUserSortDataViewCommand, AddUserSortRemoteDataViewCommand, Argument, ArgumentsList, Boundary, BrowserEscEventCommand, ClearEventsOnStopExecution, ClientManager, ClientOriginatedCommand, ClientOriginatedCommandSerializer, ClientOriginatedCommandTaskTag, ClientRefreshCommand, ClientTargetedCommandBase, ClientTargetedCommandType, ColumnSortEventCommand, CommandFactory, CommandSerializationHelper, CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage, CommandsProcessorManager, CommandsTable, CompMainPrgTable, ComputeEventCommand, ConstInterface, ConstUtils, ContextTerminationEventCommand, ContextTimeoutResetCommand, ControlItemsRefreshCommand, CookieService, CreatedFormVector, CurrentClientVersion, DataSourceIdKey, DataView, DataViewBase, DataViewCommandBase, DataViewCommandType, DataViewOutputCommand, DataviewCommand, DataviewHeaderBase, DataviewHeaderFactory, DataviewHeaders, DataviewHeadersSaxHandler, DataviewManager, DataviewManagerBase, DcValuesReference, DummyDataViewCommand, DvCache, EnhancedVerifyCommand, EnvParamsTable, Environment, EnvironmentDetails, EvaluateCommand, Event, EventCommand, EventHandler, EventHandlerPosition, EventSubType, EventsAllowedType, EventsManager, ExecOperCommand, ExecutionStack, ExecutionStackEntry, ExpDesc, ExpStrTracker, ExpTable, Expression, ExpressionDict, ExpressionEvaluator, ExpressionLocalJpn, Expression_ReturnValue, FetchDataControlValuesEventCommand, Field, FieldBase, FieldsTable as FieldsTableExt, FlowMonitorInterface, FlowMonitorQueue, FormsTable, GUIManager, GlobalCommandsManager, GlobalParams, GlobalParamsQueryCommand, GuiEventsProcessor, HandlersTable, HeapSort, HttpClientAsync, HttpClientBase, HttpClientEvents, HttpClientSync, HttpManager, HttpUtility, IClientTargetedCommand, IndexChangeEventCommand, IniputForceWriteCommand, InteractiveCommunicationsFailureHandler, Key, LanguageData, LastFocusedManager, MGData, MGDataCollection, MagicBridge, MgControl, MgForm, MgPriorityBlockingQueue, MgPriorityQueue, MirrorExpVal, MirrorPrmMap, MirrorString, NonReversibleExitEventCommand, NullValueException, OpenURLCommand, OpeningTaskDetails, Operation, OperationTable, ParamParseResult, PrmMap, QueryCommand, RCTimer, Recompute, RecomputeCommand, RecomputeTable, Recompute_RcmpBy, Record, RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType, RecordsTable, RefreshEventCommand, RefreshScreenEventCommand, RemoteCommandsProcessor, RemoteControlItemsRefreshCommand, RemoteDataViewCommandBase, RemoteDataViewCommandFactory, RemoteDataViewCommandUpdateNonModifiable, RemoteDataviewHeader, RemoteDataviewManager, RemoteTaskService, RequestMethod, ResetLocateCommand, ResetRangeCommand, ResetSortCommand, ResetUserLocateRemoteDataviewCommand, ResetUserRangeRemoteDataviewCommand, ResetUserSortRemoteDataviewCommand, ResultCommand, ResultValue, RetVals, ReturnResult, ReturnResultBase, RollbackEventCommand, RollbackEventCommand_RollbackType, RunTimeEvent, RunTimeEventBase, SET_DISPLAYLINE_BY_DV, Scrambler, SelectProgramCommand, ServerConfig, ServerError, SetTransactionStateDataviewCommand, SetTransactionStateRemoteDataViewCommand, Sort, SortCollection, SubformOpenEventCommand, SubformRefreshEventCommand, TableCache, TableCacheManager, Task, TaskBase, TaskServiceBase, TaskTransactionManager, Task_Direction, Task_Flow, Task_SubformExecModeEnum, TasksTable, Transaction, TransactionCommand, UniqueIDUtils, UnloadCommand, UserDetails, UserEventsTable, UserRange, VerifyCommand, WriteMessageToServerLogCommand, XMLBasedCommandBuilder, XMLBasedDcValuesBuilder, YesNoExp, getGuiEventObj };
+export { AbortCommand, AccessHelper, ActionManager, AddLocateCommand, AddRangeCommand, AddSortCommand, AddUserLocateDataViewCommand, AddUserLocateRemoteDataViewCommand, AddUserRangeDataviewCommand, AddUserRangeRemoteDataViewCommand, AddUserSortDataViewCommand, AddUserSortRemoteDataViewCommand, Argument, ArgumentsList, Boundary, BrowserEscEventCommand, CachedFileQueryCommand, ClearEventsOnStopExecution, ClientManager, ClientOriginatedCommand, ClientOriginatedCommandSerializer, ClientOriginatedCommandTaskTag, ClientRefreshCommand, ClientTargetedCommandBase, ClientTargetedCommandType, ColumnSortEventCommand, CommandFactory, CommandSerializationHelper, CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage, CommandsProcessorManager, CommandsTable, CompMainPrgTable, ComputeEventCommand, ConstInterface, ConstUtils, ContextTerminationEventCommand, ContextTimeoutResetCommand, ControlItemsRefreshCommand, CookieService, CreatedFormVector, CurrentClientVersion, DataSourceIdKey, DataView, DataViewBase, DataViewCommandBase, DataViewCommandType, DataViewOutputCommand, DataviewCommand, DataviewHeaderBase, DataviewHeaderFactory, DataviewHeaders, DataviewHeadersSaxHandler, DataviewManager, DataviewManagerBase, DcValuesReference, DummyDataViewCommand, DvCache, EnhancedVerifyCommand, EnvParamsTable, Environment, EnvironmentDetails, EvaluateCommand, Event, EventCommand, EventHandler, EventHandlerPosition, EventSubType, EventsAllowedType, EventsManager, ExecOperCommand, ExecutionStack, ExecutionStackEntry, ExpDesc, ExpStrTracker, ExpTable, Expression, ExpressionDict, ExpressionEvaluator, ExpressionLocalJpn, Expression_ReturnValue, FetchDataControlValuesEventCommand, Field, FieldBase, FieldsTable as FieldsTableExt, FlowMonitorInterface, FlowMonitorQueue, FormsTable, GUIManager, GlobalCommandsManager, GlobalParams, GlobalParamsQueryCommand, GuiEventsProcessor, HandlersTable, HeapSort, HttpClientAsync, HttpClientBase, HttpClientEvents, HttpClientSync, HttpManager, HttpUtility, IClientTargetedCommand, IndexChangeEventCommand, IniputForceWriteCommand, InteractiveCommunicationsFailureHandler, Key, LanguageData, LastFocusedManager, MGData, MGDataCollection, MagicBridge, MgControl, MgForm, MgPriorityBlockingQueue, MgPriorityQueue, MirrorExpVal, MirrorPrmMap, MirrorString, NonReversibleExitEventCommand, NullValueException, OpenURLCommand, OpeningTaskDetails, Operation, OperationTable, ParamParseResult, PrmMap, QueryCommand, RCTimer, Recompute, RecomputeCommand, RecomputeTable, Recompute_RcmpBy, Record, RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType, RecordsTable, RefreshEventCommand, RefreshScreenEventCommand, RemoteCommandsProcessor, RemoteControlItemsRefreshCommand, RemoteDataViewCommandBase, RemoteDataViewCommandFactory, RemoteDataViewCommandUpdateNonModifiable, RemoteDataviewHeader, RemoteDataviewManager, RemoteTaskService, RequestMethod, ResetLocateCommand, ResetRangeCommand, ResetSortCommand, ResetUserLocateRemoteDataviewCommand, ResetUserRangeRemoteDataviewCommand, ResetUserSortRemoteDataviewCommand, ResultCommand, ResultValue, RetVals, ReturnResult, ReturnResultBase, RollbackEventCommand, RollbackEventCommand_RollbackType, RunTimeEvent, RunTimeEventBase, SET_DISPLAYLINE_BY_DV, Scrambler, SelectProgramCommand, ServerConfig, ServerError, SetTransactionStateDataviewCommand, SetTransactionStateRemoteDataViewCommand, Sort, SortCollection, SubformOpenEventCommand, SubformRefreshEventCommand, TableCache, TableCacheManager, Task, TaskBase, TaskServiceBase, TaskTransactionManager, Task_Direction, Task_Flow, Task_SubformExecModeEnum, TasksTable, Transaction, TransactionCommand, UniqueIDUtils, UnloadCommand, UserDetails, UserEventsTable, UserRange, VerifyCommand, WriteMessageToServerLogCommand, XMLBasedCommandBuilder, XMLBasedDcValuesBuilder, YesNoExp, getGuiEventObj };
 //# sourceMappingURL=magic-xpa-engine.mjs.map