j-templates 7.0.74 → 7.0.76

package/Store/Diff/diffTree.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiffTreeFactory = DiffTreeFactory;
+/**
+ * Factory function that creates a DiffTree class.
+ * Can operate in worker mode for async operations.
+ * @param jsonDiffFactory - Optional factory for JSON diff utilities
+ * @param worker - If true, sets up worker message handling
+ * @returns DiffTree constructor
+ */
 function DiffTreeFactory(jsonDiffFactory, worker) {
     const { JsonDiff, JsonType, JsonDeepClone } = jsonDiffFactory();
     const ctx = this;
@@ -35,6 +42,13 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
             }
         };
     }
+    /**
+     * Flattens nested objects/arrays, extracting keyed objects to root.
+     * @param root - Root object to store flattened values
+     * @param value - Value to flatten
+     * @param keyFunc - Function to extract key from objects
+     * @returns The root object with flattened values
+     */
     function FlattenValue(root, value, keyFunc) {
         const type = JsonType(value);
         switch (type) {
@@ -54,6 +68,12 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
         }
         return root;
     }
+    /**
+     * Retrieves a value from a source object using a dot-separated path.
+     * @param source - The source object
+     * @param path - Dot-separated path to the value (empty string returns source)
+     * @returns The value at the specified path
+     */
     function GetPathValue(source, path) {
         if (path === "")
             return source;
@@ -63,6 +83,12 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
             curr = curr[parts[x]];
         return curr;
     }
+    /**
+     * Sets a value in a source object at the specified path.
+     * @param source - The source object
+     * @param path - Array of path segments (strings for keys, numbers for indices)
+     * @param value - The value to set
+     */
     function SetPathValue(source, path, value) {
         if (path.length === 0)
             return;
@@ -72,6 +98,14 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
             curr = curr[path[x]];
         curr[path[x]] = value;
     }
+    /**
+     * Resolves a path to its keyed root object if applicable.
+     * Searches up the path to find an object with a key from keyFunc.
+     * @param source - The source object
+     * @param path - Dot-separated path
+     * @param keyFunc - Function to extract key from objects
+     * @returns The resolved path (possibly shortened to root key)
+     */
     function ResolveKeyPath(source, path, keyFunc) {
         const parts = path.split(".");
         const pathValues = new Array(parts.length - 1);
@@ -90,6 +124,15 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
         }
         return path;
     }
+    /**
+     * Updates the source with a new value at the specified path and computes diffs.
+     * Also updates any keyed objects that were nested in the value.
+     * @param source - The source object to update
+     * @param path - Dot-separated path to update
+     * @param value - The new value
+     * @param keyFunc - Optional function to extract keys from objects
+     * @returns Diff results showing all changes made
+     */
     function UpdateSource(source, path, value, keyFunc) {
         const diffResult = [];
         if (keyFunc) {
@@ -115,20 +158,45 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
         }
         return diffResult;
     }
