@magic-xpa/engine 4.1300.0-dev4130.183 → 4.1300.0-dev4130.185

package/fesm2022/magic-xpa-engine.mjs

@@ -1,6 +1,6 @@
 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';
@@ -9784,6 +9784,10 @@ class ExpressionDict {
         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 */
     ];
 }
 
@@ -15642,6 +15646,20 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
                 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;
         }
@@ -16556,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);
@@ -39877,7 +40106,7 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.1300.0-dev4130.183';
+let CurrentClientVersion = '4.1300.0-dev4130.185';
 
 // @dynamic
 class ClientManager {