wraplet 0.27.0 → 0.29.0

package/dist/AbstractWraplet.d.ts

@@ -1,44 +1,32 @@
-import { WrapletChildrenMap } from "./types/WrapletChildrenMap";
-import { WrapletChildren } from "./types/WrapletChildren";
-import { Wraplet, WrapletSymbol } from "./types/Wraplet";
-import { DestroyListener } from "./types/DestroyListener";
-import { ChildInstance } from "./types/ChildInstance";
-import { Groupable, GroupableSymbol, GroupExtractor } from "./types/Groupable";
-import { NodeTreeParent, NodeTreeParentSymbol } from "./types/NodeTreeParent";
-import { Core } from "./types/Core";
+import { WrapletChildrenMap } from "./Wraplet/types/WrapletChildrenMap";
+import { WrapletChildren } from "./Wraplet/types/WrapletChildren";
+import { Wraplet, WrapletSymbol } from "./Wraplet/types/Wraplet";
+import { DestroyListener } from "./Core/types/DestroyListener";
+import { ChildInstance } from "./Wraplet/types/ChildInstance";
+import { Groupable, GroupableSymbol } from "./types/Groupable";
+import { NodeTreeParent, NodeTreeParentSymbol } from "./NodeTreeManager/types/NodeTreeParent";
+import { Core } from "./Core/types/Core";
+import { WrapletApiFactoryArgs } from "./Wraplet/types/WrapletApiFactoryArgs";
+import { WrapletApi } from "./Wraplet/types/WrapletApi";
 export declare abstract class AbstractWraplet<N extends Node = Node, M extends WrapletChildrenMap = {}> implements Wraplet<N>, Groupable, NodeTreeParent {
     protected core: Core<N, M>;
     [WrapletSymbol]: true;
     [GroupableSymbol]: true;
     [NodeTreeParentSymbol]: true;
-    isGettingDestroyed: boolean;
-    isDestroyed: boolean;
-    isGettingInitialized: boolean;
-    isInitialized: boolean;
-    private groupsExtractor;
-    private destroyListeners;
-    /**
-     * This is the log of all node accessors, available for easier debugging.
-     */
-    private __debugNodeAccessors;
+    protected destroyListeners: DestroyListener<N>[];
+    wraplet: WrapletApi<N> & NodeTreeParent["wraplet"] & Groupable["wraplet"];
     constructor(core: Core<N, M>);
-    getNodeTreeChildren(): Wraplet[];
-    setGroupsExtractor(callback: GroupExtractor): void;
-    getGroups(): string[];
+    protected createWrapletApi(args: WrapletApiFactoryArgs<N, M>): WrapletApi<N> & NodeTreeParent["wraplet"] & Groupable["wraplet"];
     protected get children(): WrapletChildren<M>;
-    accessNode(callback: (node: N) => void): void;
-    destroy(): void;
-    addDestroyListener(callback: DestroyListener<N>): void;
     /**
      * This method will be ivoked if one of the wraplet's children has been destroyed.
      */
-    protected onChildDestroyed(child: ChildInstance<M, keyof M>, id: keyof M): void;
-    protected initialize(): void;
+    protected onChildDestroy(child: ChildInstance<M, keyof M>, id: keyof M): void;
     protected get node(): N;
     /**
-     * This method will be ivoked if one of the wraplet's children has been instantiated.
+     * This method will be invoked if one of the wraplet's children has been instantiated.
      */
-    protected onChildInstantiated(child: ChildInstance<M, keyof M>, id: keyof M): void;
+    protected onChildInstantiate(child: ChildInstance<M, keyof M>, id: keyof M): void;
     /**
      * This method makes sure that the given instance is an instance of a class belonging to the
      * given child.

package/dist/Core/DefaultArgCreator.d.ts

@@ -0,0 +1,10 @@
+import { ArgCreator, ArgCreatorSymbol } from "./types/ArgCreator";
+import { WrapletChildrenMap } from "../Wraplet/types/WrapletChildrenMap";
+import { WrapletCreatorArgs } from "./types/WrapletCreator";
+export declare class DefaultArgCreator<N extends Node, M extends WrapletChildrenMap = WrapletChildrenMap> implements ArgCreator<N, M> {
+    private creator;
+    [ArgCreatorSymbol]: true;
+    constructor(creator: ArgCreator<N, M>["createArg"]);
+    createArg(args: WrapletCreatorArgs<N, M>): unknown;
+    static create<N extends Node, M extends WrapletChildrenMap = WrapletChildrenMap>(creator: ArgCreator<N, M>["createArg"]): DefaultArgCreator<N, M>;
+}

package/dist/{DefaultCore.d.ts → Core/DefaultCore.d.ts}

@@ -1,27 +1,25 @@
-import { WrapletChildren } from "./types/WrapletChildren";
-import { Wraplet } from "./types/Wraplet";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "./types/WrapletChildrenMap";
+import { WrapletChildren } from "../Wraplet/types/WrapletChildren";
+import { Wraplet } from "../Wraplet/types/Wraplet";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
 import { InstantiateChildListener } from "./types/InstantiateChildListener";
 import { DestroyChildListener } from "./types/DestroyChildListener";
 import { CoreInitOptions } from "./types/CoreInitOptions";
 import { Core, CoreSymbol } from "./types/Core";
-import { NodeTreeParentSymbol } from "./types/NodeTreeParent";
-import { MapWrapper } from "./Map/MapWrapper";
+import { NodeTreeParentSymbol } from "../NodeTreeManager/types/NodeTreeParent";
+import { MapWrapper } from "../Map/MapWrapper";
 import { WrapletCreator } from "./types/WrapletCreator";
+import { Status } from "../Wraplet/types/Status";
 export declare class DefaultCore<N extends Node = Node, M extends WrapletChildrenMap = {}> implements Core<N, M> {
     node: N;
     [CoreSymbol]: true;
     [NodeTreeParentSymbol]: true;
-    isDestroyed: boolean;
-    isGettingDestroyed: boolean;
-    isGettingInitialized: boolean;
-    isInitialized: boolean;
+    private statusWritable;
+    get status(): Status;
     mapWrapper: MapWrapper<M>;
     private instantiatedChildren;
     private destroyChildListeners;
     private instantiateChildListeners;
     private listeners;
-    private defaultWrapletCreator;
     private wrapletCreator;
     constructor(node: N, map: M | MapWrapper<M>, initOptions?: Partial<CoreInitOptions<M>>);
     /**
@@ -31,7 +29,7 @@ export declare class DefaultCore<N extends Node = Node, M extends WrapletChildre
      * processing occurs (instantiate child listeners) that needs access to the children manager,
      * so the children manager has to exist already.
      */
-    init(): void;
+    initialize(): Promise<void>;
     get map(): WrapletChildrenMapWithDefaults<M>;
     instantiateChildren(): WrapletChildren<M>;
     syncChildren(): void;
@@ -42,12 +40,12 @@ export declare class DefaultCore<N extends Node = Node, M extends WrapletChildre
     private instantiateMultipleWrapletsChild;
     addDestroyChildListener(callback: DestroyChildListener<M, keyof M>): void;
     addInstantiateChildListener(callback: InstantiateChildListener<M, keyof M>): void;
-    setWrapletCreator(wrapletCreator: WrapletCreator<N, M>): void;
+    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletChildrenMap>): void;
     private prepareIndividualWraplet;
     /**
      * This method removes from nodes references to this wraplet and its children recursively.
      */
