wraplet 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/DependencyManager/DDM.d.ts

@@ -0,0 +1,76 @@
+import { WrapletDependencies } from "../Wraplet/types/WrapletDependencies";
+import { MultipleDependencyKeys, SingleDependencyKeys, WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
+import { DependencyInstance } from "../Wraplet/types/DependencyInstance";
+import { DDMOptions } from "./types/DDMOptions";
+import { DependencyManager, DependencyManagerSymbol } from "./types/DependencyManager";
+import { Status } from "../Wraplet/types/Status";
+import { DependencyLifecycleAsyncListener } from "./types/DependencyLifecycleAsyncListener";
+import { DependencyLifecycleListener } from "./types/DependencyLifecycleListener";
+import { MapTreeBuilder } from "../Map/MapTreeBuilder";
+import { Injector } from "../Injector/types/Injector";
+export declare class DDM<N extends Node = Node, M extends WrapletDependencyMap = {}> implements DependencyManager<N, M> {
+    node: N;
+    [DependencyManagerSymbol]: true;
+    private logger;
+    private dependenciesAreInstantiated;
+    private statusWritable;
+    get status(): Status;
+    private readonly mapTree;
+    private directDependencies;
+    private wrappedDependencies;
+    private instantiatedDependencyListeners;
+    private initializedDependencyListeners;
+    private destroyedDependencyListeners;
+    constructor(node: N, map: M | MapTreeBuilder<M>, options?: Partial<DDMOptions<M>>);
+    /**
+     * Initialize dependencies.
+     */
+    initializeDependencies(): Promise<void>;
+    get map(): WrapletDependencyMapWithDefaults<M>;
+    instantiateDependencies(): void;
+    private findExistingWraplet;
+    private instantiateSingleWrapletDependency;
+    private instantiateWrapletItem;
+    private instantiateMultipleDependencies;
+    addDependencyInstantiatedListener<K extends keyof M>(id: K, callback: DependencyLifecycleListener<M, K>): void;
+    addDependencyInitializedListener<K extends keyof M>(id: K, callback: DependencyLifecycleAsyncListener<M, K>): void;
+    addDependencyDestroyedListener<K extends keyof M>(id: K, callback: DependencyLifecycleAsyncListener<M, K>): void;
+    setExistingInstance<K extends SingleDependencyKeys<M> & Extract<keyof M, string>>(id: K, wraplet: DependencyInstance<M, K>): void;
+    addExistingInstance<K extends MultipleDependencyKeys<M> & Extract<keyof M, string>>(id: K, wraplet: DependencyInstance<M, K>): void;
+    private prepareIndividualWraplet;
+    private createDependencyDestroyListener;
+    /**
+     * Checks whether a required dependency has been removed while the DDM
+     * is NOT being destroyed itself. Returns the error instance instead of
+     * throwing, so the caller can route it through the lifecycle error pipeline.
+     */
+    private validateRequiredDependencyAfterRemoval;
+    /**
+     * This method removes from nodes references to this wraplet and its dependencies recursively.
+     */
+    destroyDependencies(): Promise<void>;
+    private findChildrenElements;
+    get dependencies(): WrapletDependencies<M>;
+    private removeDependency;
+    private validateMapItem;
+    private validateMapItemForNonParent;
+    private validateElements;
+    /**
+     * Set up a proxy to check if dependencies have not been destroyed before fetching them.
+     */
+    private wrapDependencies;
+    private defaultOptions;
+    private destroyDeps;
+    /**
+     * Creates a definition for creating a node wrapper.
+     *
+     * @param map_or_position
+     *   You can provide a map or a number representing the
+     *   relative position of the ancestor map that should be
+     *   reused.
+     *
+     *   This is useful for recursive maps.
+     * @param options
+     */
+    static createInjector<N extends Node, M extends WrapletDependencyMap>(map_or_position: WrapletDependencyMap | number, options?: DDMOptions): Injector<N, M, DDMOptions>;
+}

package/dist/DependencyManager/types/DDMOptions.d.ts

@@ -0,0 +1,10 @@
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
+import { DependencyLifecycleAsyncListener } from "./DependencyLifecycleAsyncListener";
+import { DependencyLifecycleListener } from "./DependencyLifecycleListener";
+import { Logger } from "../../Logger/types/Logger";
+export type DDMOptions<M extends WrapletDependencyMap = WrapletDependencyMap> = {
+    dependencyInstantiatedListeners?: Map<keyof M, DependencyLifecycleListener<M, keyof M>[]>;
+    dependencyInitializedListeners?: Map<keyof M, DependencyLifecycleAsyncListener<M, keyof M>[]>;
+    dependencyDestroyedListeners?: Map<keyof M, DependencyLifecycleAsyncListener<M, keyof M>[]>;
+    logger?: Logger;
+};

package/dist/{Core/types/DependencyInstantiatedListener.d.ts → DependencyManager/types/DependencyLifecycleAsyncListener.d.ts}

@@ -1,3 +1,3 @@
 import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
 import { DependencyInstance } from "../../Wraplet/types/DependencyInstance";
-export type DependencyInstantiatedListener<M extends WrapletDependencyMap, K extends keyof M> = (wraplet: DependencyInstance<M, K>, id: K) => void;
+export type DependencyLifecycleAsyncListener<M extends WrapletDependencyMap, K extends keyof M> = (wraplet: DependencyInstance<M, K>) => Promise<void>;

package/dist/{Core/types/DestroyDependencyListener.d.ts → DependencyManager/types/DependencyLifecycleListener.d.ts}

@@ -1,3 +1,3 @@
 import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
 import { DependencyInstance } from "../../Wraplet/types/DependencyInstance";
-export type DependencyDestroyedListener<M extends WrapletDependencyMap, K extends keyof M> = (wraplet: DependencyInstance<M, K>, id: K) => void;
+export type DependencyLifecycleListener<M extends WrapletDependencyMap, K extends keyof M> = (wraplet: DependencyInstance<M, K>) => void;

package/dist/DependencyManager/types/DependencyManager.d.ts

@@ -0,0 +1,55 @@
+import { WrapletDependencies } from "../../Wraplet/types/WrapletDependencies";
+import { MultipleDependencyKeys, SingleDependencyKeys, WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
+import { DependencyLifecycleAsyncListener } from "./DependencyLifecycleAsyncListener";
+import { DependencyLifecycleListener } from "./DependencyLifecycleListener";
+import { DependencyInstance } from "../../Wraplet/types/DependencyInstance";
+export declare const DependencyManagerSymbol: unique symbol;
+/**
+ * Dependency manager interface that defines the public API for managing wraplet relationships
+ * and lifecycles.
+ */
+export interface DependencyManager<N extends Node = Node, M extends WrapletDependencyMap = {}> {
+    [DependencyManagerSymbol]: true;
+    /**
+     * The node that the manager is managing.
+     */
+    node: N;
+    /**
+     * Instantiate dependencies based on the map and the current node.
+     */
+    instantiateDependencies(): void;
+    /**
+     * Initialize dependencies.
+     */
+    initializeDependencies(): Promise<void>;
+    /**
+     * Destroy all dependencies.
+     */
+    destroyDependencies(): Promise<void>;
+    /**
+     * Add a listener that will be called when a dependency is initialized.
+     */
+    addDependencyInitializedListener<K extends keyof M>(id: K, callback: DependencyLifecycleAsyncListener<M, K>): void;
+    /**
+     * Add a listener that will be called when a dependency is destroyed.
+     */
+    addDependencyDestroyedListener<K extends keyof M>(id: K, callback: DependencyLifecycleAsyncListener<M, K>): void;
+    /**
+     * Add a listener that will be called when a dependency is instantiated.
+     */
+    addDependencyInstantiatedListener<K extends keyof M>(id: K, callback: DependencyLifecycleListener<M, K>): void;
+    /**
+     * This method allows you to set an existing dependency instance.
+     */
+    setExistingInstance<K extends SingleDependencyKeys<M> & Extract<keyof M, string>>(id: K, wraplet: DependencyInstance<M, K>): void;
+    /**
+     * This method allows you to add an existing dependency instance
+     * to a wraplet set.
+     */
+    addExistingInstance<K extends MultipleDependencyKeys<M> & Extract<keyof M, string>>(id: K, wraplet: DependencyInstance<M, K>): void;
+    /**
+     * Get the available dependencies.
+     */
+    readonly dependencies: WrapletDependencies<M>;
+}
+export declare function isDependencyManager<N extends Node, M extends WrapletDependencyMap>(object: unknown): object is DependencyManager<N, M>;

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

@@ -0,0 +1,5 @@
+import { Wraplet } from "../../Wraplet/types/Wraplet";
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
+import { WrapletDependencyDefinitionWithDefaults } from "../../Wraplet/types/WrapletDependencyDefinition";
+import { MapTreeBuilder } from "../../Map/MapTreeBuilder";
+export type WrapletCreator<N extends Node, M extends WrapletDependencyMap> = (node: N, definition: WrapletDependencyDefinitionWithDefaults, map: MapTreeBuilder<M>) => Wraplet;

package/dist/Injector/types/Injector.d.ts

@@ -0,0 +1,6 @@
+import { MapTreeBuilder } from "../../Map/MapTreeBuilder";
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
+export type Injector<N extends Node = Node, M extends WrapletDependencyMap = WrapletDependencyMap, D = any> = {
+    data?: D;
+    callback: (node: N, map: MapTreeBuilder<M>, data?: D) => unknown;
+};

package/dist/Logger/ConsoleLogger.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from "./types/Logger";
+export declare class ConsoleLogger implements Logger {
+    #private;
+    private constructor();
+    dumpError(error: Error): void;
+    static getGlobalLogger(): Logger;
+}

package/dist/Logger/types/Logger.d.ts

@@ -0,0 +1,3 @@
+export interface Logger {
+    dumpError(error: Error): void;
+}

package/dist/Map/MapTreeBuilder.d.ts

@@ -0,0 +1,15 @@
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
+declare const MapTreeBuilderSymbol: unique symbol;
+export declare class MapTreeBuilder<M extends WrapletDependencyMap = WrapletDependencyMap> {
+    private parent?;
+    [MapTreeBuilderSymbol]: true;
+    private map?;
+    private children;
+    constructor(parent?: MapTreeBuilder | undefined);
+    getParent(): MapTreeBuilder;
+    createChild<CM extends WrapletDependencyMap>(name: keyof M): MapTreeBuilder<CM>;
+    setMap(map: M): void;
+    getMap(): WrapletDependencyMapWithDefaults<M>;
+}
+export declare function isMapTreeBuilder(object: unknown): object is MapTreeBuilder;
+export {};

package/dist/Map/utils.d.ts

@@ -1,4 +1,4 @@
 import { WrapletDependencyDefinition, WrapletDependencyDefinitionWithDefaults } from "../Wraplet/types/WrapletDependencyDefinition";
 import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
-export declare function addDefaultsToDependencyDefinition<M extends WrapletDependencyMap, T extends WrapletDependencyDefinition<M>>(definition: T): WrapletDependencyDefinitionWithDefaults<T, M>;
+export declare function addDefaultsToDependencyDefinition<T extends WrapletDependencyDefinition>(definition: T): WrapletDependencyDefinitionWithDefaults<T>;
 export declare function fillMapWithDefaults<M extends WrapletDependencyMap>(map: M): WrapletDependencyMapWithDefaults<M>;

package/dist/NodeTreeManager/DNTM.d.ts

@@ -0,0 +1,8 @@
+import { NodeTreeManager } from "./types/NodeTreeManager";
+import { NodeInitializer } from "./types/NodeInitializer";
+export declare class DNTM<CONTEXT = unknown> implements NodeTreeManager<CONTEXT> {
+    private initializers;
+    addNodeInitializer(callback: NodeInitializer<CONTEXT>): void;
+    initializeNode(node: Node, context?: CONTEXT): Promise<void>;
+    destroyNode(node: Node): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export type NodeInitializer<CONTEXT> = (node: Node, context?: CONTEXT) => Promise<void>;

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

@@ -1,8 +1,6 @@
-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;
+import { NodeInitializer } from "./NodeInitializer";
+export interface NodeTreeManager<CONTEXT = unknown> {
+    addNodeInitializer(callback: NodeInitializer<CONTEXT>): void;
+    initializeNode(node: Node, context?: CONTEXT): Promise<void>;
+    destroyNode(node: Node): Promise<void>;
 }

package/dist/NodeTreeManager/utils.d.ts

@@ -1,8 +1,8 @@
 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) => Promise<void>): Promise<void>;
+export declare function getWrapletsFromNode<N extends Node = Node>(node: N): WrapletSet | null;
+export declare function removeWrapletFromNode<N extends Node>(wraplet: Wraplet, node: N): boolean;
+export declare function addWrapletToNode<N extends Node>(wraplet: Wraplet, node: N): void;
+export declare function actOnNodesRecursively(node: Node, callback: (node: Node) => void): Promise<void>;
 export declare function destroyWrapletsRecursively(node: Node): Promise<void>;

package/dist/Set/DefaultWrapletSet.d.ts

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

package/dist/Set/types/WrapletSet.d.ts

@@ -5,4 +5,4 @@ export { WrapletSetSymbol };
 export interface WrapletSet<W extends Wraplet = Wraplet> extends BaseSet<W>, Set<W> {
     [WrapletSetSymbol]: true;
 }
-export declare function isWrapletSet<W extends Wraplet>(object: unknown): object is WrapletSet<W>;
+export declare function isWrapletSet(object: unknown): object is WrapletSet;

package/dist/Wraplet/AbstractDependentWraplet.d.ts

@@ -0,0 +1,35 @@
+import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
+import { WrapletDependencies } from "./types/WrapletDependencies";
+import { Wraplet } from "./types/Wraplet";
+import { DependencyManager } from "../DependencyManager/types/DependencyManager";
+import { AbstractWraplet } from "./AbstractWraplet";
+import { WrapletApi } from "./types/WrapletApi";
+export declare abstract class AbstractDependentWraplet<N extends Node = Node, M extends WrapletDependencyMap = {}> extends AbstractWraplet<N> implements Wraplet {
+    protected dm: DependencyManager<N, M>;
+    constructor(dm: DependencyManager<N, M>);
+    /**
+     * Override createWrapletApi to provide DependencyManager-aware lifecycle callbacks
+     * instead of the base class's version — this avoids creating two WrapletApi
+     * instances.
+     */
+    protected createWrapletApi(): WrapletApi;
+    protected onDestroy(): Promise<void>;
+    protected onInitialize(): Promise<void>;
+    /**
+     * Dependencies.
+     */
+    protected get d(): WrapletDependencies<M>;
+    protected static createDependencyManager<N extends Node, M extends WrapletDependencyMap>(node: N, map: M): DependencyManager<N, M>;
+    protected static createWraplets(): InstanceType<abstract new (...args: any) => any>;
+    protected static createAndInitializeWraplets(): Promise<InstanceType<abstract new (...args: any) => any>>;
+    /**
+     * Instantiates wraplets on a given ParentNode.
+     */
+    protected static createDependentWraplets<T extends abstract new (ddm: any, ...args: any[]) => AbstractDependentWraplet<any, any>>(this: T, node: ParentNode, attribute: string, map: WrapletDependencyMap, additional_args?: unknown[]): InstanceType<T>[];
+    /**
+     * Instantiates and initializes wraplets on a given ParentNode.
+     */
+    protected static createAndInitializeDependentWraplets<T extends {
+        new (ddm: any, ...args: any[]): AbstractDependentWraplet<any, any>;
+    }>(this: T, node: ParentNode, attribute: string, map: WrapletDependencyMap, additional_args?: unknown[]): Promise<InstanceType<T>[]>;
+}

package/dist/Wraplet/AbstractWraplet.d.ts

@@ -0,0 +1,52 @@
+import { Wraplet, WrapletSymbol } from "./types/Wraplet";
+import { Constructable } from "../utils/types/Utils";
+import { NodeManager } from "./NodeManager";
+import { WrapletApi } from "./types/WrapletApi";
+import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryCallbacks";
+export declare abstract class AbstractWraplet<N extends Node = Node> implements Wraplet {
+    protected node: N;
+    [WrapletSymbol]: true;
+    wraplet: WrapletApi;
+    private _nodeManager;
+    constructor(node: N);
+    /**
+     * Creates the WrapletApi for this wraplet. Subclasses (e.g. AbstractDependentWraplet)
+     * can override this to supply their own lifecycle callbacks without causing a
+     * double-creation of WrapletApi.
+     */
+    protected createWrapletApi(): WrapletApi;
+    /**
+     * Builds a WrapletApi with the given callbacks and ensures NodeManager cleanup
+     * is always wired into the destroy path.
+     */
+    protected buildWrapletApi(initializeCallback?: WrapletApiFactoryBasicCallback, destroyCallback?: WrapletApiFactoryBasicCallback): WrapletApi;
+    protected get nodeManager(): NodeManager<N>;
+    /**
+     * Subclasses must return an array of constructors covering all types in union N.
+     * Wrap the result in the `supportedTypeGuard` helper to make sure that the array contains all
+     * and only classes that extend the given type.
+     */
+    protected supportedNodeTypes(): readonly Constructable<N>[] | null;
+    /**
+     * Helper for subclasses to easily satisfy the exhaustive check.
+     */
+    protected supportedNodeTypesGuard<T extends readonly Constructable<N>[]>(types: T & (Exclude<N, InstanceType<T[number]>> extends never ? T : never)): T;
+    /**
+     * This method gets invoked when the wraplet is initialized.
+     */
+    protected onInitialize(): Promise<void>;
+    /**
+     * This method gets invoked when the wraplet is destroyed.
+     */
+    protected onDestroy(): Promise<void>;
+    /**
+     * Instantiates wraplets on a given ParentNode.
+     */
+    protected static createWraplets<T extends abstract new (ddm: any, ...args: any[]) => AbstractWraplet<any>>(this: T, node: ParentNode, attribute: string, additional_args?: unknown[]): InstanceType<T>[];
+    /**
+     * Instantiates and initializes wraplets on a given ParentNode.
+     */
+    protected static createAndInitializeWraplets<T extends {
+        new (ddm: any, ...args: any[]): AbstractWraplet<any>;
+    }>(this: T, node: ParentNode, attribute: string, additional_args?: unknown[]): Promise<InstanceType<T>[]>;
+}

package/dist/Wraplet/NodeManager.d.ts

@@ -0,0 +1,22 @@
+import { SelectorCallback } from "./types/WrapletDependencyDefinition";
+export declare class NodeManager<N extends Node> {
+    private node;
+    private listeners;
+    constructor(node: N);
+    /**
+     * Add a listener to the current node.
+     */
+    addListener(eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    /**
+     * Add a listener to one of the descendants.
+     *
+     * Note: Most of the time it's not recommended to use this
+     * method because it makes a wraplet impure.
+     *
+     * Ideally, wraplet should directly interact only with its
+     * own node. However, you can make a wraplet impure if you
+     * know what you are doing.
+     */
+    addListenerTo(target: SelectorCallback | string, eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean, required?: boolean): void;
+    destroy(): void;
+}

package/dist/Wraplet/createOuterDestroyCallback.d.ts

@@ -0,0 +1,10 @@
+import { Status } from "./types/Status";
+import { Wraplet } from "./types/Wraplet";
+import { DestroyListener } from "../DependencyManager/types/DestroyListener";
+import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryCallbacks";
+export type OuterDestroyCallbackArgs = {
+    wraplet: Wraplet;
+    destroyListeners: DestroyListener[];
+    status: Status;
+};
+export declare function createOuterDestroyCallback(args: OuterDestroyCallbackArgs, destroyLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;

package/dist/Wraplet/createOuterInitializeCallback.d.ts

@@ -0,0 +1,9 @@
+import { Status } from "./types/Status";
+import { Wraplet } from "./types/Wraplet";
+import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryCallbacks";
+export type OuterInitializeCallbackArgs = {
+    wraplet: Wraplet;
+    destroyCallback: () => Promise<void>;
+    status: Status;
+};
+export declare function createOuterInitializeCallback(args: OuterInitializeCallbackArgs, initializeLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;

package/dist/Wraplet/createWrapletApi.d.ts

@@ -1,4 +1,3 @@
-import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
 import { WrapletApiFactoryArgs } from "./types/WrapletApiFactoryArgs";
 import { WrapletApi, WrapletApiDebug } from "./types/WrapletApi";
-export declare const createWrapletApi: <N extends Node, M extends WrapletDependencyMap>(args: WrapletApiFactoryArgs<N, M>) => WrapletApi<N> & WrapletApiDebug<N>;
+export declare const createWrapletApi: (args: WrapletApiFactoryArgs) => WrapletApi & WrapletApiDebug;

package/dist/Wraplet/statusActions.d.ts

@@ -1,9 +1,7 @@
 import { StatusWritable } from "../Wraplet/types/Status";
-import { Core } from "../Core/types/Core";
-import { DestroyListener } from "../Core/types/DestroyListener";
+import { DestroyListener } from "../DependencyManager/types/DestroyListener";
 import { Wraplet } from "../Wraplet/types/Wraplet";
-import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
-export declare function initializationStarted<N extends Node, M extends WrapletDependencyMap>(status: StatusWritable, core: Core<N, M>, wraplet: Wraplet<N>): Promise<boolean>;
+export declare function initializationStarted(status: StatusWritable): boolean;
 export declare function initializationCompleted(status: StatusWritable, destroyMethod: () => Promise<void>): Promise<void>;
-export declare function destructionStarted<N extends Node, W extends Wraplet<N>, M extends WrapletDependencyMap>(status: StatusWritable, core: Core<N, M>, wraplet: W, destroyListeners: DestroyListener<W>[]): Promise<boolean>;
-export declare function destructionCompleted<N extends Node, W extends Wraplet<N>, M extends WrapletDependencyMap>(status: StatusWritable, core: Core<N, M>, wraplet: W): Promise<void>;
+export declare function destructionStarted(status: StatusWritable): boolean;
+export declare function destructionCompleted(status: StatusWritable, wraplet: Wraplet, destroyListeners: DestroyListener[]): Promise<void>;

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

@@ -1,2 +1,3 @@
 import { WrapletDependencyMap } from "./WrapletDependencyMap";
-export type DependencyInstance<M extends WrapletDependencyMap, K extends keyof M = keyof M> = InstanceType<M[K]["Class"]>;
+import { InstantiableReturnType } from "../../utils/types/Utils";
+export type DependencyInstance<M extends WrapletDependencyMap, K extends keyof M = keyof M> = InstantiableReturnType<M[K]["Class"]>;

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

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

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

@@ -1,13 +1,14 @@
-import { DestroyListener } from "../../Core/types/DestroyListener";
+import { DestroyListener } from "../../DependencyManager/types/DestroyListener";
 import { Status } from "./Status";
-import { Wraplet } from "../../Wraplet/types/Wraplet";
-export interface WrapletApi<N extends Node = Node> {
+export declare const WrapletApiSymbol: unique symbol;
+export interface WrapletApi {
+    [WrapletApiSymbol]: true;
     status: Status;
-    accessNode(callback: (node: N) => void): void;
     destroy(): Promise<void>;
     initialize(): Promise<void>;
-    addDestroyListener(callback: DestroyListener<Wraplet<N>>): void;
+    addDestroyListener(callback: DestroyListener): void;
 }
-export interface WrapletApiDebug<N extends Node> {
-    __nodeAccessors: ((node: N) => void)[];
+export declare function isWrapletApi(object: unknown): object is WrapletApi;
+export interface WrapletApiDebug {
+    __destroyListeners: DestroyListener[];
 }

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

@@ -1,12 +1,8 @@
-import { WrapletDependencyMap } from "./WrapletDependencyMap";
-import { Core } from "../../Core/types/Core";
-import { DestroyListener } from "../../Core/types/DestroyListener";
-import { WrapletApiFactoryBasicCallback } from "./WrapletApiFactoryBasicCallback";
 import { Wraplet } from "./Wraplet";
-export type WrapletApiFactoryArgs<N extends Node = Node, M extends WrapletDependencyMap = WrapletDependencyMap> = {
-    core: Core<N, M>;
-    wraplet: Wraplet<N>;
-    destroyListeners?: DestroyListener<Wraplet<N>>[];
-    initializeCallback?: WrapletApiFactoryBasicCallback;
+import { WrapletApiFactoryBasicCallback } from "./WrapletApiFactoryCallbacks";
+export type WrapletApiFactoryArgs<N extends Node = Node> = {
+    node?: N;
+    wraplet: Wraplet;
     destroyCallback?: WrapletApiFactoryBasicCallback;
+    initializeCallback?: WrapletApiFactoryBasicCallback;
 };

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

@@ -1,22 +1,18 @@
 import { Wraplet } from "./Wraplet";
-import { WrapletDependencyMap } from "./WrapletDependencyMap";
-import { CoreInitOptions } from "../../Core/types/CoreInitOptions";
-import { DynamicMap } from "../../Map/types/DynamicMap";
 import { Constructable } from "../../utils/types/Utils";
+import { Injector } from "../../Injector/types/Injector";
 export type SelectorCallback<N extends ParentNode = ParentNode> = (node: N) => Node[];
-export type WrapletDependencyDefinition<M extends WrapletDependencyMap = WrapletDependencyMap> = {
+export type WrapletDependencyDefinition = {
     selector?: string | SelectorCallback;
-    Class: Constructable<Wraplet<any>>;
-    map?: M | DynamicMap;
-    coreOptions?: CoreInitOptions<M>;
+    Class: Constructable<Wraplet>;
+    injector?: Injector;
     required: boolean;
     multiple: boolean;
     args?: unknown[];
     destructible?: boolean;
 };
-export type WrapletDependencyDefinitionWithDefaults<T extends WrapletDependencyDefinition = WrapletDependencyDefinition, M extends WrapletDependencyMap = WrapletDependencyMap> = T & {
+export type WrapletDependencyDefinitionWithDefaults<T extends WrapletDependencyDefinition = WrapletDependencyDefinition> = T & {
     args: unknown[];
     destructible: boolean;
-    map: M | DynamicMap;
-    coreOptions: CoreInitOptions<M>;
+    injector: Injector;
 };

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

@@ -3,6 +3,12 @@ export type WrapletDependencyMap = {
     [id: string]: WrapletDependencyDefinition;
 };
 export type WrapletDependencyMapWithDefaults<M extends WrapletDependencyMap = WrapletDependencyMap> = {
-    [key in keyof M]: WrapletDependencyDefinitionWithDefaults<M[key], M>;
+    [key in keyof M]: WrapletDependencyDefinitionWithDefaults<M[key]>;
 };
+export type SingleDependencyKeys<M extends WrapletDependencyMap> = Extract<keyof {
+    [K in keyof M as M[K]["multiple"] extends false ? K : never]: true;
+}, string>;
+export type MultipleDependencyKeys<M extends WrapletDependencyMap> = Extract<keyof {
+    [K in keyof M as M[K]["multiple"] extends true ? K : never]: true;
+}, string>;
 export declare function isWrapletDependencyMap(object: unknown): object is WrapletDependencyMapWithDefaults;

package/dist/Wraplet/utils.d.ts

@@ -0,0 +1 @@
+export declare const isOverridden: (instance: object, methodName: string, stopAt?: Function) => boolean;