@magic-xpa/engine 4.1300.0-dev4130.19 → 4.1300.0-dev4130.191

package/fesm2022/magic-xpa-engine.mjs

@@ -1,8 +1,9 @@
 import { StringBuilder, Int32, NString, ApplicationException, NNumber, List, Debug, Char, RefParam, NumberStyles, HashUtils, DateTime, Dictionary, Stack, NChar, isNullOrUndefined, WebException, Thread, Encoding, Exception, isUndefined, Hashtable, NotImplementedException, Array_Enumerator, ISO_8859_1_Encoding, Int64 } from '@magic-xpa/mscorelib';
 import { XMLConstants, StorageAttribute, ViewRefreshMode, InternalInterface, Logger, StorageAttributeCheck, StrUtil, SubformType, TableBehaviour, MgControlType, ScrollBarThumbType, ForceExit, XmlParser, Misc, Base64, Priority, SyncExecutionHelper, Queue, Constants, DateTimeUtils, Logger_LogLevels, Logger_MessageDirection, MsgInterface, RequestInfo, OSEnvironment, JSON_Utils, UtilDateJpn, UtilStrByteMode, PICInterface, WindowType, BrkScope, RaiseAt, CtrlButtonTypeGui } from '@magic-xpa/utils';
-import { RecordUtils, GuiFieldBase, ExpVal, BlobType, FieldDef, GuiTaskBase, MgControlBase, PropInterface, GuiDataCollection, CommandType, Commands, HtmlProperties, ControlTable, Modifiers, KeyboardItem, TaskDefinitionIdTableSaxHandler, DisplayConvertor, VectorType, PIC, MgTimer, GuiConstants, RuntimeContextBase, UsernamePasswordCredentials, Styles, Manager, NUM_TYPE, GuiExpressionEvaluator, ExpressionInterface, DataModificationTypes, GuiDataViewBase, ObjectReferencesCollection, EMPTY_DCREF, ObjectReferenceBase, PropTable, FieldsTable as FieldsTable$1, DcValuesBuilderBase, MgFormBase, GuiEnvironment, TaskDefinitionId, Events, Helps, FocusManager, EventsProcessor, UIBridge } from '@magic-xpa/gui';
+import { RecordUtils, GuiFieldBase, ExpVal, BlobType, FieldDef, GuiTaskBase, MgControlBase, PropInterface, GuiDataCollection, CommandType, Commands, HtmlProperties, ControlTable, Modifiers, KeyboardItem, TaskDefinitionIdTableSaxHandler, DisplayConvertor, VectorType, PIC, MgTimer, GuiConstants, RuntimeContextBase, UsernamePasswordCredentials, Styles, Manager, NUM_TYPE, GuiExpressionEvaluator, ExpressionInterface, DateBreakParams, DataModificationTypes, GuiDataViewBase, ObjectReferencesCollection, EMPTY_DCREF, ObjectReferenceBase, PropTable, FieldsTable as FieldsTable$1, DcValuesBuilderBase, MgFormBase, GuiEnvironment, TaskDefinitionId, Events, Helps, FocusManager, EventsProcessor, UIBridge } from '@magic-xpa/gui';
 import { HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import { timer, Subject } from 'rxjs';
+import { io } from 'socket.io-client';
 import * as CryptoJS from 'crypto-js';
 
 ///
@@ -606,6 +607,9 @@ class ConstInterface {
     static MG_ATTR_SPECIAL_REUSE_TABLE_EDITOR = "SpecialReuseTableEditor";
     static MG_TAG_LAST_ROUTE = "LastRoute";
     static RC_TOKEN_CACHED_FILE = "CACHE=";
+    //For PuSub
+    static MG_TAG_PUBSUB_SERVER_URI = "PubSubServerURI";
+    static WC_TOKEN_PUBSUB_SUBSCRIBE = "PubsubToken=Y&";
 }
 
 /// <summary>
@@ -3453,6 +3457,9 @@ class Event {
             case InternalInterface.MG_ACT_DUMP_ENVIRONMENT:
                 description = 'Dump Environment';
                 break;
+            case InternalInterface.MG_ACT_PUBSUB_TOPIC_PUBLISHED:
+                description = 'Topic Publish';
+                break;
             default:
                 description = '';
                 break;
@@ -7699,6 +7706,7 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         HttpClientEvents.CheckAndSetSessionCounter_Event = this.CheckAndSetSessionCounter.bind(this);
         HttpClientEvents.ComputeAndLogRequestInfo_Event = this.ComputeAndLogRequestInfo.bind(this);
         AccessHelper.eventsManager.SpinnerStopped.subscribe(clientBusyTime => this.ClientActivated());
+        SubscriberClient.SubscribeTopics_Event = this.SubscribeTopics.bind(this);
     }
     /// <summary>
     /// Log the current request information in console
@@ -7802,6 +7810,27 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         await AccessHelper.mgDataTable.processRecovery();
         AccessHelper.eventsManager.popNewExecStacks();
     }