-    destroy(): void;
+    destroy(): Promise<void>;
     private findChildren;
     addEventListener(node: Node, eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
     get children(): WrapletChildren<M>;

package/dist/Core/defaultWrapletCreator.d.ts

@@ -0,0 +1,6 @@
+import { WrapletCreatorArgs } from "./types/WrapletCreator";
+import { WrapletChildrenMap } from "../Wraplet/types/WrapletChildrenMap";
+import { Constructable } from "../utils/types/Utils";
+import { Core } from "./types/Core";
+import { Wraplet } from "../Wraplet/types/Wraplet";
+export declare function defaultWrapletCreator(args: WrapletCreatorArgs<Node, WrapletChildrenMap>, currentCoreClass: Constructable<Core>): Wraplet;

package/dist/Core/types/ArgCreator.d.ts

@@ -0,0 +1,9 @@
+import { WrapletCreatorArgs } from "./WrapletCreator";
+import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+declare const ArgCreatorSymbol: unique symbol;
+export { ArgCreatorSymbol };
+export interface ArgCreator<N extends Node, M extends WrapletChildrenMap = {}> {
+    [ArgCreatorSymbol]: true;
+    createArg(args: WrapletCreatorArgs<N, M>): unknown;
+}
+export declare function isArgCreator<N extends Node, M extends WrapletChildrenMap = {}>(object: unknown): object is ArgCreator<N, M>;

package/dist/{types → Core/types}/Core.d.ts

@@ -1,35 +1,22 @@
-import { WrapletChildren } from "./WrapletChildren";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "./WrapletChildrenMap";
+import { WrapletChildren } from "../../Wraplet/types/WrapletChildren";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../../Wraplet/types/WrapletChildrenMap";
 import { DestroyChildListener } from "./DestroyChildListener";
 import { InstantiateChildListener } from "./InstantiateChildListener";
-import { NodeTreeParent, NodeTreeParentSymbol } from "./NodeTreeParent";
-import { Wraplet } from "./Wraplet";
+import { Wraplet } from "../../Wraplet/types/Wraplet";
 import { WrapletCreator } from "./WrapletCreator";
+import { Status } from "../../Wraplet/types/Status";
 declare const CoreSymbol: unique symbol;
 export { CoreSymbol };
 /**
  * Children manager interface that defines the public API for managing wraplet relationships
  * and lifecycles.
  */
-export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}> extends NodeTreeParent {
+export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}> {
     [CoreSymbol]: true;
-    [NodeTreeParentSymbol]: true;
     /**
-     * Indicates whether the core is destroyed.
+     * Core status.
      */
-    isDestroyed: boolean;
-    /**
-     * Indicates whether the core is in the process of being destroyed.
-     */
-    isGettingDestroyed: boolean;
-    /**
-     * Indicates whether the core is in the process of being initialized.
-     */
-    isGettingInitialized: boolean;
-    /**
-     * Indicates whether the core has been initialized.
-     */
-    isInitialized: boolean;
+    status: Status;
     /**
      * The children map that defines the relationships between nodes.
      */
@@ -42,7 +29,7 @@ export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}>
      * Initialize the core.
      * This must be called after construction to fully initialize the core.
      */
