j-templates 7.0.64 → 7.0.66

package/DOM/elements.d.ts

@@ -86,6 +86,22 @@ export declare const table: <T>(config: {
     on?: import("../Node/vNode.types").FunctionOr<import("../Node/vNode.types").vNodeEvents<HTMLElementEventMap>>;
     data?: () => T | Array<T> | Promise<Array<T>> | Promise<T>;
 }, children?: import("../Node/vNode.types").vNode[] | import("../Node/vNode.types").vNodeChildrenFunction<T>) => import("../Node/vNode.types").vNode;
+export declare const thead: <T>(config: {
+    props?: import("../Node/vNode.types").FunctionOr<import("../Utils/utils.types").RecursivePartial<HTMLElement>>;
+    attrs?: import("../Node/vNode.types").FunctionOr<{
+        [name: string]: string;
+    }>;
+    on?: import("../Node/vNode.types").FunctionOr<import("../Node/vNode.types").vNodeEvents<HTMLElementEventMap>>;
+    data?: () => T | Array<T> | Promise<Array<T>> | Promise<T>;
+}, children?: import("../Node/vNode.types").vNode[] | import("../Node/vNode.types").vNodeChildrenFunction<T>) => import("../Node/vNode.types").vNode;
+export declare const th: <T>(config: {
+    props?: import("../Node/vNode.types").FunctionOr<import("../Utils/utils.types").RecursivePartial<HTMLElement>>;
+    attrs?: import("../Node/vNode.types").FunctionOr<{
+        [name: string]: string;
+    }>;
+    on?: import("../Node/vNode.types").FunctionOr<import("../Node/vNode.types").vNodeEvents<HTMLElementEventMap>>;
+    data?: () => T | Array<T> | Promise<Array<T>> | Promise<T>;
+}, children?: import("../Node/vNode.types").vNode[] | import("../Node/vNode.types").vNodeChildrenFunction<T>) => import("../Node/vNode.types").vNode;
 export declare const tbody: <T>(config: {
     props?: import("../Node/vNode.types").FunctionOr<import("../Utils/utils.types").RecursivePartial<HTMLElement>>;
     attrs?: import("../Node/vNode.types").FunctionOr<{

package/DOM/elements.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.text = exports.pre = exports.label = exports.p = exports.aside = exports.option = exports.select = exports.video = exports.img = exports.td = exports.tr = exports.tbody = exports.table = exports.span = exports.textarea = exports.input = exports.h3 = exports.h2 = exports.h1 = exports.button = exports.b = exports.a = exports.div = void 0;
+exports.text = exports.pre = exports.label = exports.p = exports.aside = exports.option = exports.select = exports.video = exports.img = exports.td = exports.tr = exports.tbody = exports.th = exports.thead = exports.table = exports.span = exports.textarea = exports.input = exports.h3 = exports.h2 = exports.h1 = exports.button = exports.b = exports.a = exports.div = void 0;
 const vNode_1 = require("../Node/vNode");
 exports.div = vNode_1.vNode.ToFunction("div");
 exports.a = vNode_1.vNode.ToFunction("a");
@@ -13,6 +13,8 @@ exports.input = vNode_1.vNode.ToFunction("input");
 exports.textarea = vNode_1.vNode.ToFunction("textarea");
 exports.span = vNode_1.vNode.ToFunction("span");
 exports.table = vNode_1.vNode.ToFunction("table");
+exports.thead = vNode_1.vNode.ToFunction("thead");
+exports.th = vNode_1.vNode.ToFunction("th");
 exports.tbody = vNode_1.vNode.ToFunction("tbody");
 exports.tr = vNode_1.vNode.ToFunction("tr");
 exports.td = vNode_1.vNode.ToFunction("td");

package/DOM/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./elements"), exports);
+// export * from "./svgElements";
 __exportStar(require("./createPropertyAssignment"), exports);
 __exportStar(require("./createEventAssignment"), exports);

package/DOM/svgElements.js

@@ -0,0 +1,12 @@
+// import { ElementNode } from "../Node/elementNode";
+// import { ElementChildrenFunction, ElementNodeFunctionParam } from "../Node/elementNode.types";
+// const svgNs = "http://www.w3.org/2000/svg";
+// export function svg<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>) {
+//     return ElementNode.Create("svg", svgNs, nodeDef, children);
+// }
+// export function g<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>) {
+//     return ElementNode.Create("g", svgNs, nodeDef, children);
+// }
+// export function circle<T>(nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>) {
+//     return ElementNode.Create("circle", svgNs, nodeDef, children);
+// }

package/Node/component.d.ts

@@ -2,21 +2,73 @@ import { ComponentEvents } from "./component.types";
 import { ObservableScope } from "../Store/Tree/observableScope";
 import { FunctionOr, vNode as vNodeType } from "./vNode.types";
 import { RecursivePartial } from "../Utils/utils.types";
+/**
+ * Base Component class.
+ *
+ * @template D - Data type for the component's scoped state.
+ * @template T - Template type used by the component.
+ * @template E - Event map type for component events.
+ */
 export declare class Component<D = void, T = void, E = {}> {
     private vNode;
-    private componentEvents;
     private scope;
     private templates;
+    private componentEvents;
+    /**
+     * Returns the component's virtual node injector.
+     */
     get Injector(): import("../Utils/injector").Injector;
+    /**
+     * Indicates whether the component has been destroyed.
+     */
     get Destroyed(): boolean;
+    /**
+     * Internal scoped Observable for component state.
+     */
     protected get Scope(): ObservableScope<D>;
+    /**
+     * Current data value from the scoped Observable.
+     */
     protected get Data(): D;
+    /**
+     * Accessor for the component's virtual node.
+     */
     protected get VNode(): vNodeType;
+    /**
+     * Accessor for the component's template collection.
+     */
     protected get Templates(): T;
-    constructor(data: D | (() => D | Promise<D>), templates: T, vNode: vNodeType, componentEvents: ComponentEvents<E>);
+    /**
+     * Creates a new Component instance. Not intended to be overriden.
+     *
+     * @param data - Initial data or a factory function returning data/promise.
+     * @param templates - Template definitions for rendering.
+     * @param vNode - The underlying virtual node instance.
+     * @param componentEvents - Optional event callbacks.
+     */
+    constructor(vNode: vNodeType, config: vComponentConfig<D, E>, templates: T);
+    /**
+     * Returns the component's rendered vNode(s).
+     * Override to provide custom rendering logic.
+     *
+     * @returns A vNode or array of vNodes representing the component UI.
+     */
     Template(): vNodeType | vNodeType[];
+    /**
+     * Lifecycle hook called after the component has been bound to the DOM.
+     * Override to perform post‑binding initialization.
+     */
     Bound(): void;
+    /**
+     * Fires a component event.
+     *
+     * @param event - The event name to fire.
+     * @param data - Optional payload for the event.
+     */
     Fire<P extends keyof E>(event: P, data?: E[P]): void;
+    /**
+     * Destroys the component, cleaning up its scoped data and decorators.
+     */
     Destroy(): void;
 }
 type vComponentConfig<D, E, P = HTMLElement> = {
@@ -24,12 +76,23 @@ type vComponentConfig<D, E, P = HTMLElement> = {
     props?: FunctionOr<RecursivePartial<P>> | undefined;
     on?: ComponentEvents<E> | undefined;
 };
-type ComponentConstructor<D, T, E> = {
-    new (data: D | (() => D | Promise<D>), templates: T, vNode: vNodeType, componentEvents: ComponentEvents<E>): Component<D, T, E>;
-};
 export declare namespace Component {
-    function ToFunction<D, T, E, P = HTMLElement>(type: string, constructor: ComponentConstructor<D, T, E>, namespace?: string): (config: vComponentConfig<D, E, P>, templates?: T) => vNodeType;
-    function Register<D = void, T = void, E = void>(name: string, constructor: ComponentConstructor<D, T, E>): void;
+    /**
+     * Function wraps the Component as a function that can be used to create vNode objects
+     * and generate templates.
+     */
+    function ToFunction<D, T, E, P = HTMLElement>(type: string, constructor: typeof Component<D, T, E>, namespace?: string): (config: vComponentConfig<D, E, P>, templates?: T) => vNodeType;
+    /**
+     * Function registers the Component as a WebComponent as the provided name.
+     */
+    function Register<D = void, T = void, E = void>(name: string, constructor: typeof Component<D, T, E>): void;
+    /**
+     * Attaches a virtual node to a real DOM node.
+     *
+     * @param node - The target DOM node to attach to.
+     * @param vnode - The virtual node to be attached.
+     * @returns The result of the attachment operation.
+     */
     function Attach(node: any, vnode: vNodeType): vNodeType;
 }
 export {};

package/Node/component.js

@@ -4,67 +4,156 @@ exports.Component = void 0;
 const decorators_1 = require("../Utils/decorators");
 const observableScope_1 = require("../Store/Tree/observableScope");
 const vNode_1 = require("./vNode");
+/**
+ * Base Component class.
+ *
+ * @template D - Data type for the component's scoped state.
+ * @template T - Template type used by the component.
+ * @template E - Event map type for component events.
+ */
 class Component {
+    /**
+     * Returns the component's virtual node injector.
+     */
     get Injector() {
         return this.vNode.injector;
     }
+    /**
+     * Indicates whether the component has been destroyed.
+     */
     get Destroyed() {
         return this.vNode.destroyed;
     }
+    /**
+     * Internal scoped Observable for component state.
+     */
     get Scope() {
         return this.scope;
     }
+    /**
+     * Current data value from the scoped Observable.
+     */
     get Data() {
         return this.scope.Value;
     }
+    /**
+     * Accessor for the component's virtual node.
+     */
     get VNode() {
         return this.vNode;
     }
+    /**
+     * Accessor for the component's template collection.
+     */
     get Templates() {
         return this.templates;
     }
-    constructor(data, templates, vNode, componentEvents) {
+    /**
+     * Creates a new Component instance. Not intended to be overriden.
+     *
+     * @param data - Initial data or a factory function returning data/promise.
+     * @param templates - Template definitions for rendering.
+     * @param vNode - The underlying virtual node instance.
+     * @param componentEvents - Optional event callbacks.
+     */
+    /* constructor(
+      data: D | (() => D | Promise<D>),
+      templates: T,
+      private vNode: vNodeType,
+      private componentEvents: ComponentEvents<E>,
+    ) {
+      if (typeof data === "function")
+        this.scope = new ObservableScope<D>(data as () => D | Promise<D>);
+      else this.scope = new ObservableScope<D>(() => data);
+  
+      this.templates = templates || ({} as T);
+    } */
+    constructor(vNode, config, templates) {
         this.vNode = vNode;
-        this.componentEvents = componentEvents;
+        const { data, on } = config;
         if (typeof data === "function")
             this.scope = new observableScope_1.ObservableScope(data);
         else
             this.scope = new observableScope_1.ObservableScope(() => data);
+        this.componentEvents = on;
         this.templates = templates || {};
     }
+    /**
+     * Returns the component's rendered vNode(s).
+     * Override to provide custom rendering logic.
+     *
+     * @returns A vNode or array of vNodes representing the component UI.
+     */
     Template() {
         return [];
     }
-    Bound() { }
+    /**
+     * Lifecycle hook called after the component has been bound to the DOM.
+     * Override to perform post‑binding initialization.
+     */
+    Bound() {
+        decorators_1.Bound.All(this);
+    }
+    /**
+     * Fires a component event.
+     *
+     * @param event - The event name to fire.
+     * @param data - Optional payload for the event.
+     */
     Fire(event, data) {
         var eventCallback = this.componentEvents && this.componentEvents[event];
         eventCallback && eventCallback(data);
     }
+    /**
+     * Destroys the component, cleaning up its scoped data and decorators.
+     */
     Destroy() {
         this.scope.Destroy();
         decorators_1.Destroy.All(this);
     }
 }
 exports.Component = Component;
+/* type ComponentConstructor<D, T, E> = {
+  new (
+    data: D | (() => D | Promise<D>),
+    templates: T,
+    vNode: vNodeType,
+    componentEvents: ComponentEvents<E>,
+  ): Component<D, T, E>;
+}; */
 (function (Component) {
-    function ToFunction(type, constructor, namespace) {
+    /**
+     * Function wraps the Component as a function that can be used to create vNode objects
+     * and generate templates.
+     */
+    function ToFunction(type, 
+    // constructor: ComponentConstructor<D, T, E>,
+    constructor, namespace) {
         return function (config, templates) {
-            const { data, on, props } = config;
+            /* const { data, on, props } = config;
+      
             class ConcreteComponent extends constructor {
-                constructor(vnode) {
-                    super(data, templates, vnode, on);
-                }
+              constructor(vnode: vNodeType) {
+                super(data, templates, vnode, on);
+              }
+            } */
+            function ComponentFactory(vnode) {
+                return new constructor(vnode, config, templates);
             }
             const definition = {
                 type,
                 namespace: namespace ?? null,
-                props,
-                componentConstructor: ConcreteComponent,
+                props: config.props,
+                componentFactory: ComponentFactory,
+                // componentConstructor: ConcreteComponent,
             };
             return vNode_1.vNode.Create(definition);
         };
     }
     Component.ToFunction = ToFunction;
+    /**
+     * Function registers the Component as a WebComponent as the provided name.
+     */
     function Register(name, constructor) {
         const componentFunction = ToFunction(`${name}-component`, constructor);
         class WebComponent extends HTMLElement {
@@ -78,6 +167,13 @@ exports.Component = Component;
         customElements.define(name, WebComponent);
     }
     Component.Register = Register;
+    /**
+     * Attaches a virtual node to a real DOM node.
+     *
+     * @param node - The target DOM node to attach to.
+     * @param vnode - The virtual node to be attached.
+     * @returns The result of the attachment operation.
+     */
     function Attach(node, vnode) {
         return vNode_1.vNode.Attach(node, vnode);
     }

package/Node/vNode.js

@@ -14,7 +14,8 @@ var vNode;
         return {
             definition,
             type: definition.type,
-            injector: definition.componentConstructor
+            // injector: definition.componentConstructor
+            injector: definition.componentFactory
                 ? injector_1.Injector.Scope(injector_1.Injector.Current(), function () {
                     return new injector_1.Injector();
                 })
@@ -94,7 +95,9 @@ var vNode;
     vNode.Attach = Attach;
 })(vNode || (exports.vNode = vNode = {}));
 function InitNode(vnode) {
-    const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray, } = vnode.definition;
+    const { type, namespace, props, attrs, on, data, 
+    // componentConstructor,
+    componentFactory, children, childrenArray, } = vnode.definition;
     const node = (vnode.node =
         vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
     vnode.definition = null;
@@ -137,8 +140,10 @@ function InitNode(vnode) {
         else
             assignAttributes(attrs);
     }
-    if (componentConstructor) {
-        vnode.component = new componentConstructor(vnode);
+    // if (componentConstructor) {
+    if (componentFactory) {
+        // vnode.component = new componentConstructor(vnode);
+        vnode.component = componentFactory(vnode);
         vnode.component.Bound();
         function componentChildren() {
             return vnode.component.Template();
@@ -163,6 +168,7 @@ function Children(vnode, children, data) {
                 return;
             const startChildren = vnode.children;
             const newChildren = Store_1.ObservableScope.Value(scope);
+            // AssignChildren(vnode, scope);
             if (startChildren !== newChildren) {
                 vnode.children = newChildren;
                 UpdateChildren(vnode);
@@ -170,11 +176,21 @@ function Children(vnode, children, data) {
         }));
     }
     vnode.children = childNodes;
+    // AssignChildren(vnode, childrenScope);
 }
-function AssignChildren(vnode, childrenScope) {
-    const children = Store_1.ObservableScope.Peek(childrenScope);
-    vnode.children = children;
-}
+/* function AssignChildren(
+  vnode: vNodeType,
+  childrenScope: IObservableScope<
+    [
+      any,
+      vNodeType[],
+      IObservableScope<string | vNodeType | vNodeType[]> | null,
+    ][]
+  >,
+) {
+  const children = ObservableScope.Peek(childrenScope);
+  vnode.children = children;
+} */
 const DEFAULT_DATA = [undefined];
 function DefaultData() {
     return DEFAULT_DATA;

package/Node/vNode.types.d.ts

@@ -37,7 +37,5 @@ export type vNodeDefinition<P = HTMLElement, E = HTMLElementEventMap, T = never>
     data?: () => T | Array<T> | Promise<Array<T>> | Promise<T>;
     children?: vNodeChildrenFunction<T>;
     childrenArray?: vNode[];
-    componentConstructor?: {
-        new (vnode: vNode): Component<any, any, any>;
-    };
+    componentFactory?: (vnode: vNode) => Component<any, any, any>;
 };

package/Store/Store/storeAsync.d.ts

@@ -1,11 +1,89 @@
 import { Store } from "./store";
+/**
+ * StoreAsync class extends the base Store class to provide asynchronous data management operations.
+ * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
+ *
+ * StoreAsync is designed to work with observable data structures, allowing for efficient updates
+ * and notifications when data changes. It is particularly useful for scenarios where asynchronous
+ * operations are preferred or required, such as handling large datasets or performing complex diffs
+ * without blocking the main thread.
+ *
+ * @example
+ * // Creating a StoreAsync instance
+ * const store = new StoreAsync();
+ *
+ * // Writing data to the store asynchronously
+ * await store.Write({ name: "John", age: 30 }, "user");
+ *
+ * // Patching existing data asynchronously
+ * await store.Patch("user", { age: 31 });
+ *
+ * // Pushing data into an array asynchronously
+ * await store.Push("user.array", { id: 1 }, { id: 2 });
+ *
+ * // Splicing an array asynchronously
+ * const deletedItems = await store.Splice("user.array", 0, 1, { id: 3 });
+ *
+ * // Cleaning up resources
+ * store.Destroy();
+ *
+ * @see Store
+ * @see StoreSync
+ * @see DiffAsync
+ */
 export declare class StoreAsync extends Store {
+    /**
+     * The diff instance used to compute differences between current and new data states asynchronously.
+     * @private
+     */
     private diff;
+    /**
+     * The async queue instance used to manage asynchronous operations in a non-blocking manner.
+     * @private
+     */
     private queue;
+    /**
+     * Creates an instance of StoreAsync.
+     * @param keyFunc Optional function to generate a key for a given data value.
+     */
     constructor(keyFunc?: (value: any) => string | undefined);
+    /**
+     * Writes data to the store asynchronously.
+     * This method ensures that write operations are queued and executed in a non-blocking manner.
+     * @param data The data to be written. Can be of any type.
+     * @param key Optional key for the data. If not provided, the keyFunc will be used to generate a key.
+     * @throws Will throw an error if no key is provided for the data.
+     */
     Write(data: unknown, key?: string): Promise<void>;
+    /**
+     * Patches an existing value in the store with new data asynchronously.
+     * This method ensures that patch operations are queued and executed in a non-blocking manner.
+     * @param key The key of the value to be patched.
+     * @param patch The patch data to be merged with the existing value.
+     * @throws Will throw an error if the value to be patched is undefined.
+     */
     Patch(key: string, patch: unknown): Promise<void>;
+    /**
+     * Pushes data into an array stored at the specified key asynchronously.
+     * This method ensures that push operations are queued and executed in a non-blocking manner.
+     * @param key The key of the array where data will be pushed.
+     * @param data The data items to be pushed into the array.
+     */
     Push(key: string, ...data: unknown[]): Promise<void>;
+    /**
+     * Splices an array stored at the specified key with new data asynchronously.
+     * This method ensures that splice operations are queued and executed in a non-blocking manner.
+     * It modifies the array by deleting elements and inserting new ones at the specified position.
+     * @param key The key of the array to be spliced.
+     * @param start The position at which to start changing the array.
+     * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
+     * @param items Optional elements to insert into the array.
+     * @returns The array of deleted elements.
+     */
     Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]>;
+    /**
+     * Destroys the StoreAsync instance, stopping the async queue and cleaning up the diff instance.
+     * This method should be called when the instance is no longer needed to free up resources.
+     */
     Destroy(): void;
 }

package/Store/Store/storeAsync.js

@@ -6,12 +6,59 @@ const json_1 = require("../../Utils/json");
 const diffAsync_1 = require("../Diff/diffAsync");
 const observableNode_1 = require("../Tree/observableNode");
 const store_1 = require("./store");
+/**
+ * StoreAsync class extends the base Store class to provide asynchronous data management operations.
+ * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
+ *
+ * StoreAsync is designed to work with observable data structures, allowing for efficient updates
+ * and notifications when data changes. It is particularly useful for scenarios where asynchronous
+ * operations are preferred or required, such as handling large datasets or performing complex diffs
+ * without blocking the main thread.
+ *
+ * @example
+ * // Creating a StoreAsync instance
+ * const store = new StoreAsync();
+ *
+ * // Writing data to the store asynchronously
+ * await store.Write({ name: "John", age: 30 }, "user");
+ *
+ * // Patching existing data asynchronously
+ * await store.Patch("user", { age: 31 });
+ *
+ * // Pushing data into an array asynchronously
+ * await store.Push("user.array", { id: 1 }, { id: 2 });
+ *
+ * // Splicing an array asynchronously
+ * const deletedItems = await store.Splice("user.array", 0, 1, { id: 3 });
+ *
+ * // Cleaning up resources
+ * store.Destroy();
+ *
+ * @see Store
+ * @see StoreSync
+ * @see DiffAsync
+ */
 class StoreAsync extends store_1.Store {
+    /**
+     * Creates an instance of StoreAsync.
+     * @param keyFunc Optional function to generate a key for a given data value.
+     */
     constructor(keyFunc) {
         super(keyFunc);
+        /**
+         * The async queue instance used to manage asynchronous operations in a non-blocking manner.
+         * @private
+         */
         this.queue = new asyncQueue_1.AsyncQueue();
         this.diff = new diffAsync_1.DiffAsync(keyFunc);
     }
+    /**
+     * Writes data to the store asynchronously.
+     * This method ensures that write operations are queued and executed in a non-blocking manner.
+     * @param data The data to be written. Can be of any type.
+     * @param key Optional key for the data. If not provided, the keyFunc will be used to generate a key.
+     * @throws Will throw an error if no key is provided for the data.
+     */
     async Write(data, key) {
         await this.queue.Next(async () => {
             key = key || this.keyFunc?.(data);
@@ -21,6 +68,13 @@ class StoreAsync extends store_1.Store {
             this.UpdateRootMap(diffResult);
         });
     }
+    /**
+     * Patches an existing value in the store with new data asynchronously.
+     * This method ensures that patch operations are queued and executed in a non-blocking manner.
+     * @param key The key of the value to be patched.
+     * @param patch The patch data to be merged with the existing value.
+     * @throws Will throw an error if the value to be patched is undefined.
+     */
     async Patch(key, patch) {
         await this.queue.Next(async () => {
             const value = this.Get(key);
@@ -32,6 +86,12 @@ class StoreAsync extends store_1.Store {
             this.UpdateRootMap(diffResult);
         });
     }
+    /**
+     * Pushes data into an array stored at the specified key asynchronously.
+     * This method ensures that push operations are queued and executed in a non-blocking manner.
+     * @param key The key of the array where data will be pushed.
+     * @param data The data items to be pushed into the array.
+     */
     async Push(key, ...data) {
         await this.queue.Next(async () => {
             const arr = this.Get(key);
@@ -45,6 +105,16 @@ class StoreAsync extends store_1.Store {
             this.UpdateRootMap(diffResult);
         });
     }
+    /**
+     * Splices an array stored at the specified key with new data asynchronously.
+     * This method ensures that splice operations are queued and executed in a non-blocking manner.
+     * It modifies the array by deleting elements and inserting new ones at the specified position.
+     * @param key The key of the array to be spliced.
+     * @param start The position at which to start changing the array.
+     * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
+     * @param items Optional elements to insert into the array.
+     * @returns The array of deleted elements.
+     */
     async Splice(key, start, deleteCount, ...items) {
         return await this.queue.Next(async () => {
             const arr = this.Get(key);
@@ -56,6 +126,10 @@ class StoreAsync extends store_1.Store {
             return spliceResult;
         });
     }
+    /**
+     * Destroys the StoreAsync instance, stopping the async queue and cleaning up the diff instance.
+     * This method should be called when the instance is no longer needed to free up resources.
+     */
     Destroy() {
         this.queue.Stop();
         this.diff.Destroy();