+    // <summary> Get the subscription token from server </summary>
+    // <param name="topics">List of topics to be subscribed to.</param>
+    // <returns> Return subscription token to authenticate xpa client </returns>
+    async GetSubscriptionTokenFromServer(topics) {
+        const sessionID = this.SessionId;
+        let queryStr = `${ConstInterface.REQ_ARG_START}${ConstInterface.RC_INDICATION}${ConstInterface.RC_TOKEN_CTX_ID}${ClientManager.Instance.GetRuntimeCtxID()}`;
+        if (!isNullOrUndefined(sessionID))
+            queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_ID}${sessionID}`;
+        queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.WC_TOKEN_PUBSUB_SUBSCRIBE}`;
+        //queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_TARGET_FILE}`;
+        const url = ServerConfig.Instance.getServerURL() + queryStr;
+        //queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.WC_TOKEN_PUBSUB_SUBSCRIBE}`;
+        //const url = ServerConfig.Instance.getServerURL() + queryStr;
+        let response = await this.GetContent(url, false, null, null);
+        //let uInt8Array:Uint8Array = new Uint8Array(response);
+        return this.ArrayBufferToString(response);
+    }
+    async SubscribeTopics(topics, socket) {
+        const token = await RemoteCommandsProcessor.GetInstance().GetSubscriptionTokenFromServer(Array.from(topics));
+        socket.emit('subscribe', Array.from(topics), token, ClientManager.Instance.GetRuntimeCtxID());
+    }
 }
 /// <summary>helper class: details from the runtime-engine - environment values.
 /// Handshake response: <Richclientresponse> <ContextID>...</ContextID> <Environment InputPassword="Y|N"
@@ -9751,6 +9780,14 @@ class ExpressionDict {
         null,
         null,
         new ExpDesc('NO', 0, 2, 2, 'A', false), /* 716- Hash */
+        null,
+        null,
+        new ExpDesc('U', 0, -1, -1, 'B', false), /* 719- Subscribe */
+        new ExpDesc('U', 0, -1, -1, 'B', false), /* 720- Unsubscribe */
+        null,
+        null,
+        new ExpDesc('B', 0, 4, 4, 'TDVV', false), /* 723- LocalToUTC */
+        new ExpDesc('B', 0, 4, 4, 'TDVV', false), /* 724- UTCToLocal */
     ];
 }
 