+    /**
+     * Internal diff tree implementation.
+     * Maintains root state and computes diffs for path/value updates.
+     * @private
+     */
     class DiffTree {
+        /**
+         * Creates a DiffTree instance.
+         * @param keyFunc - Optional function to extract a key from objects
+         */
         constructor(keyFunc) {
             this.keyFunc = keyFunc;
             this.rootState = {};
         }
+        /**
+         * Computes diffs for a batch of path/value pairs.
+         * @param data - Array of objects with path and value properties
+         * @returns Combined diff results
+         */
         DiffBatch(data) {
             const results = data
                 .map(({ path, value }) => this.DiffPath(path, value))
                 .flat(1);
             return results;
         }
+        /**
+         * Computes the diff between a new value and the current value at a path.
+         * @param path - Dot-separated path to the value
+         * @param value - The new value to compare
+         * @returns Diff results showing changes
+         */
         DiffPath(path, value) {
             return UpdateSource(this.rootState, path, value, this.keyFunc);
         }
+        /**
+         * Retrieves the current value at a path.
+         * @param path - Dot-separated path to the value
+         * @returns The value at the specified path
+         */
         GetPath(path) {
             return GetPathValue(this.rootState, path);
         }

package/Store/Store/store.d.ts

@@ -1,11 +1,49 @@
 import { JsonDiffResult } from "../../Utils/json";
+/**
+ * Base class for observable data store management.
+ * Stores root objects as ObservableNode instances and manages updates through diff operations.
+ *
+ * @see StoreSync
+ * @see StoreAsync
+ */
 export declare class Store {
     protected keyFunc?: (value: any) => string | undefined;
     private rootMap;
     private createNode;
+    /**
+     * Creates an instance of Store.
+     * @param keyFunc Optional function to generate a key for a given data value.
+     * When provided, enables alias functionality where values can reference other root objects.
+     */
     constructor(keyFunc?: (value: any) => string | undefined);
+    /**
+     * Retrieves a value from the store by id.
+     * @template O - The type of the value to retrieve
+     * @param id - The id/key of the value
+     * @returns The value or undefined if not found
+     */
     Get<O>(id: string): O | undefined;
+    /**
+     * Retrieves a value from the store by id, with a default value if not found.
+     * @template O - The type of the value to retrieve
+     * @param id - The id/key of the value
+     * @param defaultValue - The default value to return if id doesn't exist
+     * @returns The value or the default value
+     */
     Get<O>(id: string, defaultValue: O): O;
+    /**
+     * Updates the root map with diff results by grouping changes by root path.
+     * @param results - Array of diff results to apply
+     * @protected
+     */
     protected UpdateRootMap(results: JsonDiffResult): void;
+    /**
+     * Updates a specific root object with diff results.
+     * Creates the root object if it doesn't exist.
+     * @param rootPath - The path of the root object
+     * @param results - Array of diff results to apply to this root object
+     * @throws If unable to initialize root path with the given results
+     * @private
+     */
     private UpdateRootObject;
 }

package/Store/Store/store.js

@@ -2,7 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Store = void 0;
 const observableNode_1 = require("../Tree/observableNode");
+/**
+ * Base class for observable data store management.
+ * Stores root objects as ObservableNode instances and manages updates through diff operations.
+ *
+ * @see StoreSync
+ * @see StoreAsync
+ */
 class Store {
+    /**
+     * Creates an instance of Store.
+     * @param keyFunc Optional function to generate a key for a given data value.
+     * When provided, enables alias functionality where values can reference other root objects.
+     */
     constructor(keyFunc) {
         this.keyFunc = keyFunc;
         this.rootMap = new Map();
@@ -30,6 +42,11 @@ class Store {
         }
         return result[id];
     }
+    /**
+     * Updates the root map with diff results by grouping changes by root path.
+     * @param results - Array of diff results to apply
+     * @protected
+     */
     UpdateRootMap(results) {
         for (let x = 0; x < results.length;) {
             const root = results[x].path[0];
@@ -40,6 +57,14 @@ class Store {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
+    /**
+     * Updates a specific root object with diff results.
+     * Creates the root object if it doesn't exist.
+     * @param rootPath - The path of the root object
+     * @param results - Array of diff results to apply to this root object
+     * @throws If unable to initialize root path with the given results
+     * @private
+     */
     UpdateRootObject(rootPath, results) {
         const rootObject = this.rootMap.get(rootPath);
         if (rootObject === undefined) {

package/Store/Tree/observableNode.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableNode = exports.GET_TO_JSON = exports.GET_OBSERVABLE_VALUE = exports.IS_OBSERVABLE_NODE = void 0;
 const json_1 = require("../../Utils/json");
-const jsonType_1 = require("../../Utils/jsonType");
+const json_2 = require("../../Utils/json");
 const observableScope_1 = require("./observableScope");
 /**
  * Symbol to identify observable nodes.
@@ -48,7 +48,7 @@ function ownKeys(value) {
 function ownKeysArray(value) {
     return Object.keys(value);
 }
-function UnwrapProxy(value, type = (0, jsonType_1.JsonType)(value)) {
+function UnwrapProxy(value, type = (0, json_2.JsonType)(value)) {
     if (type === "value")
         return value;
     if (value[exports.IS_OBSERVABLE_NODE])
@@ -72,7 +72,7 @@ function CreateProxyFactory(alias) {
         return CreateProxyFromValue(value);
     }
     function ToJsonCopy(value) {
-        const type = (0, jsonType_1.JsonType)(value);
+        const type = (0, json_2.JsonType)(value);
         switch (type) {
             case "array": {
                 const typedValue = value;
@@ -195,7 +195,7 @@ function CreateProxyFactory(alias) {
     function ObjectProxySetter(object, prop, value) {
         if (readOnly)
             throw `Object is readonly`;
-        const jsonType = (0, jsonType_1.JsonType)(value);
+        const jsonType = (0, json_2.JsonType)(value);
         if (jsonType === "value") {
             value !== object[prop] && SetPropertyValue(object, prop, value);
         }
@@ -242,7 +242,7 @@ function CreateProxyFactory(alias) {
         return observableScope_1.ObservableScope.Value(leafScopes[prop]);
     }
     function CreateProxyFromValue(value) {
-        const type = (0, jsonType_1.JsonType)(value);
+        const type = (0, json_2.JsonType)(value);
         switch (type) {
             case "object": {
                 let proxy = proxyCache.get(value) ?? CreateObjectProxy(value);

package/Store/Tree/observableScope.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = void 0;
 exports.CalcScope = CalcScope;
-const bitSet_1 = require("../../Utils/bitSet");
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
 /**
@@ -45,11 +44,6 @@ function CreateStaticScope(initialValue) {
         value: initialValue,
     };
 }
-/**
- * Queue of scopes pending batched update processing.
- * Scopes are added when their dependencies change and greedy batching is enabled.
- * The queue is processed in a microtask to batch multiple updates efficiently.
- */
 let scopeQueue = [];
 /**
  * Processes all queued scopes, recomputing dirty scopes and emitting changes.
@@ -94,78 +88,67 @@ function OnSet() {
     emitter_1.Emitter.Emit(this.emitter, this);
 }
 /**
- * Strategy where emitters are accessed in the same order as the previous execution.
- * This allows for efficient reconciliation by tracking which emitters were accessed
- * at the same positions in the array.
+ * Registers an emitter using SAME_STRATEGY.
+ * If the emitter is already registered at the current index, increments the index.
+ * Otherwise, switches to PUSH_STRATEGY and appends the emitter.
+ * @param state The current watch state.
+ * @param emitter The emitter to register.
  */
-const SAME_STRATEGY = 1;
+function RegisterSame(state, emitter) {
+    if (state.emitterIndex < state.emitters.length &&
+        state.emitters[state.emitterIndex] === emitter) {
+        state.emitterIndex++;
+        return;
+    }
+    state.emitters = state.emitters.slice(0, state.emitterIndex);
+    state.strategy = PUSH_STRATEGY;
+    RegisterPush(state, emitter);
+}
 /**
- * Strategy where new emitters are pushed to the array when accessed.
- * Used when the access pattern changes from the previous execution.
+ * Registers an emitter using PUSH_STRATEGY.
+ * Switches to DISTINCT_STRATEGY when the emitter count exceeds 50 to optimize memory.
+ * @param state The current watch state.
+ * @param emitter The emitter to register.
  */
-const PUSH_STRATEGY = 2;
-function GetBitSetFor(emitters) {
-    const bitSet = bitSet_1.BitSetPool.Get(BIT_SET_POOL);
-    for (let x = 0; x < emitters.length; x++)
-        bitSet_1.BitSet.set(bitSet, emitters[x][0]);
-    return bitSet;
+function RegisterPush(state, emitter) {
+    if (state.emitters.length > 10) {
+        state.strategy = DISTINCT_STRATEGY;
+        state.emitterSet = new Set(state.emitters);
+        RegisterDistinct(state, emitter);
+    }
+    else if (!state.emitters.includes(emitter))
+        state.emitters.push(emitter);
 }
 /**
- * Registers an emitter as a dependency during a watch operation.
- *
- * This function tracks which emitters are accessed while executing a scope's getFunction.
- * It uses two strategies for efficiency:
- *
- * - **SAME_STRATEGY**: When emitters are accessed in the same order as the previous execution,
- *   it tracks this via emitterIndex and skips array operations. Only switches to PUSH_STRATEGY
- *   when the order changes.
- *
- * - **PUSH_STRATEGY**: When access order differs or is new, emitters are pushed to the array.
- *   The BitSet prevents duplicates (same emitter accessed multiple times).
- *
- * The function does nothing if called outside a watch context (watchState is null).
- *
- * @param emitter The emitter to register as a dependency. Must have a unique ID at index 0.
+ * Registers an emitter using DISTINCT_STRATEGY.
+ * Only adds emitters that haven't been registered yet, using an ID set for O(1) lookup.
+ * @param state The current watch state.
+ * @param emitter The emitter to register.
+ */
+function RegisterDistinct(state, emitter) {
+    if (!state.emitterSet.has(emitter)) {
+        state.emitters.push(emitter);
+        state.emitterSet.add(emitter);
+    }
+}
+/**
+ * Routes an emitter to the appropriate registration strategy based on current watch state.
+ * Does nothing if not within a watch context.
+ * @param emitter The emitter to register.
  */
 function RegisterEmitter(emitter) {
     if (watchState === null)
         return;
     switch (watchState.strategy) {
-        case SAME_STRATEGY: {
-            if (watchState.emitterIndex < watchState.emitters.length &&
-                watchState.emitters[watchState.emitterIndex][0] === emitter[0]) {
-                watchState.emitterIndex++;
-                // BitSet.set(watchState.emitterIds, emitter[0]);
-            }
-            else {
-                watchState.strategy = PUSH_STRATEGY;
-                watchState.emitters = watchState.emitters.slice(0, watchState.emitterIndex);
-                RegisterEmitter(emitter);
-            }
+        case SAME_STRATEGY:
+            RegisterSame(watchState, emitter);
             break;
-        }
-        case PUSH_STRATEGY: {
-            switch (watchState.emitters.length) {
-                case 0: {
-                    watchState.emitters.push(emitter);
-                    break;
-                }
-                case 1: {
-                    if (watchState.emitters[0][0] !== emitter[0])
-                        watchState.emitters.push(emitter);
-                    break;
-                }
-                default: {
-                    if (watchState.emitters[watchState.emitters.length - 1][0] !== emitter[0]) {
-                        watchState.emitterIds ??= GetBitSetFor(watchState.emitters);
-                        if (bitSet_1.BitSet.add(watchState.emitterIds, emitter[0]))
-                            watchState.emitters.push(emitter);
-                    }
-                    break;
-                }
-            }
+        case PUSH_STRATEGY:
+            RegisterPush(watchState, emitter);
+            break;
+        case DISTINCT_STRATEGY:
+            RegisterDistinct(watchState, emitter);
             break;
-        }
     }
 }
 /**
@@ -190,16 +173,14 @@ function GetScopeValue(scope) {
     return scope.value;
 }
 /**
- * Global watch state representing the current dependency tracking context.
- * This is set during scope execution and tracks which emitters/scopes are accessed.
- * Nested watch contexts are supported via the parent reference pattern.
+ * Strategy constants for optimizing emitter registration during watch operations.
+ * Each strategy represents a different approach to tracking and deduplicating dependencies.
  */
+const SAME_STRATEGY = 1;
+const PUSH_STRATEGY = 2;
+const DISTINCT_STRATEGY = 3;
+const SHRINK_STRATEGY = 4;
 let watchState = null;
-/**
- * Pool for recycling BitSet objects to reduce garbage collection overhead.
- * BitSets are borrowed during watch operations and returned after use.
- */
-const BIT_SET_POOL = bitSet_1.BitSetPool.Create();
 /**
  * Executes a callback while tracking all scope and emitter dependencies.
  * Creates a watch context that records what was accessed during execution.
@@ -211,16 +192,21 @@ function WatchFunction(callback, currentCalc, initialEmitters) {
     const parent = watchState;
     watchState = {
         emitterIndex: 0,
-        strategy: initialEmitters === null ? PUSH_STRATEGY : SAME_STRATEGY,
         value: null,
         emitters: initialEmitters ?? [],
-        emitterIds: null, // BitSetPool.Get(BIT_SET_POOL),
+        emitterSet: null,
         currentCalc,
         nextCalc: null,
+        strategy: initialEmitters === null ? PUSH_STRATEGY : SAME_STRATEGY,
     };
     watchState.value = callback();
     const resultState = watchState;
     watchState = parent;
+    if (resultState.strategy === SAME_STRATEGY &&
+        resultState.emitterIndex < resultState.emitters.length) {
+        resultState.emitters = resultState.emitters.slice(0, resultState.emitterIndex);
+        resultState.strategy = SHRINK_STRATEGY;
+    }
     return resultState;
 }
 /**
@@ -231,11 +217,7 @@ function WatchFunction(callback, currentCalc, initialEmitters) {
 function ExecuteScope(scope) {
     scope.dirty = false;
     const state = WatchFunction(scope.getFunction, scope.calcScopes, scope.emitters);
-    if (state.strategy === SAME_STRATEGY &&
-        state.emitterIndex < state.emitters.length)
-        state.emitters = state.emitters.slice(0, state.emitterIndex);
     UpdateEmitters(scope, state);
-    state.emitterIds && bitSet_1.BitSetPool.Return(BIT_SET_POOL, state.emitterIds);
     const calcScopes = state.currentCalc;
     scope.calcScopes = state.nextCalc;
     for (const key in calcScopes)
@@ -263,7 +245,6 @@ function ExecuteFunction(callback, greedy, allowStatic) {
         const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
         scope.calcScopes = state.nextCalc;
         UpdateEmitters(scope, state);
-        state.emitterIds && bitSet_1.BitSetPool.Return(BIT_SET_POOL, state.emitterIds);
         if (async)
             state.value.then(function (result) {
                 scope.value = result;
@@ -294,7 +275,7 @@ function CalcScope(callback, idOverride) {
         return callback();
     const nextScopes = (watchState.nextCalc ??= {});
     const id = idOverride ?? "default";
-    if (Object.hasOwn(nextScopes, id)) {
+    if (nextScopes[id]) {
         RegisterScope(nextScopes[id]);
         return GetScopeValue(nextScopes[id]);
     }
@@ -306,31 +287,45 @@ function CalcScope(callback, idOverride) {
     return GetScopeValue(nextScopes[id]);
 }
 /**
- * Updates a scope's emitter subscriptions based on the new watch state.
- * Efficiently reconciles old and new emitter lists starting from emitterIndex.
- *
- * Emitters before emitterIndex are in the same position and don't need updates.
- * Emitters at/after emitterIndex are removed if no longer accessed or added if newly accessed.
- *
- * @param scope The scope to update emitter subscriptions for.
- * @param state The watch state containing the new emitter list.
+ * Updates a scope's dependency emitters using efficient diffing.
+ * Subscribes to new emitters and unsubscribes from removed ones.
+ * @param scope The scope to update dependencies for.
+ * @param right The new list of emitters to track.
+ * @param distinct Whether emitters are already unique (sorted and deduplicated).
  */
 function UpdateEmitters(scope, state) {
-    const currentEmitters = scope.emitters;
-    const nextEmitters = state.emitters;
-    const nextEmitterIds = state.emitterIds;
-    const sameIndex = state.emitterIndex;
-    if (currentEmitters !== null) {
-        for (let x = sameIndex; x < currentEmitters.length; x++) {
-            if (nextEmitterIds === null || !bitSet_1.BitSet.remove(nextEmitterIds, currentEmitters[x][0]))
-                emitter_1.Emitter.Remove(currentEmitters[x], scope.setCallback);
-        }
+    if (scope.emitters === null) {
+        for (let x = 0; x < state.emitters.length; x++)
+            emitter_1.Emitter.On(state.emitters[x], scope.setCallback);
+        scope.emitters = state.emitters;
+        return;
     }
-    for (let x = sameIndex; x < nextEmitters.length; x++) {
-        if (nextEmitterIds === null || bitSet_1.BitSet.has(nextEmitterIds, nextEmitters[x][0]))
-            emitter_1.Emitter.On(nextEmitters[x], scope.setCallback);
+    switch (state.strategy) {
+        case SHRINK_STRATEGY: {
+            for (let x = state.emitters.length; x < scope.emitters.length; x++)
+                emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            break;
+        }
+        case PUSH_STRATEGY: {
+            for (let x = state.emitterIndex; x < scope.emitters.length; x++)
+                if (!state.emitters.includes(scope.emitters[x], state.emitterIndex))
+                    emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            for (let x = state.emitterIndex; x < state.emitters.length; x++)
+                if (!scope.emitters.includes(state.emitters[x], state.emitterIndex))
+                    emitter_1.Emitter.On(state.emitters[x], scope.setCallback);
+            break;
+        }
+        case DISTINCT_STRATEGY: {
+            for (let x = state.emitterIndex; x < scope.emitters.length; x++)
+                if (!state.emitterSet.delete(scope.emitters[x]))
+                    emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            for (let x = state.emitterIndex; x < state.emitters.length; x++)
+                if (state.emitterSet.has(state.emitters[x]))
+                    emitter_1.Emitter.On(state.emitters[x], scope.setCallback);
+            break;
+        }
     }
-    scope.emitters = nextEmitters;
+    scope.emitters = state.emitters;
 }
 /**
  * Destroys multiple scopes, cleaning up their resources.
@@ -348,7 +343,7 @@ function DestroyAllScopes(scopes) {
 function DestroyScope(scope) {
     if (!scope || scope.type === "static")
         return;
-    emitter_1.Emitter.Destroy(scope.emitter);
+    // Emitter.Destroy(scope.emitter);
     for (const key in scope.calcScopes)
         DestroyScope(scope.calcScopes[key]);
     scope.calcScopes = null;
@@ -362,7 +357,6 @@ function DestroyScope(scope) {
     scope.setCallback = null;
     scope.destroyed = true;
     scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed, scope);
-    scope.onDestroyed && emitter_1.Emitter.Destroy(scope.onDestroyed);
 }
 var ObservableScope;
 (function (ObservableScope) {

package/Utils/asyncQueue.d.ts

@@ -1,8 +1,28 @@
+/**
+ * A queue that executes async callbacks sequentially, one at a time.
+ */
 export declare class AsyncQueue {
     private running;
     private queue;
+    /**
+     * Adds a callback to the queue and returns a promise that resolves when it executes.
+     * @template T - The type the callback promise resolves to
+     * @param callback - Async function to queue
+     * @returns Promise that resolves with the callback's result when executed
+     */
     Next<T>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * Clears the queue and stops execution.
+     */
     Stop(): void;
+    /**
+     * Starts queue execution if not already running.
+     * @private
+     */
     private Start;
+    /**
+     * Executes the next callback in the queue recursively until empty.
+     * @private
+     */
     private ExecuteQueue;
 }

package/Utils/asyncQueue.js

@@ -2,11 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncQueue = void 0;
 const list_1 = require("./list");
+/**
+ * A queue that executes async callbacks sequentially, one at a time.
+ */
 class AsyncQueue {
     constructor() {
         this.running = false;
         this.queue = list_1.List.Create();
     }
+    /**
+     * Adds a callback to the queue and returns a promise that resolves when it executes.
+     * @template T - The type the callback promise resolves to
+     * @param callback - Async function to queue
+     * @returns Promise that resolves with the callback's result when executed
+     */
     Next(callback) {
         const ret = new Promise((resolve, reject) => {
             list_1.List.Add(this.queue, async function () {
@@ -22,15 +31,26 @@ class AsyncQueue {
         this.Start();
         return ret;
     }
+    /**
+     * Clears the queue and stops execution.
+     */
     Stop() {
         list_1.List.Clear(this.queue);
     }
+    /**
+     * Starts queue execution if not already running.
+     * @private
+     */
     Start() {
         if (this.running)
             return;
         this.running = true;
         this.ExecuteQueue();
     }
+    /**
+     * Executes the next callback in the queue recursively until empty.
+     * @private
+     */
     async ExecuteQueue() {
         const callback = list_1.List.Pop(this.queue);
         if (callback !== undefined) {