-    init(): void;
+    initialize(): Promise<void>;
     /**
      * Instantiate children based on the map and the current node.
      */
@@ -62,7 +49,7 @@ export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}>
     /**
      * Destroy all children.
      */
-    destroy(): void;
+    destroy(): Promise<void>;
     /**
      * Add an event listener to a node and track it for cleanup.
      */
@@ -71,7 +58,7 @@ export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}>
     /**
      * Allows for overriding the default wraplet creation process.
      */
-    setWrapletCreator(wrapletCreator: WrapletCreator<N, M>): void;
+    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletChildrenMap>): void;
     /**
      * Get the instantiated children.
      */

package/dist/{types → Core/types}/CoreInitOptions.d.ts

@@ -1,5 +1,5 @@
 import { InstantiateChildListener } from "./InstantiateChildListener";
-import { WrapletChildrenMap } from "./WrapletChildrenMap";
+import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
 import { DestroyChildListener } from "./DestroyChildListener";
 export type CoreInitOptions<M extends WrapletChildrenMap = WrapletChildrenMap> = {
     instantiateChildListeners: InstantiateChildListener<M, keyof M>[];

package/dist/Core/types/DestroyChildListener.d.ts

@@ -0,0 +1,3 @@
+import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+import { ChildInstance } from "../../Wraplet/types/ChildInstance";
+export type DestroyChildListener<M extends WrapletChildrenMap, K extends keyof M> = (wraplet: ChildInstance<M, K>, id: K) => void;

package/dist/Core/types/DestroyListener.d.ts

@@ -0,0 +1,2 @@
+import { Wraplet } from "../../Wraplet/types/Wraplet";
+export type DestroyListener<N extends Node> = (wraplet: Wraplet<N>) => Promise<void>;

package/dist/Core/types/InstantiateChildListener.d.ts

@@ -0,0 +1,3 @@
+import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+import { ChildInstance } from "../../Wraplet/types/ChildInstance";
+export type InstantiateChildListener<M extends WrapletChildrenMap, K extends keyof M> = (wraplet: ChildInstance<M, K>, id: K) => void;

package/dist/Core/types/WrapletCreator.d.ts

@@ -0,0 +1,15 @@
+import { Wraplet } from "../../Wraplet/types/Wraplet";
+import { MapWrapper } from "../../Map/MapWrapper";
+import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+import { CoreInitOptions } from "./CoreInitOptions";
+import { Constructable } from "../../utils/types/Utils";
+import { Core } from "./Core";
+export type WrapletCreator<N extends Node, M extends WrapletChildrenMap> = (args: WrapletCreatorArgs<N, M>, currentCoreClass: Constructable<Core>) => Wraplet<N>;
+export type WrapletCreatorArgs<N extends Node, M extends WrapletChildrenMap> = {
+    id: keyof M;
+    Class: Constructable<Wraplet<N>>;
+    element: N;
+    map: MapWrapper<M>;
+    initOptions: CoreInitOptions<M>;
+    args: unknown[];
+};

package/dist/Map/MapRepeat.d.ts

@@ -1,6 +1,6 @@
 import { MapWrapper } from "./MapWrapper";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../types/WrapletChildrenMap";
-import { DynamicMap, DynamicMapSymbol } from "../types/Map/DynamicMap";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
+import { DynamicMap, DynamicMapSymbol } from "./types/DynamicMap";
 export declare class MapRepeat implements DynamicMap {
     private readonly levels;
     [DynamicMapSymbol]: true;

package/dist/Map/MapWrapper.d.ts

@@ -1,4 +1,4 @@
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../types/WrapletChildrenMap";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
 type RecursiveMapKeys<T extends WrapletChildrenMap> = {
     [K in keyof T]: T[K] extends {
         map: infer M extends WrapletChildrenMap;

package/dist/{types/Map → Map/types}/DynamicMap.d.ts

@@ -1,5 +1,5 @@
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../WrapletChildrenMap";
-import { MapWrapper } from "../../Map/MapWrapper";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../../Wraplet/types/WrapletChildrenMap";
+import { MapWrapper } from "../MapWrapper";
 declare const DynamicMapSymbol: unique symbol;
 export { DynamicMapSymbol };
 export interface DynamicMap {

package/dist/{WrapletChildrenMap.d.ts → Map/utils.d.ts}

@@ -1,4 +1,4 @@
-import { WrapletChildDefinition, WrapletChildDefinitionWithDefaults } from "./types/WrapletChildDefinition";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "./types/WrapletChildrenMap";
+import { WrapletChildDefinition, WrapletChildDefinitionWithDefaults } from "../Wraplet/types/WrapletChildDefinition";
+import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
 export declare function addDefaultsToChildDefinition<M extends WrapletChildrenMap, T extends WrapletChildDefinition<M>>(definition: T): WrapletChildDefinitionWithDefaults<T, M>;
 export declare function fillMapWithDefaults<M extends WrapletChildrenMap>(map: M): WrapletChildrenMapWithDefaults<M>;

package/dist/NodeTreeManager/DefaultNodeTreeManager.d.ts

@@ -1,12 +1,12 @@
-import { NodeTreeManager } from "./NodeTreeManager";
-import { Wraplet } from "../types/Wraplet";
-import { WrapletSetReadonly } from "../types/Set/WrapletSetReadonly";
-export type Initializer = (node: Node) => Wraplet[];
+import { NodeTreeManager } from "./types/NodeTreeManager";
+import { Wraplet } from "../Wraplet/types/Wraplet";
+import { WrapletSetReadonly } from "../Set/types/WrapletSetReadonly";
+export type Initializer = (node: Node) => Promise<Wraplet[]>;
 export default class DefaultNodeTreeManager implements NodeTreeManager {
     private initializers;
     private items;
     addWrapletInitializer(callback: Initializer): void;
-    initializeNodeTree(node: Node): void;
-    destroyNodeTree(node: Node): void;
+    initializeNodeTree(node: Node): Promise<void>;
+    destroyNodeTree(node: Node): Promise<void>;
     getSet(): WrapletSetReadonly;
 }

package/dist/NodeTreeManager/types/NodeTreeManager.d.ts

@@ -0,0 +1,8 @@
+import { Initializer } from "../DefaultNodeTreeManager";
+import { WrapletSetReadonly } from "../../Set/types/WrapletSetReadonly";
+export interface NodeTreeManager {
+    addWrapletInitializer(callback: Initializer): void;
+    initializeNodeTree(node: Node): Promise<void>;
+    destroyNodeTree(node: Node): Promise<void>;
+    getSet(): WrapletSetReadonly;
+}

package/dist/{types → NodeTreeManager/types}/NodeTreeParent.d.ts

@@ -1,8 +1,10 @@
-import { Wraplet } from "./Wraplet";
+import { Wraplet } from "../../Wraplet/types/Wraplet";
 declare const NodeTreeParentSymbol: unique symbol;
 export { NodeTreeParentSymbol };
 export interface NodeTreeParent {
     [NodeTreeParentSymbol]: true;
-    getNodeTreeChildren(): Wraplet[];
+    wraplet: {
+        getNodeTreeChildren(): Wraplet[];
+    };
 }
 export declare function isNodeTreeParent(object: object): object is NodeTreeParent;

package/dist/{utils.d.ts → NodeTreeManager/utils.d.ts}

@@ -1,8 +1,8 @@
-import { Wraplet } from "./types/Wraplet";
-import { WrapletSet } from "./types/Set/WrapletSet";
+import { Wraplet } from "../Wraplet/types/Wraplet";
+import { WrapletSet } from "../Set/types/WrapletSet";
 export declare function isParentNode(node: Node): node is ParentNode;
 export declare function getWrapletsFromNode<N extends Node = Node, W extends Wraplet<N> = Wraplet<N>>(node: N): WrapletSet<W>;
 export declare function removeWrapletFromNode<N extends Node>(wraplet: Wraplet<N>, node: N): boolean;
 export declare function addWrapletToNode<N extends Node>(wraplet: Wraplet<N>, node: N): void;
-export declare function actOnNodesRecursively(node: Node, callback: (node: Node) => void): void;
-export declare function destroyWrapletsRecursively(node: Node): void;
+export declare function actOnNodesRecursively(node: Node, callback: (node: Node) => Promise<void>): Promise<void>;
+export declare function destroyWrapletsRecursively(node: Node): Promise<void>;

package/dist/Set/DefaultSearchableSet.d.ts

@@ -1,4 +1,4 @@
-import { BaseSet } from "../types/Set/BaseSet";
+import { BaseSet } from "./types/BaseSet";
 export declare class DefaultSearchableSet<T> extends Set<T> implements BaseSet<T> {
     find(filter: (wraplet: T) => boolean): T[];
     findOne(filter: (wraplet: T) => boolean): T | null;

package/dist/Set/DefaultWrapletSet.d.ts

@@ -1,7 +1,7 @@
-import { WrapletSet, WrapletSetSymbol } from "../types/Set/WrapletSet";
-import { Wraplet } from "../types/Wraplet";
+import { WrapletSet, WrapletSetSymbol } from "./types/WrapletSet";
+import { Wraplet } from "../Wraplet/types/Wraplet";
 import { DefaultSearchableSet } from "./DefaultSearchableSet";
-import { WrapletSetReadonlySymbol } from "../types/Set/WrapletSetReadonly";
+import { WrapletSetReadonlySymbol } from "./types/WrapletSetReadonly";
 export declare class DefaultWrapletSet<T extends Wraplet> extends DefaultSearchableSet<T> implements WrapletSet {
     [WrapletSetReadonlySymbol]: true;
     [WrapletSetSymbol]: true;

package/dist/Set/DefaultWrapletSetReadonly.d.ts

@@ -1,5 +1,5 @@
-import { Wraplet } from "../types/Wraplet";
-import { WrapletSetReadonly, WrapletSetReadonlySymbol } from "../types/Set/WrapletSetReadonly";
+import { Wraplet } from "../Wraplet/types/Wraplet";
+import { WrapletSetReadonly, WrapletSetReadonlySymbol } from "./types/WrapletSetReadonly";
 import { DefaultSearchableSet } from "./DefaultSearchableSet";
 export declare class DefaultWrapletSetReadonly<T extends Wraplet> extends DefaultSearchableSet<T> implements WrapletSetReadonly {
     [WrapletSetReadonlySymbol]: true;

package/dist/{types/Set → Set/types}/WrapletSet.d.ts

@@ -1,4 +1,4 @@
-import { Wraplet } from "../Wraplet";
+import { Wraplet } from "../../Wraplet/types/Wraplet";
 import { BaseSet } from "./BaseSet";
 declare const WrapletSetSymbol: unique symbol;
 export { WrapletSetSymbol };

package/dist/{types/Set → Set/types}/WrapletSetReadonly.d.ts

@@ -1,4 +1,4 @@
-import { Wraplet } from "../Wraplet";
+import { Wraplet } from "../../Wraplet/types/Wraplet";
 import { BaseSet } from "./BaseSet";
 declare const WrapletSetReadonlySymbol: unique symbol;
 export { WrapletSetReadonlySymbol };

package/dist/Storage/AbstractNongranularKeyValueStorage.d.ts

@@ -0,0 +1,28 @@
+import { KeyValueStorage, KeyValueStorageSymbol } from "./types/KeyValueStorage";
+import { StorageValidators } from "./types/StorageValidators";
+import { NongranularStorageOptions } from "./NongranularStorageOptions";
+export declare abstract class AbstractNongranularKeyValueStorage<D extends Record<string, unknown>> implements KeyValueStorage<D> {
+    protected defaults: D;
+    protected validators: StorageValidators<D>;
+    [KeyValueStorageSymbol]: true;
+    private data;
+    private options;
+    constructor(defaults: D, validators: StorageValidators<D>, options: Partial<NongranularStorageOptions<D>>);
+    has(key: keyof D): Promise<boolean>;
+    get<T extends keyof D>(key: T): Promise<D[T]>;
+    getMultiple<T extends keyof D>(keys: T[]): Promise<Pick<D, T>>;
+    getAll(): Promise<D>;
+    set<T extends keyof D>(key: T, value: D[T]): Promise<void>;
+    setMultiple(data: Partial<D>): Promise<void>;
+    setAll(data: D): Promise<void>;
+    delete(key: keyof D): Promise<void>;
+    deleteMultiple(keys: (keyof D)[]): Promise<void>;
+    deleteAll(): Promise<void>;
+    refresh(): Promise<void>;
+    private fetchFreshData;
+    private validateData;
+    private validateValidators;
+    protected abstract getValue(): Promise<string>;
+    protected abstract setValue(value: D): Promise<void>;
+    protected abstract deleteAllValues(): Promise<void>;
+}

package/dist/Storage/ElementAttributeStorage.d.ts

@@ -0,0 +1,17 @@
+import { StorageValidators } from "./types/StorageValidators";
+import { ElementOptionsMerger } from "./ElementOptionsMerger";
+import { AbstractNongranularKeyValueStorage } from "./AbstractNongranularKeyValueStorage";
+export type ElementStorageOptions<D extends Record<string, unknown>> = {
+    keepFresh: boolean;
+    elementOptionsMerger: ElementOptionsMerger<D>;
+};
+export declare class ElementAttributeStorage<D extends Record<string, unknown>> extends AbstractNongranularKeyValueStorage<D> {
+    private element;
+    private attribute;
+    protected defaults: D;
+    protected validators: StorageValidators<D>;
+    constructor(element: Element, attribute: string, defaults: D, validators: StorageValidators<D>, options?: Partial<ElementStorageOptions<D>>);
+    protected getValue(): Promise<string>;
+    protected setValue(value: D): Promise<void>;
+    protected deleteAllValues(): Promise<void>;
+}

package/dist/Storage/ElementStorage.d.ts

@@ -1,30 +1,12 @@
-import { Storage } from "../types/Storage/Storage";
-import { StorageValidators } from "../types/Storage/StorageValidators";
-import { ElementOptionsMerger } from "./ElementOptionsMerger";
-export type ElementStorageOptions<D extends Record<string, unknown>> = {
-    keepFresh: boolean;
-    elementOptionsMerger: ElementOptionsMerger<D>;
-};
-export declare class ElementStorage<D extends Record<string, unknown>> implements Storage<D> {
+import { StorageValidators } from "./types/StorageValidators";
+import { AbstractNongranularKeyValueStorage } from "./AbstractNongranularKeyValueStorage";
+import { NongranularStorageOptions } from "./NongranularStorageOptions";
+export declare class ElementStorage<D extends Record<string, unknown>, E extends Element = HTMLScriptElement> extends AbstractNongranularKeyValueStorage<D> {
     private element;
-    private attribute;
-    private defaults;
-    private validators;
-    private data;
-    private options;
-    constructor(element: Element, attribute: string, defaults: D, validators: StorageValidators<D>, options?: Partial<ElementStorageOptions<D>>);
-    has(key: keyof D): boolean;
-    get<T extends keyof D>(key: T): D[T];
-    getMultiple<T extends keyof D>(keys: T[]): Pick<D, T>;
-    getAll(): D;
-    set<T extends keyof D>(key: T, value: D[T]): void;
-    setMultiple(data: Partial<D>): void;
-    setAll(data: D): void;
-    delete(key: keyof D): void;
-    deleteMultiple(keys: (keyof D)[]): void;
-    deleteAll(): void;
-    refresh(): void;
-    private fetchFreshData;
-    private validateData;
-    private getAttributeValue;
+    protected defaults: D;
+    protected validators: StorageValidators<D>;
+    constructor(element: E, defaults: D, validators: StorageValidators<D>, options?: Partial<NongranularStorageOptions<D>>);
+    protected getValue(): Promise<string>;
+    protected setValue(value: D): Promise<void>;
+    protected deleteAllValues(): Promise<void>;
 }

package/dist/Storage/NongranularStorageOptions.d.ts

@@ -0,0 +1,5 @@
+import { ElementOptionsMerger } from "./ElementOptionsMerger";
+export type NongranularStorageOptions<D extends Record<string, unknown>> = {
+    keepFresh: boolean;
+    elementOptionsMerger: ElementOptionsMerger<D>;
+};

package/dist/Storage/StorageWrapper.d.ts

@@ -0,0 +1,21 @@
+import { KeyValueStorage, KeyValueStorageSymbol } from "./types/KeyValueStorage";
+import { StorageValidators } from "./types/StorageValidators";
+export declare class StorageWrapper<D extends Record<string, unknown>> implements KeyValueStorage<D> {
+    private storage;
+    private defaults;
+    private validators;
+    [KeyValueStorageSymbol]: true;
+    constructor(storage: KeyValueStorage<D>, defaults: D, validators: StorageValidators<D>);
+    has(key: keyof D): Promise<boolean>;
+    get<T extends keyof D>(key: T): Promise<D[T]>;
+    getMultiple<T extends keyof D>(keys: T[]): Promise<Pick<D, T>>;
+    getAll(): Promise<D>;
+    set<T extends keyof D>(key: T, value: D[T]): Promise<void>;
+    setMultiple(data: Partial<D>): Promise<void>;
+    setAll(data: D): Promise<void>;
+    delete(key: keyof D): Promise<void>;
+    deleteMultiple(keys: (keyof D)[]): Promise<void>;
+    deleteAll(): Promise<void>;
+    private validateGetValue;
+    private validateSetValue;
+}

package/dist/Storage/types/KeyValueStorage.d.ts

@@ -0,0 +1,13 @@
+import { KeyValueStorageReadonly } from "./KeyValueStorageReadonly";
+declare const KeyValueStorageSymbol: unique symbol;
+export { KeyValueStorageSymbol };
+export interface KeyValueStorage<D extends Record<string, unknown>> extends KeyValueStorageReadonly<D> {
+    [KeyValueStorageSymbol]: true;
+    set: <T extends keyof D>(key: T, value: D[T]) => Promise<void>;
+    setMultiple: (data: Partial<D>) => Promise<void>;
+    setAll: (data: D) => Promise<void>;
+    delete: (key: keyof D) => Promise<void>;
+    deleteMultiple: (keys: (keyof D)[]) => Promise<void>;
+    deleteAll: () => Promise<void>;
+}
+export declare function isKeyValueStorage<D extends Record<string, unknown>>(object: unknown): object is KeyValueStorage<D>;

package/dist/Storage/types/KeyValueStorageReadonly.d.ts

@@ -0,0 +1,6 @@
+export type KeyValueStorageReadonly<D extends Record<string, unknown>> = {
+    get: <T extends keyof D>(key: T) => Promise<D[T]>;
+    getMultiple: <T extends keyof D>(keys: T[]) => Promise<Pick<D, T>>;
+    getAll: () => Promise<D>;
+    has: (key: keyof D) => Promise<boolean>;
+};

package/dist/Wraplet/createWrapletApi.d.ts

@@ -0,0 +1,6 @@
+import { WrapletChildrenMap } from "./types/WrapletChildrenMap";
+import { Groupable } from "../types/Groupable";
+import { NodeTreeParent } from "../NodeTreeManager/types/NodeTreeParent";
+import { WrapletApiFactoryArgs } from "./types/WrapletApiFactoryArgs";
+import { WrapletApi, WrapletApiDebug } from "./types/WrapletApi";
+export declare const createWrapletApi: <N extends Node, M extends WrapletChildrenMap>(args: WrapletApiFactoryArgs<N, M>) => WrapletApi<N> & WrapletApiDebug<N> & NodeTreeParent["wraplet"] & Groupable["wraplet"];

package/dist/Wraplet/types/Status.d.ts

@@ -0,0 +1,9 @@
+export interface Status {
+    readonly isInitialized: boolean;
+    readonly isGettingInitialized: boolean;
+    readonly isDestroyed: boolean;
+    readonly isGettingDestroyed: boolean;
+}
+export type StatusWritable = {
+    -readonly [K in keyof Status]: Status[K];
+};

package/dist/Wraplet/types/Wraplet.d.ts

@@ -0,0 +1,8 @@
+import { WrapletApi } from "./WrapletApi";
+declare const WrapletSymbol: unique symbol;
+export { WrapletSymbol };
+export interface Wraplet<N extends Node = Node> {
+    [WrapletSymbol]: true;
+    wraplet: WrapletApi<N>;
+}
+export declare function isWraplet<N extends Node>(object: unknown): object is Wraplet<N>;

package/dist/Wraplet/types/WrapletApi.d.ts

@@ -0,0 +1,12 @@
+import { DestroyListener } from "../../Core/types/DestroyListener";
+import { Status } from "./Status";
+export interface WrapletApi<N extends Node = Node> {
+    status: Status;
+    accessNode(callback: (node: N) => void): void;
+    destroy(): Promise<void>;
+    initialize(): Promise<void>;
+    addDestroyListener(callback: DestroyListener<N>): void;
+}
+export interface WrapletApiDebug<N extends Node> {
+    __nodeAccessors: ((node: N) => void)[];
+}

package/dist/Wraplet/types/WrapletApiFactoryArgs.d.ts

@@ -0,0 +1,16 @@
+import { WrapletChildrenMap } from "./WrapletChildrenMap";
+import { Core } from "../../Core/types/Core";
+import { DestroyListener } from "../../Core/types/DestroyListener";
+import { WrapletApiFactoryBasicCallback } from "./WrapletApiFactoryBasicCallback";
+import { GroupExtractor } from "../../types/Groupable";
+import { Status } from "./Status";
+import { Wraplet } from "./Wraplet";
+export type WrapletApiFactoryArgs<N extends Node = Node, M extends WrapletChildrenMap = WrapletChildrenMap> = {
+    core: Core<N, M>;
+    wraplet: Wraplet<N>;
+    status?: Status;
+    destroyListeners?: DestroyListener<N>[];
+    initializeCallback?: WrapletApiFactoryBasicCallback;
+    destroyCallback?: WrapletApiFactoryBasicCallback;
+    groupExtractor?: GroupExtractor;
+};

package/dist/Wraplet/types/WrapletApiFactoryBasicCallback.d.ts

@@ -0,0 +1 @@
+export type WrapletApiFactoryBasicCallback = () => Promise<void>;

package/dist/{types → Wraplet/types}/WrapletChildDefinition.d.ts

@@ -1,8 +1,8 @@
 import { Wraplet } from "./Wraplet";
 import { WrapletChildrenMap } from "./WrapletChildrenMap";
-import { CoreInitOptions } from "./CoreInitOptions";
-import { DynamicMap } from "./Map/DynamicMap";
-import { Constructable } from "./Utils";
+import { CoreInitOptions } from "../../Core/types/CoreInitOptions";
+import { DynamicMap } from "../../Map/types/DynamicMap";
+import { Constructable } from "../../utils/types/Utils";
 export type SelectorCallback<N extends ParentNode = ParentNode> = (node: N) => Node[];
 export type WrapletChildDefinition<M extends WrapletChildrenMap = WrapletChildrenMap> = {
     selector?: string | SelectorCallback;