j-templates 7.0.65 → 7.0.67

package/DOM/domNodeConfig.js

@@ -169,7 +169,9 @@ exports.DOMNodeConfig = {
             target.appendChild(children[x]);
     },
     reconcileChild(target, child) {
-        if (target.childElementCount > 1 || target.firstChild !== child)
+        if (target.childElementCount === 0)
+            target.appendChild(child);
+        else if (target.childElementCount > 1 || target.firstChild !== child)
             target.replaceChildren(child);
     },
 };

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

@@ -1,22 +1,74 @@
 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";
+import { IObservableScope } from "../Store/Tree/observableScope";
+/**
+ * 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;
-    protected get Scope(): ObservableScope<D>;
-    protected get Data(): D;
+    /**
+     * Internal scoped Observable for component state.
+     */
+    protected get Scope(): IObservableScope<D | Promise<D>>;
+    /**
+     * Current data value from the scoped Observable.
+     */
+    protected get Data(): D | Promise<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

@@ -2,69 +2,164 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Component = void 0;
 const decorators_1 = require("../Utils/decorators");
-const observableScope_1 = require("../Store/Tree/observableScope");
 const vNode_1 = require("./vNode");
+const Store_1 = require("../Store");
+/**
+ * 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;
+        return Store_1.ObservableScope.Value(this.scope);
     }
+    /**
+     * 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<D>(data as () => D | Promise<D>);
+        else this.scope = new ObservableScope<D>(() => data); */
         if (typeof data === "function")
-            this.scope = new observableScope_1.ObservableScope(data);
+            this.scope = Store_1.ObservableScope.Create(data);
         else
-            this.scope = new observableScope_1.ObservableScope(() => data);
+            this.scope = {
+                type: "static",
+                value: 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();
+        Store_1.ObservableScope.Destroy(this.scope);
         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 +173,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,19 +95,22 @@ 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;
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
         if (typeof props === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(props);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
-            }
-            assignProperties(value);
+            const scope = Store_1.ObservableScope.Create(props);
+            // const [value, scope] = ObservableScope.CreateIf(props as () => any);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
+            // }
+            assignProperties(Store_1.ObservableScope.Value(scope));
         }
         else
             assignProperties(props);
@@ -114,12 +118,13 @@ function InitNode(vnode) {
     if (on) {
         const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
         if (typeof on === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(on);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
-            }
-            assignEvents(value);
+            const scope = Store_1.ObservableScope.Create(on);
+            // const [value, scope] = ObservableScope.CreateIf(on);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
+            // }
+            assignEvents(Store_1.ObservableScope.Value(scope));
         }
         else
             assignEvents(on);
@@ -127,18 +132,21 @@ function InitNode(vnode) {
     if (attrs) {
         const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
         if (typeof attrs === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(attrs);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
-            }
-            assignAttributes(value);
+            const scope = Store_1.ObservableScope.Create(attrs);
+            // const [value, scope] = ObservableScope.CreateIf(attrs);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
+            //}
+            assignAttributes(Store_1.ObservableScope.Value(scope));
         }
         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();
@@ -155,7 +163,7 @@ function InitNode(vnode) {
     UpdateChildren(vnode, true, !!childrenArray);
 }
 function Children(vnode, children, data) {
-    const [childNodes, childrenScope] = CreateChildrenScope(vnode, children, data);
+    const childrenScope = CreateChildrenScope(vnode, children, data);
     if (childrenScope) {
         vnode.scopes.push(childrenScope);
         Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
@@ -163,18 +171,29 @@ 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);
             }
         }));
     }
-    vnode.children = childNodes;
-}
-function AssignChildren(vnode, childrenScope) {
-    const children = Store_1.ObservableScope.Peek(childrenScope);
-    vnode.children = children;
+    vnode.children = Store_1.ObservableScope.Value(childrenScope);
+    // AssignChildren(vnode, childrenScope);
 }
+/* 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;
@@ -188,7 +207,7 @@ function CreateChildrenScope(vnode, children, data = DefaultData) {
             });
         };
     }
-    return Store_1.ObservableScope.CreateIf(WrapChildren(vnode.injector, children, data));
+    return Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, data));
 }
 function WrapChildren(injector, children, data) {
     let nodeArray = [];
@@ -249,10 +268,14 @@ function EvaluateNextNodesSmall(injector, getNextChildren, nextData, nodeArray)
             nodeArray[i] = null;
         }
         else {
-            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+            const scope = Store_1.ObservableScope.Create(function () {
                 return injector_1.Injector.Scope(injector, getNextChildren, data);
             });
-            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
+            nextNodes[x] = [
+                data,
+                CreateNodeArray(Store_1.ObservableScope.Value(scope)),
+                scope,
+            ];
         }
     }
     for (let x = 0; x < nodeArray.length; x++) {
@@ -278,27 +301,37 @@ function EvaluateNextNodesLarge(injector, getNextChildren, nextData, nodeArray)
         for (; currentChildIndex >= 0 && currentChildren[currentChildIndex] === null; currentChildIndex--) { }
         if (currentChildIndex !== -1) {
             const currentChild = currentChildren[currentChildIndex];
-            if (currentChild[2]) {
-                const scope = currentChild[2];
-                const value = scope.value;
-                const updatedValue = Store_1.ObservableScope.Value(scope);
-                if (value !== updatedValue)
-                    currentChild[1] = CreateNodeArray(updatedValue);
-            }
-            if (currentChild[2]?.dirty) {
-                const nextChildren = Store_1.ObservableScope.Value(currentChild[2]);
-                currentChild[1] = CreateNodeArray(nextChildren);
+            currentChildren[currentChildIndex] = null;
+            // if (currentChild[2]) {
+            const scope = currentChild[2];
+            const value = scope.value;
+            const updatedValue = Store_1.ObservableScope.Value(scope);
+            if (value !== updatedValue) {
+                vNode.DestroyAll(currentChild[1]);
+                currentChild[1] = CreateNodeArray(updatedValue);
             }
+            // }
+            /* if (currentChild[2]?.dirty) {
+              const nextChildren = ObservableScope.Value(currentChild[2]);
+              currentChild[1] = CreateNodeArray(nextChildren);
+              } */
             nextNodes[x] = currentChild;
-            currentChildren[currentChildIndex] = null;
+            // currentChildren[currentChildIndex] = null;
             if (currentChildIndex === 0)
                 dataMap.delete(data);
         }
         else {
-            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+            const scope = Store_1.ObservableScope.Create(function () {
                 return injector_1.Injector.Scope(injector, getNextChildren, data);
             });
-            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
+            /* const [nextChildren, scope] = ObservableScope.CreateIf(function () {
+              return Injector.Scope(injector, getNextChildren, data);
+              }); */
+            nextNodes[x] = [
+                data,
+                CreateNodeArray(Store_1.ObservableScope.Value(scope)),
+                scope,
+            ];
         }
     }
     for (const value of dataMap.values()) {
@@ -378,8 +411,7 @@ function ScheduledAssignment(assign) {
             return;
         scheduled = true;
         nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-            if (scope.destroyed)
-                return;
+            // if (scope.destroyed) return;
             scheduled = false;
             const value = Store_1.ObservableScope.Peek(scope);
             assign(value);

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;
 }