j-templates 7.0.74 → 7.0.76

package/Utils/emitter.d.ts

@@ -1,11 +1,9 @@
 export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => void;
-export type Emitter = [number, ...EmitterCallback[]];
+export type Emitter = EmitterCallback[];
 export declare namespace Emitter {
     function Create(): Emitter;
-    function GetId(emitter: Emitter): number;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
-    function Destroy(emitter: Emitter): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
     function Clear(emitter: Emitter): void;
 }

package/Utils/emitter.js

@@ -1,30 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
-const idPool = [];
-let idPoolIndex = 0;
-let globalId = 0;
 var Emitter;
 (function (Emitter) {
     function Create() {
-        const emitterId = idPoolIndex === 0 ? ++globalId : idPool[--idPoolIndex];
-        const emitter = [emitterId];
-        return emitter;
+        return [];
     }
     Emitter.Create = Create;
-    function GetId(emitter) {
-        return emitter[0];
-    }
-    Emitter.GetId = GetId;
     function On(emitter, callback) {
         emitter.push(callback);
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
-        if (emitter[0] === -1)
-            return;
-        let writePos = 1;
-        for (let x = 1; x < emitter.length; x++) {
+        let writePos = 0;
+        for (let x = 0; x < emitter.length; x++) {
             if (emitter[x] !== null) {
                 emitter[x](...args);
                 emitter[writePos++] = emitter[x];
@@ -34,21 +23,14 @@ var Emitter;
             emitter.splice(writePos);
     }
     Emitter.Emit = Emit;
-    function Destroy(emitter) {
-        idPool[idPoolIndex++] = emitter[0];
-        emitter[0] = -1;
-    }
-    Emitter.Destroy = Destroy;
     function Remove(emitter, callback) {
-        if (emitter[0] === -1)
-            return;
         const index = emitter.indexOf(callback);
-        if (index >= 1)
+        if (index >= 0)
             emitter[index] = null;
     }
     Emitter.Remove = Remove;
     function Clear(emitter) {
-        emitter.splice(1);
+        emitter.splice(0);
     }
     Emitter.Clear = Clear;
 })(Emitter || (exports.Emitter = Emitter = {}));

package/Utils/functions.d.ts

@@ -1 +1,6 @@
+/**
+ * Checks if a function is an async function.
+ * @param func - The function to check
+ * @returns true if the function is async, false otherwise
+ */
 export declare function IsAsync(func: Function): boolean;

package/Utils/functions.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsAsync = IsAsync;
+/**
+ * Checks if a function is an async function.
+ * @param func - The function to check
+ * @returns true if the function is async, false otherwise
+ */
 function IsAsync(func) {
     return func[Symbol.toStringTag] === "AsyncFunction";
 }

package/Utils/json.d.ts

@@ -1,8 +1,18 @@
+/**
+ * Result of a JSON diff operation, containing paths and values that changed.
+ * @template T - The type of the JSON value being diffed
+ */
 export type JsonDiffResult<T = unknown> = {
+    /** Array path segments (strings for object keys, numbers for array indices) */
     path: (string | number)[];
+    /** The new value at this path */
     value: unknown;
 }[];
 export type JsonDiffFactoryResult = ReturnType<typeof JsonDiffFactory>;
+/**
+ * Factory that creates JSON utility functions for diffing, merging, and cloning.
+ * @returns Object containing JsonDiff, JsonType, JsonDeepClone, and JsonMerge functions
+ */
 export declare function JsonDiffFactory(): {
     JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
     JsonType: (value: any) => "object" | "value" | "array";

package/Utils/json.js

@@ -3,12 +3,21 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonMerge = exports.JsonDeepClone = exports.JsonType = exports.JsonDiff = void 0;
 exports.JsonDiffFactory = JsonDiffFactory;
+/**
+ * Factory that creates JSON utility functions for diffing, merging, and cloning.
+ * @returns Object containing JsonDiff, JsonType, JsonDeepClone, and JsonMerge functions
+ */
 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)
             return "value";
@@ -26,6 +35,15 @@ function JsonDiffFactory() {
             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);
@@ -46,7 +64,7 @@ function JsonDiffFactory() {
                 const typedSource = source;
                 const typedPatch = patch;
                 const sourceKeys = Object.keys(typedSource);
-                const targetKeys = Object.keys(typedPatch).filter(key => !sourceKeys.includes(key));
+                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]]);
@@ -60,6 +78,12 @@ function JsonDiffFactory() {
                 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) {
         const type = JsonType(value);
         switch (type) {
@@ -81,12 +105,31 @@ function JsonDiffFactory() {
                 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
+     */
     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;
@@ -115,6 +158,15 @@ function JsonDiffFactory() {
         }
         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;
@@ -138,6 +190,16 @@ function JsonDiffFactory() {
             allChildrenChanged = false;
         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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "7.0.74",
+  "version": "7.0.76",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",

package/Utils/bitSet.d.ts

@@ -1,23 +0,0 @@
-export type BitSet = {
-    init: boolean;
-    buffer: Uint32Array | null;
-    activeFrames: Set<number>;
-    minFrame: number;
-    maxFrame: number;
-};
-export type BitSetPool = {
-    pool: BitSet[];
-    index: number;
-};
-export declare namespace BitSetPool {
-    function Create(): BitSetPool;
-    function Get(pool: BitSetPool): BitSet;
-    function Return(pool: BitSetPool, bitSet: BitSet): void;
-}
-export declare namespace BitSet {
-    function Create(): BitSet;
-    function set(set: BitSet, num: number): void;
-    function has(set: BitSet, num: number): boolean;
-    function add(set: BitSet, num: number): boolean;
-    function remove(set: BitSet, num: number): boolean;
-}

package/Utils/bitSet.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitSet = exports.BitSetPool = void 0;
-// 100000 = 31
-const FRAME_BIT_SHIFT = 5;
-const DEFAULT_FRAME_COUNT = 1024;
-const DEFAULT_FRAME_HALF = DEFAULT_FRAME_COUNT / 2;
-function GetFrame(number) {
-    // Effectively equivalent to Math.floor(number / 32)
-    return number >>> FRAME_BIT_SHIFT;
-}
-function GetBit(number) {
-    // JavaScript only uses rightmost 5 bits of num for this operation
-    // Effectively equivalent to number % 32
-    return 1 << number;
-}
-function Resize(set, frame) {
-    if (set.minFrame <= frame && frame < set.maxFrame)
-        return;
-    const currentSize = set.maxFrame - set.minFrame;
-    let newMin = Math.min(set.minFrame, frame);
-    let newMax = Math.max(set.maxFrame, frame + 1);
-    let newSize = newMax - newMin;
-    const minimumNewSize = currentSize * 2;
-    if (newSize < minimumNewSize) {
-        const growBy = minimumNewSize - newSize;
-        const growByHalf = growBy / 2;
-        newMin = newMin - Math.floor(growByHalf);
-        newMax = newMax + Math.ceil(growByHalf);
-        if (newMin < 0) {
-            newMax -= newMin;
-            newMin = 0;
-        }
-        newSize = newMax - newMin;
-    }
-    const newBuffer = new Uint32Array(newSize);
-    newBuffer.set(set.buffer, set.minFrame - newMin);
-    set.buffer = newBuffer;
-    set.minFrame = newMin;
-    set.maxFrame = newMax;
-}
-function Initialize(set, initFrameNumber) {
-    if (set.init)
-        return;
-    set.init = true;
-    set.activeFrames.clear();
-    const frame = GetFrame(initFrameNumber);
-    const sizeHalf = (set.buffer?.length ?? DEFAULT_FRAME_COUNT) / 2;
-    set.buffer ??= new Uint32Array(DEFAULT_FRAME_COUNT);
-    set.minFrame = frame - Math.floor(sizeHalf);
-    set.maxFrame = frame + Math.ceil(sizeHalf);
-    if (set.minFrame < 0) {
-        set.maxFrame -= set.minFrame;
-        set.minFrame = 0;
-    }
-}
-var BitSetPool;
-(function (BitSetPool) {
-    function Create() {
-        return {
-            pool: [],
-            index: 0
-        };
-    }
-    BitSetPool.Create = Create;
-    function Get(pool) {
-        return pool.index === 0 ? BitSet.Create() : pool.pool[--pool.index];
-    }
-    BitSetPool.Get = Get;
-    function Return(pool, bitSet) {
-        bitSet.init = false;
-        pool.pool[pool.index++] = bitSet;
-    }
-    BitSetPool.Return = Return;
-})(BitSetPool || (exports.BitSetPool = BitSetPool = {}));
-var BitSet;
-(function (BitSet) {
-    function Create() {
-        return {
-            init: false,
-            buffer: null,
-            activeFrames: new Set(),
-            minFrame: -1,
-            maxFrame: -1,
-        };
-    }
-    BitSet.Create = Create;
-    function set(set, num) {
-        Initialize(set, num);
-        const frame = GetFrame(num);
-        Resize(set, frame);
-        if (!set.activeFrames.has(frame)) {
-            set.buffer[frame] = 0;
-            set.activeFrames.add(frame);
-        }
-        const frameOffset = frame - set.minFrame;
-        set.buffer[frameOffset] |= GetBit(num);
-    }
-    BitSet.set = set;
-    function has(set, num) {
-        if (set.buffer === null)
-            return false;
-        const frame = GetFrame(num);
-        if (!set.activeFrames.has(frame))
-            return false;
-        if (frame < set.minFrame || set.maxFrame <= frame)
-            return false;
-        const frameOffset = frame - set.minFrame;
-        const frameValue = set.buffer[frameOffset] & GetBit(num);
-        return frameValue !== 0;
-    }
-    BitSet.has = has;
-    function add(set, num) {
-        Initialize(set, num);
-        const frame = GetFrame(num);
-        Resize(set, frame);
-        if (!set.activeFrames.has(frame)) {
-            set.buffer[frame] = 0;
-            set.activeFrames.add(frame);
-        }
-        const frameOffset = frame - set.minFrame;
-        const frameStart = set.buffer[frameOffset];
-        set.buffer[frameOffset] |= GetBit(num);
-        return frameStart !== set.buffer[frameOffset];
-    }
-    BitSet.add = add;
-    function remove(set, num) {
-        if (set.buffer === null)
-            return false;
-        const frame = GetFrame(num);
-        if (!set.activeFrames.has(frame) || frame < set.minFrame || set.maxFrame <= frame)
-            return false;
-        const frameOffset = frame - set.minFrame;
-        const frameStart = set.buffer[frameOffset];
-        set.buffer[frameOffset] ^= GetBit(num);
-        return frameStart !== set.buffer[frameOffset];
-    }
-    BitSet.remove = remove;
-})(BitSet || (exports.BitSet = BitSet = {}));

package/Utils/jsonType.d.ts

@@ -1 +0,0 @@
-export { JsonType } from './json';

package/Utils/jsonType.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonType = void 0;
-var json_1 = require("./json");
-Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return json_1.JsonType; } });