wraplet 0.48.0 → 1.0.0-beta.10

package/README.md

@@ -0,0 +1,5 @@
+# Intro
+
+[![Tests](https://github.com/wraplet/wraplet/actions/workflows/main.yml/badge.svg)](https://github.com/wraplet/wraplet/actions/workflows/main.yml)
+
+An object-oriented framework giving your JS/TS code structure.

package/dist/DependencyManager/Core.d.ts

@@ -0,0 +1,80 @@
+import { WrapletDependencies } from "../Wraplet/types/WrapletDependencies";
+import { MultipleDependencyKeys, SingleDependencyKeys, WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
+import { DependencyInstance } from "../Wraplet/types/DependencyInstance";
+import { CoreOptions } from "./types/CoreOptions";
+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 Core<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 destroyedDependencyListeners;
+    private instantiatedDependencyListeners;
+    private initializedDependencyListeners;
+    constructor(node: N, map: M | MapTreeBuilder<M>, options?: Partial<CoreOptions<M>>);
+    /**
+     * Initialize core.
+     *
+     * We couldn't put this step in the constructor, because during initialization some wraplet
+     * processing occurs (instantiate dependency listeners) that needs access to the Core,
+     * so the Core has to exist already.
+     */
+    initializeDependencies(): Promise<void>;
+    get map(): WrapletDependencyMapWithDefaults<M>;
+    instantiateDependencies(): void;
+    private findExistingWraplet;
+    private instantiateSingleWrapletDependency;
+    private instantiateWrapletItem;
+    private instantiateMultipleDependencies;
+    addDependencyDestroyedListener(callback: DependencyLifecycleAsyncListener<M, keyof M>): void;
+    addDependencyInstantiatedListener(callback: DependencyLifecycleListener<M, keyof M>): void;
+    addDependencyInitializedListener(callback: DependencyLifecycleAsyncListener<M, keyof M>): 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 core
+     * 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.
+     */
+    destroy(): 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 destroyDependencies;
+    /**
+     * 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?: CoreOptions): Injector<N, M, CoreOptions>;
+}

package/dist/DependencyManager/types/CoreOptions.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 CoreOptions<M extends WrapletDependencyMap = WrapletDependencyMap> = {
+    dependencyInstantiatedListeners?: DependencyLifecycleListener<M, keyof M>[];
+    dependencyInitializedListeners?: DependencyLifecycleAsyncListener<M, keyof M>[];
+    dependencyDestroyedListeners?: DependencyLifecycleAsyncListener<M, keyof M>[];
+    logger?: Logger;
+};

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

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

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

@@ -0,0 +1,59 @@
+import { WrapletDependencies } from "../../Wraplet/types/WrapletDependencies";
+import { MultipleDependencyKeys, SingleDependencyKeys, WrapletDependencyMap, WrapletDependencyMapWithDefaults } 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;
+    /**
+     * The children map that defines the relationships between nodes.
+     */
+    map: WrapletDependencyMapWithDefaults<M>;
+    /**
+     * Instantiate dependencies based on the map and the current node.
+     */
+    instantiateDependencies(): void;
+    /**
+     * Initialize dependencies.
+     */
+    initializeDependencies(): Promise<void>;
+    /**
+     * Add a listener that will be called when a dependency is initialized.
+     */
+    addDependencyInitializedListener(callback: DependencyLifecycleAsyncListener<M, keyof M>): void;
+    /**
+     * Add a listener that will be called when a dependency is destroyed.
+     */
+    addDependencyDestroyedListener(callback: DependencyLifecycleAsyncListener<M, keyof M>): void;
+    /**
+     * Add a listener that will be called when a dependency is instantiated.
+     */
+    addDependencyInstantiatedListener(callback: DependencyLifecycleListener<M, keyof M>): 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>;
+    /**
+     * Destroy all dependencies.
+     */
+    destroy(): Promise<void>;
+}
+export declare function isDependencyManager<N extends Node, M extends WrapletDependencyMap>(object: unknown): object is DependencyManager<N, M>;

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

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

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

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/DefaultNodeTreeManager.d.ts

@@ -1,12 +1,8 @@
 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 {
+export type Initializer<CONTEXT> = (node: Node, context?: CONTEXT) => Promise<void>;
+export declare class DefaultNodeTreeManager<CONTEXT = unknown> implements NodeTreeManager<CONTEXT> {
     private initializers;
-    private items;
-    addWrapletInitializer(callback: Initializer): void;
-    initializeNodeTree(node: Node): Promise<void>;
-    destroyNodeTree(node: Node): Promise<void>;
-    getSet(): WrapletSetReadonly;
+    addNodeInitializer(callback: Initializer<CONTEXT>): void;
+    initializeNode(node: Node, context?: CONTEXT): Promise<void>;
+    destroyNode(node: Node): Promise<void>;
 }

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

@@ -0,0 +1,2 @@
+import { Wraplet } from "../../Wraplet/types/Wraplet";
+export type InitializeListener<CONTEXT> = (node: Node, wraplets: Wraplet[], 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;
+export interface NodeTreeManager<CONTEXT = unknown> {
+    addNodeInitializer(callback: Initializer<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 getWrapletsFromNode<N extends Node = Node, W extends Wraplet<N> = Wraplet<N>>(node: N): WrapletSet<W> | null;
 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 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

@@ -1,8 +1,8 @@
-import { Wraplet } from "../../Wraplet/types/Wraplet";
+import { Dependencies } from "../../Wraplet/types/Wraplet";
 import { BaseSet } from "./BaseSet";
 declare const WrapletSetSymbol: unique symbol;
 export { WrapletSetSymbol };
-export interface WrapletSet<W extends Wraplet = Wraplet> extends BaseSet<W>, Set<W> {
+export interface WrapletSet<W extends Dependencies = Dependencies> extends BaseSet<W>, Set<W> {
     [WrapletSetSymbol]: true;
 }
-export declare function isWrapletSet<W extends Wraplet>(object: unknown): object is WrapletSet<W>;
+export declare function isWrapletSet<W extends Dependencies>(object: unknown): object is WrapletSet<W>;

package/dist/Wraplet/AbstractDependentWraplet.d.ts

@@ -0,0 +1,53 @@
+import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
+import { WrapletDependencies } from "./types/WrapletDependencies";
+import { Wraplet } from "./types/Wraplet";
+import { DependencyInstance } from "./types/DependencyInstance";
+import { DependencyManager } from "../DependencyManager/types/DependencyManager";
+import { Constructable } from "../utils/types/Utils";
+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<N> {
+    protected dm: DependencyManager<N, M>;
+    constructor(dm: DependencyManager<N, M>);
+    /**
+     * Override createWrapletApi to provide Core-aware lifecycle callbacks
+     * instead of the base class's version — this avoids creating two WrapletApi
+     * instances.
+     */
+    protected createWrapletApi(): WrapletApi<N>;
+    protected onDestroy(): Promise<void>;
+    protected onInitialize(): Promise<void>;
+    /**
+     * Dependencies.
+     */
+    protected get d(): WrapletDependencies<M>;
+    /**
+     *  his method will be invoked if one of the wraplet's dependencies has been instantiated.
+     */
+    protected onDependencyInstantiated(dependency: DependencyInstance<M, keyof M>, id: keyof M): void;
+    /**
+     *  his method will be invoked if one of the wraplet's dependencies has been initialized.
+     */
+    protected onDependencyInitialized(dependency: DependencyInstance<M, keyof M>, id: keyof M): Promise<void>;
+    /**
+     * This method will be ivoked if one of the wraplet's dependencies has been destroyed.
+     */
+    protected onDependencyDestroyed(dependency: DependencyInstance<M, keyof M>, id: keyof M): Promise<void>;
+    /**
+     * Subclasses must return an array of constructors covering all types in union N.
+     * Wrap the result in the `supportedTypeCheck` helper to make sure that the array contains all
+     * and only classes that extend the given type.
+     */
+    protected supportedNodeTypes(): readonly Constructable<N>[] | null;
+    protected static createCore<N extends Node, M extends WrapletDependencyMap>(node: N, map: M): DependencyManager<N, M>;
+    /**
+     * Instantiates wraplets on a given ParentNode.
+     */
+    protected static createWraplets<T extends abstract new (core: any, ...args: any[]) => AbstractDependentWraplet<any, any>>(this: T, node: ParentNode, map: WrapletDependencyMap, attribute: string, additional_args?: unknown[]): InstanceType<T>[];
+    /**
+     * Instantiates and initializes wraplets on a given ParentNode.
+     */
+    protected static createAndInitializeWraplets<T extends {
+        new (core: any, ...args: any[]): AbstractDependentWraplet<any, any>;
+    }>(this: T, node: ParentNode, map: WrapletDependencyMap, attribute: string, additional_args?: unknown[]): Promise<InstanceType<T>[]>;
+}

package/dist/Wraplet/AbstractWraplet.d.ts

@@ -0,0 +1,42 @@
+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<N> {
+    protected node: N;
+    [WrapletSymbol]: true;
+    wraplet: WrapletApi<N>;
+    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<N>;
+    /**
+     * 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<N>;
+    protected get nodeManager(): NodeManager<N>;
+    /**
+     * Subclasses must return an array of constructors covering all types in union N.
+     * Wrap the result in the `supportedTypeCheck` 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>;
+}

package/dist/Wraplet/NodeManager.d.ts

@@ -0,0 +1,7 @@
+export declare class NodeManager<N extends Node> {
+    private node;
+    private listeners;
+    constructor(node: N);
+    addListener(eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    destroy(): void;
+}

package/dist/Wraplet/createDependencyApi.d.ts

@@ -0,0 +1,3 @@
+import { DependencyApiFactoryArgs } from "./types/DependencyApiFactoryArgs";
+import { DependencyApi, DependencyApiDebug } from "./types/DependencyApi";
+export declare const createDependencyApi: (args: DependencyApiFactoryArgs) => DependencyApi & DependencyApiDebug;

package/dist/Wraplet/createOuterDestroyCallback.d.ts

@@ -0,0 +1,10 @@
+import { Status } from "./types/Status";
+import { Dependencies } from "./types/Wraplet";
+import { DestroyListener } from "../DependencyManager/types/DestroyListener";
+import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryCallbacks";
+export type OuterDestroyCallbackArgs = {
+    wraplet: Dependencies;
+    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 { Dependencies } from "./types/Wraplet";
+import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryCallbacks";
+export type OuterInitializeCallbackArgs = {
+    wraplet: Dependencies;
+    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: <N extends Node>(args: WrapletApiFactoryArgs<N>) => WrapletApi<N> & WrapletApiDebug<N>;

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 { 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>;
+import { DestroyListener } from "../DependencyManager/types/DestroyListener";
+import { Dependencies } from "../Wraplet/types/Wraplet";
+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: Dependencies, destroyListeners: DestroyListener[]): Promise<void>;

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

@@ -0,0 +1,16 @@
+import { DestroyListener } from "../../DependencyManager/types/DestroyListener";
+import { Status } from "./Status";
+export declare const DependencyApiSymbol: unique symbol;
+export interface BaseWrapletApi {
+    status: Status;
+    destroy(): Promise<void>;
+    initialize(): Promise<void>;
+    addDestroyListener(callback: DestroyListener): void;
+}
+export interface DependencyApi extends BaseWrapletApi {
+    [DependencyApiSymbol]: true;
+}
+export declare function isDependencyApi(object: unknown): object is DependencyApi;
+export interface DependencyApiDebug {
+    __destroyListeners: DestroyListener[];
+}

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

@@ -0,0 +1,7 @@
+import { WrapletApiFactoryBasicCallback } from "./WrapletApiFactoryCallbacks";
+import { Dependencies } from "./Wraplet";
+export type DependencyApiFactoryArgs = {
+    wraplet: Dependencies;
+    destroyCallback?: WrapletApiFactoryBasicCallback;
+    initializeCallback?: WrapletApiFactoryBasicCallback;
+};

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,15 @@
+import { DependencyApi } from "./DependencyApi";
 import { WrapletApi } from "./WrapletApi";
-declare const WrapletSymbol: unique symbol;
-export { WrapletSymbol };
+export declare const DependencySymbol: unique symbol;
+export interface Dependency {
+    [DependencySymbol]: true;
+    wraplet: DependencyApi;
+}
+export declare function isDependency(object: unknown): object is Dependency;
+export declare const WrapletSymbol: unique symbol;
 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>;
+export type Dependencies = Wraplet | Dependency;

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

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

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

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

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 { Dependency, Wraplet } from "./Wraplet";
 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<any> | Dependency>;
+    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;