j-templates 8.0.13 → 8.0.15

package/Utils/json.js

@@ -1,232 +1,219 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonMerge = exports.JsonDeepClone = exports.JsonType = exports.JsonDiff = void 0;
-exports.JsonDiffFactory = JsonDiffFactory;
+const jsonProto = Object.getPrototypeOf({});
+const arrayProto = Object.getPrototypeOf([]);
+const strProto = Object.getPrototypeOf("");
+const numProto = Object.getPrototypeOf(0);
+const boolProto = Object.getPrototypeOf(false);
 /**
- * Factory that creates JSON utility functions for diffing, merging, and cloning.
- * @returns Object containing JsonDiff, JsonType, JsonDeepClone, and JsonMerge functions
+ * Determines the JSON type of a value.
+ * @param value - The value to check
+ * @returns "value" for primitives/null/undefined, "object" for plain objects, "array" for arrays
  */
-function JsonDiffFactory() {
-    const jsonProto = Object.getPrototypeOf({});
-    const arrayProto = Object.getPrototypeOf([]);
-    const strProto = Object.getPrototypeOf("");
-    const numProto = Object.getPrototypeOf(0);
-    const boolProto = Object.getPrototypeOf(false);
-    /**
-     * Determines the JSON type of a value.
-     * @param value - The value to check
-     * @returns "value" for primitives/null/undefined, "object" for plain objects, "array" for arrays
-     */
-    function JsonType(value) {
-        if (value === null || value === undefined)
+export function JsonType(value) {
+    if (value === null || value === undefined)
+        return "value";
+    switch (Object.getPrototypeOf(value)) {
+        case strProto:
+        case numProto:
+        case boolProto:
             return "value";
-        switch (Object.getPrototypeOf(value)) {
-            case strProto:
-            case numProto:
-            case boolProto:
-                return "value";
-            case jsonProto:
-                return "object";
-            case arrayProto:
-                return "array";
-        }
-        if (Array.isArray(value))
+        case jsonProto:
+            return "object";
+        case arrayProto:
             return "array";
-        return "value";
     }
-    /**
-     * Deep merges a patch into a source value.
-     * - If types don't match, returns the patch
-     * - For objects: recursively merges properties, adds new properties
-     * - For arrays: maps over patch, merging with corresponding source elements
-     * @param source - The original value
-     * @param patch - The value to merge into source
-     * @returns The merged result
-     */
-    function JsonMerge(source, patch) {
-        if (patch === undefined)
-            return JsonDeepClone(source);
-        const sourceType = JsonType(source);
-        const patchType = JsonType(patch);
-        if (sourceType !== patchType)
-            return patch;
-        switch (sourceType) {
-            case "array": {
-                const typedSource = source;
-                const typedPatch = patch;
-                const result = new Array(typedPatch.length);
-                for (let x = 0; x < typedPatch.length; x++)
-                    result[x] = JsonMerge(typedSource[x], typedPatch[x]);
-                return result;
+    if (Array.isArray(value))
+        return "array";
+    return "value";
+}
+/**
+ * Deep merges a patch into a source value.
+ * - If types don't match, returns the patch
+ * - For objects: recursively merges properties, adds new properties
+ * - For arrays: maps over patch, merging with corresponding source elements
+ * @param source - The original value
+ * @param patch - The value to merge into source
+ * @returns The merged result
+ */
+export function JsonMerge(source, patch) {
+    if (patch === undefined)
+        return JsonDeepClone(source);
+    const sourceType = JsonType(source);
+    const patchType = JsonType(patch);
+    if (sourceType !== patchType)
+        return patch;
+    switch (sourceType) {
+        case "array": {
+            const typedSource = source;
+            const typedPatch = patch;
+            const result = new Array(typedPatch.length);
+            for (let x = 0; x < typedPatch.length; x++)
+                result[x] = JsonMerge(typedSource[x], typedPatch[x]);
+            return result;
+        }
+        case "object": {
+            const typedSource = source;
+            const typedPatch = patch;
+            const sourceKeys = Object.keys(typedSource);
+            const targetKeys = Object.keys(typedPatch).filter((key) => !sourceKeys.includes(key));
+            const result = {};
+            for (let x = 0; x < sourceKeys.length; x++) {
+                result[sourceKeys[x]] = JsonMerge(typedSource[sourceKeys[x]], typedPatch[sourceKeys[x]]);
             }
-            case "object": {
-                const typedSource = source;
-                const typedPatch = patch;
-                const sourceKeys = Object.keys(typedSource);
-                const targetKeys = Object.keys(typedPatch).filter((key) => !sourceKeys.includes(key));
-                const result = {};
-                for (let x = 0; x < sourceKeys.length; x++) {
-                    result[sourceKeys[x]] = JsonMerge(typedSource[sourceKeys[x]], typedPatch[sourceKeys[x]]);
-                }
-                for (let x = 0; x < targetKeys.length; x++) {
-                    result[targetKeys[x]] = typedPatch[targetKeys[x]];
-                }
-                return result;
+            for (let x = 0; x < targetKeys.length; x++) {
+                result[targetKeys[x]] = typedPatch[targetKeys[x]];
             }
-            default:
-                return patch;
+            return result;
         }
+        default:
+            return patch;
     }
-    /**
-     * Creates a deep clone of a JSON-compatible value.
-     * @template T - The type of the value to clone
-     * @param value - The value to clone
-     * @returns A deep clone of the value
-     */
-    function JsonDeepClone(value, type = JsonType(value)) {
-        switch (type) {
+}
+/**
+ * Creates a deep clone of a JSON-compatible value.
+ * @template T - The type of the value to clone
+ * @param value - The value to clone
+ * @returns A deep clone of the value
+ */
+export function JsonDeepClone(value, type = JsonType(value)) {
+    switch (type) {
+        case "array": {
+            const typed = value;
+            const result = new Array(typed.length);
+            for (let x = 0; x < typed.length; x++)
+                result[x] = JsonDeepClone(typed[x]);
+            return result;
+        }
+        case "object": {
+            const ret = {};
+            const keys = Object.keys(value);
+            for (let x = 0; x < keys.length; x++)
+                ret[keys[x]] = JsonDeepClone(value[keys[x]]);
+            return ret;
+        }
+        default:
+            return value;
+    }
+}
+/**
+ * Computes the differences between two JSON values.
+ * Returns an array of paths and values that changed from oldValue to newValue.
+ * @template T - The type of the JSON values being compared
+ * @param newValue - The new value
+ * @param oldValue - The old value to compare against
+ * @param rootPath - Optional dot-separated string for the base path (for internal recursion)
+ * @param initResult - Optional initial result array (for internal recursion)
+ * @returns Array of change records with path and new value
+ */
+export function JsonDiff(newValue, oldValue, rootPath, initResult) {
+    const result = initResult ?? [];
+    const startPath = rootPath ? rootPath.split(".") : [];
+    JsonDiffRecursive(startPath, newValue, oldValue, result);
+    return result;
+}
+/**
+ * Recursive helper for JsonDiff that traverses and compares values.
+ * @internal
+ * @param path - Current path being evaluated
+ * @param newValue - New value at this path
+ * @param oldValue - Old value at this path
+ * @param resp - Result array to populate with changes
+ * @returns true if the entire subtree changed, false otherwise
+ */
+function JsonDiffRecursive(path, newValue, oldValue, resp) {
+    if (newValue === oldValue)
+        return false;
+    const newType = JsonType(newValue);
+    const oldType = JsonType(oldValue);
+    const changedPathLength = resp.length;
+    let allChildrenChanged = true;
+    if (newType === oldType)
+        switch (newType) {
             case "array": {
-                const typed = value;
-                const result = new Array(typed.length);
-                for (let x = 0; x < typed.length; x++)
-                    result[x] = JsonDeepClone(typed[x]);
-                return result;
+                allChildrenChanged = JsonDiffArrays(path, newValue, oldValue, resp);
+                break;
             }
             case "object": {
-                const ret = {};
-                const keys = Object.keys(value);
-                for (let x = 0; x < keys.length; x++)
-                    ret[keys[x]] = JsonDeepClone(value[keys[x]]);
-                return ret;
+                allChildrenChanged = JsonDiffObjects(path, newValue, oldValue, resp);
+                break;
             }
-            default:
-                return value;
         }
+    if (allChildrenChanged) {
+        resp.length > changedPathLength && resp.splice(changedPathLength);
+        resp.push({
+            path,
+            value: newValue,
+        });
+        return true;
     }
-    /**
-     * Computes the differences between two JSON values.
-     * Returns an array of paths and values that changed from oldValue to newValue.
-     * @template T - The type of the JSON values being compared
-     * @param newValue - The new value
-     * @param oldValue - The old value to compare against
-     * @param rootPath - Optional dot-separated string for the base path (for internal recursion)
-     * @param initResult - Optional initial result array (for internal recursion)
-     * @returns Array of change records with path and new value
-     */
-    function JsonDiff(newValue, oldValue, rootPath, initResult) {
-        const result = initResult ?? [];
-        const startPath = rootPath ? rootPath.split(".") : [];
-        JsonDiffRecursive(startPath, newValue, oldValue, result);
-        return result;
+    return false;
+}
+/**
+ * Compares two arrays and records differences.
+ * @internal
+ * @param path - Current path being evaluated
+ * @param newValue - New array
+ * @param oldValue - Old array to compare against
+ * @param resp - Result array to populate with changes
+ * @returns true if the entire array changed, false otherwise
+ */
+function JsonDiffArrays(path, newValue, oldValue, resp) {
+    if (oldValue.length === 0 || newValue.length === 0) {
+        return oldValue.length !== newValue.length;
     }
-    /**
-     * Recursive helper for JsonDiff that traverses and compares values.
-     * @internal
-     * @param path - Current path being evaluated
-     * @param newValue - New value at this path
-     * @param oldValue - Old value at this path
-     * @param resp - Result array to populate with changes
-     * @returns true if the entire subtree changed, false otherwise
-     */
-    function JsonDiffRecursive(path, newValue, oldValue, resp) {
-        if (newValue === oldValue)
-            return false;
-        const newType = JsonType(newValue);
-        const oldType = JsonType(oldValue);
-        const changedPathLength = resp.length;
-        let allChildrenChanged = true;
-        if (newType === oldType)
-            switch (newType) {
-                case "array": {
-                    allChildrenChanged = JsonDiffArrays(path, newValue, oldValue, resp);
-                    break;
-                }
-                case "object": {
-                    allChildrenChanged = JsonDiffObjects(path, newValue, oldValue, resp);
-                    break;
-                }
-            }
-        if (allChildrenChanged) {
-            resp.length > changedPathLength && resp.splice(changedPathLength);
-            resp.push({
-                path,
-                value: newValue,
-            });
-            return true;
+    let allChildrenChanged = true;
+    if (newValue.length > 0 || oldValue.length > 0) {
+        for (let y = 0; y < newValue.length; y++) {
+            const arrayPath = path.concat(y);
+            const oldValueElem = oldValue[y];
+            allChildrenChanged =
+                JsonDiffRecursive(arrayPath, newValue[y], oldValueElem, resp) &&
+                    allChildrenChanged;
         }
-        return false;
     }
-    /**
-     * Compares two arrays and records differences.
-     * @internal
-     * @param path - Current path being evaluated
-     * @param newValue - New array
-     * @param oldValue - Old array to compare against
-     * @param resp - Result array to populate with changes
-     * @returns true if the entire array changed, false otherwise
-     */
-    function JsonDiffArrays(path, newValue, oldValue, resp) {
-        if (oldValue.length === 0 || newValue.length === 0) {
-            return oldValue.length !== newValue.length;
-        }
-        let allChildrenChanged = true;
-        if (newValue.length > 0 || oldValue.length > 0) {
-            for (let y = 0; y < newValue.length; y++) {
-                const arrayPath = path.concat(y);
-                const oldValueElem = oldValue[y];
-                allChildrenChanged =
-                    JsonDiffRecursive(arrayPath, newValue[y], oldValueElem, resp) &&
-                        allChildrenChanged;
-            }
+    else
+        allChildrenChanged = false;
+    if (newValue.length !== oldValue.length)
+        resp.push({
+            path: path.concat("length"),
+            value: newValue.length,
+        });
+    return allChildrenChanged;
+}
+/**
+ * Compares two objects and records differences.
+ * Uses sorted keys and two-pointer technique for efficient comparison.
+ * @internal
+ * @param path - Current path being evaluated
+ * @param newValue - New object
+ * @param oldValue - Old object to compare against
+ * @param resp - Result array to populate with changes
+ * @returns true if the entire object should be replaced (keys removed), false otherwise
+ */
+function JsonDiffObjects(path, newValue, oldValue, resp) {
+    const newKeys = Object.keys(newValue).sort();
+    const oldKeys = Object.keys(oldValue).sort();
+    if (newKeys.length === 0 && oldKeys.length === 0)
+        return false;
+    if (newKeys.length < oldKeys.length)
+        return true;
+    let newKeyIndex = 0;
+    let oldKeyIndex = 0;
+    while (newKeyIndex < newKeys.length) {
+        const childPath = path.concat(newKeys[newKeyIndex]);
+        if (oldKeyIndex < oldKeys.length &&
+            newKeys[newKeyIndex] === oldKeys[oldKeyIndex]) {
+            JsonDiffRecursive(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp);
+            oldKeyIndex++;
         }
-        else
-            allChildrenChanged = false;
-        if (newValue.length !== oldValue.length)
+        else if (newValue[newKeys[newKeyIndex]] !== undefined) {
             resp.push({
-                path: path.concat("length"),
-                value: newValue.length,
+                path: childPath,
+                value: newValue[newKeys[newKeyIndex]],
             });
-        return allChildrenChanged;
-    }
-    /**
-     * Compares two objects and records differences.
-     * Uses sorted keys and two-pointer technique for efficient comparison.
-     * @internal
-     * @param path - Current path being evaluated
-     * @param newValue - New object
-     * @param oldValue - Old object to compare against
-     * @param resp - Result array to populate with changes
-     * @returns true if the entire object should be replaced (keys removed), false otherwise
-     */
-    function JsonDiffObjects(path, newValue, oldValue, resp) {
-        const newKeys = Object.keys(newValue).sort();
-        const oldKeys = Object.keys(oldValue).sort();
-        if (newKeys.length === 0 && oldKeys.length === 0)
-            return false;
-        if (newKeys.length < oldKeys.length)
-            return true;
-        let newKeyIndex = 0;
-        let oldKeyIndex = 0;
-        while (newKeyIndex < newKeys.length) {
-            const childPath = path.concat(newKeys[newKeyIndex]);
-            if (oldKeyIndex < oldKeys.length &&
-                newKeys[newKeyIndex] === oldKeys[oldKeyIndex]) {
-                JsonDiffRecursive(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp);
-                oldKeyIndex++;
-            }
-            else if (newValue[newKeys[newKeyIndex]] !== undefined) {
-                resp.push({
-                    path: childPath,
-                    value: newValue[newKeys[newKeyIndex]],
-                });
-            }
-            newKeyIndex++;
         }
-        if (oldKeyIndex < oldKeys.length)
-            return true;
-        return false;
+        newKeyIndex++;
     }
-    return { JsonDiff, JsonType, JsonDeepClone, JsonMerge };
+    if (oldKeyIndex < oldKeys.length)
+        return true;
+    return false;
 }
-_a = JsonDiffFactory(), exports.JsonDiff = _a.JsonDiff, exports.JsonType = _a.JsonType, exports.JsonDeepClone = _a.JsonDeepClone, exports.JsonMerge = _a.JsonMerge;

package/Utils/list.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.List = void 0;
-var List;
+export var List;
 (function (List) {
     function CreateNode(data) {
         return { previous: null, next: null, data };
@@ -223,4 +220,4 @@ var List;
         return map;
     }
     List.ToListMap = ToListMap;
-})(List || (exports.List = List = {}));
+})(List || (List = {}));

package/Utils/scheduling.js

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._requestIdleCallback = exports._queueMicrotask = exports._setTimeout = exports._requestAnimationFrame = void 0;
 const IMMEDIATE_OVERRIDE = typeof process !== "undefined" ?
     process.env.SYNC_SCHEDULING === 'true' :
     false;
-exports._requestAnimationFrame = IMMEDIATE_OVERRIDE ?
+export const _requestAnimationFrame = IMMEDIATE_OVERRIDE ?
     function immediateRequestAnimationFrame(callback) {
         callback(0);
         return 0;
     } : window.requestAnimationFrame;
-exports._setTimeout = IMMEDIATE_OVERRIDE ?
+export const _setTimeout = IMMEDIATE_OVERRIDE ?
     function immediateSetTimeout(handler, timeout, ...args) {
         if (typeof handler === "function")
             handler(...args);
         return 0;
     } : window.setTimeout;
-exports._queueMicrotask = IMMEDIATE_OVERRIDE ?
+export const _queueMicrotask = IMMEDIATE_OVERRIDE ?
     function immediateQueueMicrotask(callback) {
         callback();
     } : window.queueMicrotask;
-exports._requestIdleCallback = IMMEDIATE_OVERRIDE ?
+export const _requestIdleCallback = IMMEDIATE_OVERRIDE ?
     function immediateRequestIdleCallback(callback, options) {
         callback({ didTimeout: false, timeRemaining: () => 0 });
         return 0;

package/Utils/thread.js

@@ -1,13 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Schedule = Schedule;
-exports.After = After;
-exports.Callback = Callback;
-exports.Synch = Synch;
-exports.Thread = Thread;
-exports.ThreadAsync = ThreadAsync;
-const list_1 = require("./list");
-const scheduling_1 = require("./scheduling");
+import { List } from "./list";
+import { _queueMicrotask, _setTimeout } from "./scheduling";
 // Constants
 /**
  * The maximum time allowed for work execution in milliseconds
@@ -16,7 +8,7 @@ const workTimeMs = 16;
 /**
  * Queue of thread contexts that need processing
  */
-const contextQueue = list_1.List.Create();
+const contextQueue = List.Create();
 // State variables
 let threadContext = null;
 let timeoutRunning = false;
@@ -44,10 +36,10 @@ function createDeadline() {
  */
 function ProcessQueue(deadline = createDeadline()) {
     let ctx;
-    while (deadline.timeRemaining() > 0 && (ctx = list_1.List.Pop(contextQueue)))
+    while (deadline.timeRemaining() > 0 && (ctx = List.Pop(contextQueue)))
         DoWork(ctx, deadline);
     if (contextQueue.size > 0)
-        (0, scheduling_1._setTimeout)(ProcessQueue);
+        _setTimeout(ProcessQueue);
     else
         timeoutRunning = false;
 }
@@ -56,11 +48,11 @@ function ProcessQueue(deadline = createDeadline()) {
  * @param ctx - The thread context to schedule
  */
 function ScheduleWork(ctx) {
-    list_1.List.Add(contextQueue, ctx);
+    List.Add(contextQueue, ctx);
     if (timeoutRunning)
         return;
     timeoutRunning = true;
-    (0, scheduling_1._queueMicrotask)(ProcessQueue);
+    _queueMicrotask(ProcessQueue);
 }
 /**
  * Invokes a callback in the specified thread context
@@ -85,7 +77,7 @@ function DoWork(ctx, deadline = createDeadline()) {
     let callback;
     while (async === ctx.async &&
         deadline.timeRemaining() > 0 &&
-        (callback = list_1.List.Pop(ctx.workList)))
+        (callback = List.Pop(ctx.workList)))
         Invoke(ctx, callback);
     if (ctx.workList.size > 0)
         ScheduleWork(ctx);
@@ -99,7 +91,7 @@ function CreateContext() {
     return {
         async: false,
         workEndNode: null,
-        workList: list_1.List.Create(),
+        workList: List.Create(),
     };
 }
 /**
@@ -112,11 +104,11 @@ function ScheduleCallback(callback, before, async) {
     threadContext = threadContext || CreateContext();
     threadContext.async = threadContext.async || async;
     if (before)
-        list_1.List.AddBefore(threadContext.workList, threadContext.workEndNode, callback);
+        List.AddBefore(threadContext.workList, threadContext.workEndNode, callback);
     else if (threadContext.workEndNode)
-        list_1.List.AddAfter(threadContext.workList, threadContext.workEndNode, callback);
+        List.AddAfter(threadContext.workList, threadContext.workEndNode, callback);
     else
-        threadContext.workEndNode = list_1.List.Add(threadContext.workList, callback);
+        threadContext.workEndNode = List.Add(threadContext.workList, callback);
 }
 /**
  * Executes a callback synchronously without using threading
@@ -135,14 +127,14 @@ function SynchWithoutThread(callback) {
  * Schedules a callback to run asynchronously
  * @param callback - The callback function to schedule
  */
-function Schedule(callback) {
+export function Schedule(callback) {
     ScheduleCallback(callback, true, true);
 }
 /**
  * Schedules a callback to run after existing callbacks in the same context
  * @param callback - The callback function to schedule
  */
-function After(callback) {
+export function After(callback) {
     ScheduleCallback(callback, false, false);
 }
 /**
@@ -150,7 +142,7 @@ function After(callback) {
  * @param callback - The original callback function
  * @returns A wrapped function that schedules execution
  */
-function Callback(callback) {
+export function Callback(callback) {
     return function (a, b, c, d) {
         Schedule(function () {
             callback(a, b, c, d);
@@ -165,7 +157,7 @@ var inSynchCallback = false;
  * Executes a callback synchronously or asynchronously based on context
  * @param callback - The callback function to execute
  */
-function Synch(callback) {
+export function Synch(callback) {
     if (threadContext || inSynchCallback)
         callback(false);
     else {
@@ -178,7 +170,7 @@ function Synch(callback) {
  * Schedules a callback that can run either synchronously or asynchronously
  * @param callback - The callback function to schedule
  */
-function Thread(callback) {
+export function Thread(callback) {
     if (threadContext)
         ScheduleCallback(callback, true, false);
     else
@@ -189,7 +181,7 @@ function Thread(callback) {
  * @param callback - The callback function to execute
  * @returns A promise that resolves when the callback completes
  */
-function ThreadAsync(callback) {
+export function ThreadAsync(callback) {
     return new Promise((resolve) => Thread(function (async) {
         callback(async);
         Thread(resolve);

package/Utils/utils.types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/_not_used/array.js

@@ -1,10 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayDiff = ArrayDiff;
-exports.ReconcileSortedEmitters = ReconcileSortedEmitters;
-exports.InsertionSortTuples = InsertionSortTuples;
-exports.ReconcileSortedArrays = ReconcileSortedArrays;
-function ArrayDiff(source, target) {
+export function ArrayDiff(source, target) {
     if (source === target)
         return false;
     if (!source || !target || source.length !== target.length)
@@ -44,7 +38,7 @@ function ArrayDiff(source, target) {
  * // Adds [2, 4] and removes [1]
  * ```
  */
-function ReconcileSortedEmitters(left, right, add, remove) {
+export function ReconcileSortedEmitters(left, right, add, remove) {
     let leftIndex = 0;
     let rightIndex = 0;
     while (leftIndex < left.length && rightIndex < right.length) {
@@ -68,7 +62,7 @@ function ReconcileSortedEmitters(left, right, add, remove) {
     for (let ri = rightIndex; ri < right.length; ri++)
         add(right[ri]);
 }
-function InsertionSortTuples(arr) {
+export function InsertionSortTuples(arr) {
     const n = arr.length;
     // Start from the second element (index 1) as the first element (index 0)
     // is trivially sorted by itself.
@@ -89,7 +83,7 @@ function InsertionSortTuples(arr) {
     }
     return arr;
 }
-function ReconcileSortedArrays(left, right, add, remove) {
+export function ReconcileSortedArrays(left, right, add, remove) {
     let leftIndex = 0;
     let rightIndex = 0;
     while (leftIndex < left.length && rightIndex < right.length) {