@@ -11255,6 +11292,7 @@ class Environment {
     _dropUserFormats = null;
     _webclientReinitSession = "N";
     _specialValNewPolicy = false; //??
+    _pubsubServerURI = null;
     static Instance = new Environment();
     get Language() {
         return this._language;
@@ -11463,6 +11501,9 @@ class Environment {
                 case ConstInterface.MG_ATTR_SPECIAL_DOTNET_ALLOW_ZERO_DATE:
                 case ConstInterface.MG_ATTR_SPECIAL_REUSE_TABLE_EDITOR:
                     break;
+                case ConstInterface.MG_TAG_PUBSUB_SERVER_URI:
+                    this._pubsubServerURI = valueStr;
+                    break;
                 default:
                     Logger.Instance.WriteExceptionToLogWithMsg("in Environment.fillData(): unknown attribute: " + attribute);
                     break;
@@ -11899,6 +11940,9 @@ class Environment {
     GetSpecialCancelOnCreate() {
         return this._specialCancelOnCreate;
     }
+    GetPubSubServerURI() {
+        return this._pubsubServerURI;
+    }
 }
 /// <summary>
 ///   This class holds details for single Environment (per Component)
@@ -13824,6 +13868,136 @@ class CookieService {
     }
 }
 
+class SubscriberClient {
+    static instance;
+    socket;
+    subscribedTopics = new Set();
+    static SubscribeTopics_Event = null;
+    constructor(task) {
+        // Connect to the Socket.IO server with subscriber role
+        const serverUrl = EnvParamsTable.Instance.get(ConstInterface.MG_TAG_PUBSUB_SERVER_URI);
+        const taskRef = task;
+        this.socket = io(serverUrl, {
+            query: {
+                role: 'subscriber'
+                //token: '' // TODO: TO be used, in case subscriber needs to be authenticated with separate token.
+            }
+        });
+        // Handle connection
+        this.socket.on('connect', async () => {
+            Logger.Instance.WriteDevToLog("SubscriberClient connected to server : " + this.socket.id);
+            // Case 2: Subscribe to topics that were subscribed with previous session between client and pubsub middleware.
+            // (reconnected to middleware after a disconnection)
+            if (this.subscribedTopics.size > 0) {
+                await SubscriberClient.SubscribeTopics_Event(this.subscribedTopics, this.socket);
+            }
+        });
+        // Handle disconnection
+        this.socket.on('disconnect', (reason) => {
+            let disconnectReason;
+            switch (reason) {
+                case "ping timeout":
+                    disconnectReason = "Connection lost due to timeout";
+                    break;
+                case "transport close":
+                    disconnectReason = "Network connection closed";
+                    break;
+                case "io server disconnect":
+                    disconnectReason = "Disconnected by server";
+                    break;
+                default:
+                    disconnectReason = "Disconnected:";
+            }
+            Logger.Instance.WriteDevToLog("SubscriberClient disconnected from server : " + reason + " : " + disconnectReason);
+        });
+        // Handle reconnection
+        this.socket.on("reconnect", (attemptNumber) => {
+            Logger.Instance.WriteDevToLog("Reconnected after " + attemptNumber + "attempts");
+        });
+        // Handle reconnection attempts
+        this.socket.on("reconnect_attempt", (attemptNumber) => {
+            Logger.Instance.WriteDevToLog("Reconnect attempt: " + attemptNumber);
+        });
+        // Handle reconnection errors
+        this.socket.on("connect_error", (err) => {
+            Logger.Instance.WriteDevToLog("Connection error: " + err.name + " Message: " + err.message);
+        });
+        // Handle subscription confirmation
+        this.socket.on('subscribed', (data) => {
+            this.subscribedTopics.add(data.topic);
+            Logger.Instance.WriteDevToLog("SubscriberClient subscribed to topic : " + data.topic + " : " + data.message);
+        });
+        // Handle unsubscription confirmation
+        this.socket.on('unsubscribed', (data) => {
+            this.subscribedTopics.delete(data.topic);
+            Logger.Instance.WriteDevToLog("SubscriberClient unsubscribed from topic : " + data.topic + " : " + data.message);
+        });
+        // Handle errors
+        this.socket.on('error', (error) => {
+            Logger.Instance.WriteErrorToLog("SubscriberClient error : " + error.message);
+        });
+        // Handle incoming messages
+        this.socket.on('message', (data) => {
+            //this.messageSubject.next(data);
+            Logger.Instance.WriteDevToLog("SubscriberClient received message from topic : " + data.topic + " : " + data.message);
+            EventsManager.Instance.AddTopicPublishedEvent(taskRef, data.topic, data.message);
+        });
+    }
+    /**
+     * Get the singleton instance of SubscriberClient
+     */
+    static getInstance(task) {
+        if (!SubscriberClient.instance) {
+            SubscriberClient.instance = new SubscriberClient(task);
+        }
+        return SubscriberClient.instance;
+    }
+    /**
+     * Subscribe to multiple topics at once
+     * @param topics Array of topics to subscribe to
+     */
+    subscribe(topics, token) {
+        let ctxID = ClientManager.Instance.GetRuntimeCtxID();
+        this.socket.emit('subscribe', topics, token, ctxID);
+        // topics.forEach(topic => {
+        //   if (!this.subscribedTopics.has(topic)) {
+        //
+        //     let ctxID = ClientManager.Instance.GetRuntimeCtxID()
+        //     this.socket.emit('subscribe', topic, token, ctxID);
+        //   }
+        // });
+    }
+    /**
+     * Unsubscribe from multiple topics at once
+     * @param topics Array of topics to unsubscribe from
+     */
+    unsubscribe(topics) {
+        topics.forEach(topic => {
+            if (this.subscribedTopics.has(topic)) {
+                this.socket.emit('unsubscribe', topic);
+            }
+        });
+    }
+    /**
+     * Unsubscribe from all topics
+     * TODO: To be called when client explicitly disconnects from the server. Alternately, if middleware receives a disconnect request, it can also unsubscribe from all topics from its own side.
+     */
+    unsubscribeFromAll() {
+        this.subscribedTopics.forEach(topic => this.socket.emit('unsubscribe', topic));
+    }
+    /**
+     * Disconnect from the server
+     * TODO: To be called when client explicitly disconnects from the server.
+     */
+    disconnect() {
+        this.socket.disconnect();
+    }
+    static async SubscribeTopics(topics, socket) {
+        if (this.SubscribeTopics_Event !== null)
+            this.SubscribeTopics_Event(topics, socket);
+    }
+}
+
 class ExpressionEvaluator extends GuiExpressionEvaluator {
     static ASTERISK_CHR = String.fromCharCode(1);
     static QUESTION_CHR = String.fromCharCode(2);
@@ -15464,6 +15638,28 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
                 this.eval_op_Hash(val1, val2, resVal);
                 expStrTracker.resetNullResult();
                 break;
+            case ExpressionInterface.EXP_OP_SUBSCRIBE:
+                resVal.Attr = StorageAttribute.BOOLEAN;
+                this.eval_op_Subscribe(valStack);
+                break;
+            case ExpressionInterface.EXP_OP_UNSUBSCRIBE:
+                resVal.Attr = StorageAttribute.BOOLEAN;
+                resVal.BoolVal = this.eval_op_UnSubscribe(valStack);
+                break;
+            case ExpressionInterface.EXP_OP_LOCALTOUTC:
+                val4 = valStack.pop(); // UTC date output variable
+                val3 = valStack.pop(); // UTC time output variable
+                val2 = valStack.pop(); // local date
+                val1 = valStack.pop(); // local time
+                await this.eval_op_localToUTC(resVal, val1, val2, val3, val4);
+                break;
+            case ExpressionInterface.EXP_OP_UTCTOLOCAL:
+                val4 = valStack.pop(); // local date output variable
+                val3 = valStack.pop(); // local time output variable
+                val2 = valStack.pop(); // UTC date
+                val1 = valStack.pop(); // UTC time
+                await this.eval_op_utcToLocal(resVal, val1, val2, val3, val4);
+                break;
             default:
                 return;
         }
@@ -16378,6 +16574,217 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
         resVal.Attr = StorageAttribute.BOOLEAN;
         resVal.BoolVal = true;
     }
+    /**
+     * Safely extracts date/time parts from a JS Date using Intl.DateTimeFormat.
+     *
+     * WHY: Native JS Date has known pitfalls — century year bug (year < 100 mapped to 1900+year),
+     * silent leap year rollovers, DST gaps, and 0-based months. Intl.DateTimeFormat avoids all
+     * of these by using the browser's IANA timezone database internally.
+     *
+     * Used by both eval_op_localToUTC and eval_op_utcToLocal as a single safe extraction point.
+     *
+     * @param date     - A valid JS Date object
+     * @param timeZone - IANA timezone string (e.g. 'Asia/Kolkata', 'UTC').
+     *                   Defaults to browser's local timezone — correct for any user, any country.
+     * @returns Parsed parts (month is 1-based) or null if date is invalid
+     */
+    convertDateTimeParts(date, timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone) {
+        if (!date || isNaN(date.getTime()))
+            return null;
+        // 'en-CA' locale formats date as YYYY-MM-DD — unambiguous and consistent across
+        // all browsers. Other locales like en-US (MM/DD/YYYY) or en-GB (DD/MM/YYYY) can
+        // behave differently across Chrome, Firefox and Safari. Nothing to do with Canada.
+        const formatter = new Intl.DateTimeFormat('en-CA', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false
+        });
+        const parts = formatter.formatToParts(date);
+        const get = (type) => {
+            const part = parts.find(p => p.type === type);
+            if (!part)
+                throw new Error(`Missing date part: ${type}`);
+            return parseInt(part.value, 10);
+        };
+        try {
+            const hour = get('hour');
+            return {
+                year: get('year'),
+                month: get('month'), // 1-based because Intl returns display month (1–12), unlike JS Date.getMonth() which is 0-based
+                day: get('day'),
+                hour: hour === 24 ? 0 : hour, // normalize midnight — some browsers return 24 instead of 0
+                minute: get('minute'),
+                second: get('second')
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Validates that a time value (in total seconds) is within a valid day range
+     */
+    isValidTimeSec(timeSec) {
+        return Number.isInteger(timeSec) && timeSec >= 0 && timeSec <= 86399;
+    }
+    /**
+     * Splits total seconds since midnight into hours, minutes, seconds.
+     * e.g. 3661 → { hours: 1, minutes: 1, seconds: 1 }
+     */
+    splitTimeSec(timeSec) {
+        return {
+            hours: Math.floor(timeSec / 3600),
+            minutes: Math.floor((timeSec % 3600) / 60),
+            seconds: timeSec % 60
+        };
+    }
+    /**
+     * Writes a time (seconds) and date (Magic numeric) into their respective output fields.
+     */
+    async writeDateTimeToFields(timeFld, dateTimeSec, dateFld, dateVal) {
+        const tmpVal = new ExpVal();
+        tmpVal.MgNumVal = new NUM_TYPE();
+        tmpVal.Attr = StorageAttribute.TIME;
+        tmpVal.MgNumVal.NUM_4_LONG(dateTimeSec);
+        await timeFld.setValueAndStartRecompute(tmpVal.ToMgVal(), false, true, false, false);
+        await timeFld.updateDisplay();
+        tmpVal.Attr = StorageAttribute.DATE;
+        tmpVal.MgNumVal.NUM_4_LONG(dateVal);
+        await dateFld.setValueAndStartRecompute(tmpVal.ToMgVal(), false, true, false, false);
+        await dateFld.updateDisplay();
+    }
+    /**
+     * Converts local date/time to UTC and writes the result into output fields.
+     *
+     * Edge cases handled:
+     *  - Century years  — setFullYear() avoids JS year < 100 bug
+     *  - Leap years     — round-trip validation catches silent date rollovers
+     *  - DST gaps       — Intl.DateTimeFormat resolves correctly per IANA tz rules
+     *  - DST ambiguity  — Intl uses first occurrence consistently
+     *  - Cross-midnight — JS Date handles automatically
+     *  - Out-of-range   — time < 0 or > 86399 explicitly rejected
+     *
+     * @param resVal       - Output: Boolean result (true = success)
+     * @param localTimeVal - Input: Local time as total seconds since midnight (Magic numeric)
+     * @param localDateVal - Input: Local date as Magic numeric
+     * @param utcTimeVar   - Input: Field index for the UTC time output field
+     * @param utcDateVar   - Input: Field index for the UTC date output field
+     */
+    async eval_op_localToUTC(resVal, localTimeVal, localDateVal, utcTimeVar, utcDateVar) {
+        resVal.Attr = StorageAttribute.BOOLEAN;
+        resVal.BoolVal = false;
+        // Guard: all four numeric values must be present
+        if (localTimeVal.MgNumVal === null || localDateVal.MgNumVal === null ||
+            utcTimeVar.MgNumVal === null || utcDateVar.MgNumVal === null) {
+            return;
+        }
+        // Fetch output fields
+        const utcDateFld = this.GetFieldOfContextTask(utcDateVar.MgNumVal.NUM_2_LONG());
+        const utcTimeFld = this.GetFieldOfContextTask(utcTimeVar.MgNumVal.NUM_2_LONG());
+        if (utcTimeFld === null || utcDateFld === null)
+            return;
+        // Break the input date into parts
+        const dateParts = new DateBreakParams();
+        DisplayConvertor.Instance.date_break_datemode(dateParts, localDateVal.MgNumVal.NUM_2_LONG(), true, this.ExpTask.getCompIdx());
+        // Reject zero/uninitialized Magic date parts
+        if (dateParts.year === 0 || dateParts.month === 0 || dateParts.day === 0)
+            return;
+        // Guard: reject out-of-range time value
+        const localTimeSec = localTimeVal.MgNumVal.NUM_2_LONG();
+        if (!this.isValidTimeSec(localTimeSec))
+            return;
+        const { hours, minutes, seconds } = this.splitTimeSec(localTimeSec);
+        // Use setFullYear to avoid JS bug where new Date(year < 100, ...) maps to 1900+year
+        const localDateTime = new Date(0);
+        localDateTime.setFullYear(dateParts.year, dateParts.month - 1, dateParts.day);
+        localDateTime.setHours(hours, minutes, seconds, 0);
+        // Guard: round-trip check catches silent rollovers (e.g. Feb 29 on non-leap year)
+        if (localDateTime.getFullYear() !== dateParts.year ||
+            localDateTime.getMonth() !== dateParts.month - 1 ||
+            localDateTime.getDate() !== dateParts.day) {
+            return;
+        }
+        if (isNaN(localDateTime.getTime()))
+            return;
+        // Extract UTC parts via Intl — DST, leap year, century year all handled automatically
+        const utcParts = this.convertDateTimeParts(localDateTime, 'UTC');
+        if (utcParts === null)
+            return;
+        const utcTime = utcParts.hour * 3600 + utcParts.minute * 60 + utcParts.second;
+        const utcDate = DisplayConvertor.Instance.date_4_calender(utcParts.year, utcParts.month, utcParts.day, 1, false // month already 1-based
+        );
+        await this.writeDateTimeToFields(utcTimeFld, utcTime, utcDateFld, utcDate);
+        resVal.BoolVal = true;
+    }
+    /**
+     * Converts UTC date/time to local and writes the result into output fields.
+     *
+     * Edge cases handled:
+     *  - Century years  — Date.UTC() does not have the year < 100 bug
+     *  - Leap years     — round-trip validation catches silent date rollovers
+     *  - DST gaps       — Intl.DateTimeFormat resolves to correct local time automatically
+     *  - DST ambiguity  — Intl uses first occurrence consistently
+     *  - Cross-midnight — JS Date handles automatically
+     *  - Out-of-range   — time < 0 or > 86399 explicitly rejected
+     *
+     * @param resVal       - Output: Boolean result (true = success)
+     * @param utcTimeVal   - Input: UTC time as total seconds since midnight (Magic numeric)
+     * @param utcDateVal   - Input: UTC date as Magic numeric
+     * @param localTimeVar - Input: Field index for the local time output field
+     * @param localDateVar - Input: Field index for the local date output field
+     */
+    async eval_op_utcToLocal(resVal, utcTimeVal, utcDateVal, localTimeVar, localDateVar) {
+        resVal.Attr = StorageAttribute.BOOLEAN;
+        resVal.BoolVal = false;
+        // Guard: all four numeric values must be present
+        if (utcTimeVal.MgNumVal === null || utcDateVal.MgNumVal === null ||
+            localTimeVar.MgNumVal === null || localDateVar.MgNumVal === null) {
+            return;
+        }
+        // Fetch output fields
+        const localDateFld = this.GetFieldOfContextTask(localDateVar.MgNumVal.NUM_2_LONG());
+        const localTimeFld = this.GetFieldOfContextTask(localTimeVar.MgNumVal.NUM_2_LONG());
+        if (localTimeFld === null || localDateFld === null)
+            return;
+        // Break the input date into parts
+        const dateParts = new DateBreakParams();
+        DisplayConvertor.Instance.date_break_datemode(dateParts, utcDateVal.MgNumVal.NUM_2_LONG(), true, this.ExpTask.getCompIdx());
+        // Reject zero/uninitialized Magic date parts
+        if (dateParts.year === 0 || dateParts.month === 0 || dateParts.day === 0)
+            return;
+        // Guard: reject out-of-range time value
+        const utcTimeSec = utcTimeVal.MgNumVal.NUM_2_LONG();
+        if (!this.isValidTimeSec(utcTimeSec))
+            return;
+        const { hours, minutes, seconds } = this.splitTimeSec(utcTimeSec);
+        // Why Date.UTC() instead of new Date(year, month, day, ...)?
+        // JS has a bug: new Date(99, 0, 1) does not give year 99 — it gives 1999.
+        // Date.UTC() always uses the exact year provided — safe for century years like 1900, 2000, 2100
+        const utcDateTime = new Date(Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, hours, minutes, seconds, 0));
+        // Guard: round-trip check catches silent rollovers (e.g. Feb 29 on non-leap year)
+        if (utcDateTime.getUTCFullYear() !== dateParts.year ||
+            utcDateTime.getUTCMonth() !== dateParts.month - 1 ||
+            utcDateTime.getUTCDate() !== dateParts.day) {
+            return;
+        }
+        if (isNaN(utcDateTime.getTime()))
+            return;
+        // Extract local datetime parts via Intl — no timeZone arg = browser's local timezone
+        // DST, leap year, century year all handled automatically
+        const localParts = this.convertDateTimeParts(utcDateTime);
+        if (localParts === null)
+            return;
+        const localTime = localParts.hour * 3600 + localParts.minute * 60 + localParts.second;
+        const localDate = DisplayConvertor.Instance.date_4_calender(localParts.year, localParts.month, localParts.day, 1, false // month already 1-based
+        );
+        await this.writeDateTimeToFields(localTimeFld, localTime, localDateFld, localDate);
+        resVal.BoolVal = true;
+    }
     eval_op_ndow(resVal, val1, displayConvertor) {
         if (val1.MgNumVal === null) {
             super.SetNULL(resVal, StorageAttribute.NUMERIC);
@@ -18556,6 +18963,46 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
         }
         return CryptoJS.lib.WordArray.create(words, u8.length);
     }
+    async eval_op_Subscribe(valStack) {
+        let nArgs = valStack.pop();
+        let result = false;
+        if (nArgs > 0) {
+            // get the parameters
+            let Exp_params = new Array(nArgs);
+            for (let j = 0; j < nArgs; j++) {
+                Exp_params[nArgs - 1 - j] = valStack.pop();
+            }
+            let topics = this.params2arguments(Exp_params, 0, Exp_params.length);
+            let token = await RemoteCommandsProcessor.GetInstance().GetSubscriptionTokenFromServer(topics);
+            let sc = SubscriberClient.getInstance(this.ExpTask);
+            sc.subscribe(topics, token);
+            result = true;
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg('ExpressionEvaluator.Subscribe() there is problem with the arguments');
+            result = false;
+        }
+        return result;
+    }
+    eval_op_UnSubscribe(valStack) {
+        let nArgs = valStack.pop();
+        let result = false;
+        if (nArgs > 0) {
+            // get the parameters
+            let Exp_params = new Array(nArgs);
+            for (let j = 0; j < nArgs; j++) {
+                Exp_params[nArgs - 1 - j] = valStack.pop();
+            }
+            let sc = SubscriberClient.getInstance(this.ExpTask);
+            let topics = this.params2arguments(Exp_params, 0, Exp_params.length);
+            sc.unsubscribe(topics);
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg('ExpressionEvaluator.UnSubscribe() there is problem with the arguments');
+            result = false;
+        }
+        return result;
+    }
 }
 /// <summary>
 ///   This exception used when at least one of the operands is null
@@ -32592,6 +33039,7 @@ class Task extends TaskBase {
         enable = await this.checkProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_ALLOW_INDEX, true);
         this.ActionManager.enable(InternalInterface.MG_ACT_VIEW_BY_KEY, enable);
         this.ActionManager.enable(InternalInterface.MG_ACT_DUMP_ENVIRONMENT, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_PUBSUB_TOPIC_PUBLISHED, true);
     }
     /// <summary>
     ///   set hasZoomHandler to true
@@ -34814,6 +35262,22 @@ class EventsManager {
         }
     }
     /// <summary>
+    /// Add internal to handle published topic from pubsub middleware
+    /// </summary>
+    /// <param name = "task"> control </param>
+    /// <param name = "topic"> value of control </param>
+    /// <param name = "message"> refresh display </param>
+    AddTopicPublishedEvent(task, topic, message) {
+        const rtEvt = new RunTimeEvent(task); //, false);
+        rtEvt.setInternal(InternalInterface.MG_ACT_PUBSUB_TOPIC_PUBLISHED);
+        let argsList = new Array(2);
+        argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, topic);
+        argsList[1] = new ExpVal(StorageAttribute.ALPHA, false, message);
+        let args = new ArgumentsList(argsList);
+        rtEvt.setArgList(args);
+        this.addToTail(rtEvt);
+    }
+    /// <summary>
     ///  Add internal event ro set the value of control
     /// </summary>
     /// <param name = "ctrl"> control </param>
@@ -39642,7 +40106,7 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.1300.0-dev4130.19';
+let CurrentClientVersion = '4.1300.0-dev4130.191';
 
 // @dynamic
 class ClientManager {
@@ -40256,5 +40720,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, 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 };
+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, SubscriberClient, 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