wraplet 0.46.0 → 0.47.0

package/dist/AbstractWraplet.d.ts

@@ -1,14 +1,14 @@
-import { WrapletChildrenMap } from "./Wraplet/types/WrapletChildrenMap";
-import { WrapletChildren } from "./Wraplet/types/WrapletChildren";
+import { WrapletDependencyMap } from "./Wraplet/types/WrapletDependencyMap";
+import { WrapletDependencies } from "./Wraplet/types/WrapletDependencies";
 import { Wraplet, WrapletSymbol } from "./Wraplet/types/Wraplet";
 import { DestroyListener } from "./Core/types/DestroyListener";
-import { ChildInstance } from "./Wraplet/types/ChildInstance";
+import { DependencyInstance } from "./Wraplet/types/DependencyInstance";
 import { Groupable, GroupableSymbol } from "./types/Groupable";
 import { NodeTreeParent, NodeTreeParentSymbol } from "./NodeTreeManager/types/NodeTreeParent";
 import { Core } from "./Core/types/Core";
 import { Constructable } from "./utils/types/Utils";
 import { RichWrapletApi } from "./Wraplet/types/RichWrapletApi";
-export declare abstract class AbstractWraplet<N extends Node = Node, M extends WrapletChildrenMap = {}> implements Wraplet<N>, Groupable, NodeTreeParent {
+export declare abstract class AbstractWraplet<N extends Node = Node, M extends WrapletDependencyMap = {}> implements Wraplet<N>, Groupable, NodeTreeParent {
     protected core: Core<N, M>;
     [WrapletSymbol]: true;
     [GroupableSymbol]: true;
@@ -16,16 +16,16 @@ export declare abstract class AbstractWraplet<N extends Node = Node, M extends W
     protected destroyListeners: DestroyListener<Wraplet<N>>[];
     wraplet: RichWrapletApi<N>;
     constructor(core: Core<N, M>);
-    protected get children(): WrapletChildren<M>;
+    protected get deps(): WrapletDependencies<M>;
     /**
-     * This method will be ivoked if one of the wraplet's children has been destroyed.
+     * This method will be ivoked if one of the wraplet's dependencies has been destroyed.
      */
-    protected onChildDestroy(child: ChildInstance<M, keyof M>, id: keyof M): void;
+    protected onDependencyDestroyed(dependency: DependencyInstance<M, keyof M>, id: keyof M): void;
     protected get node(): N;
     /**
-     * This method will be invoked if one of the wraplet's children has been instantiated.
+     * This method will be invoked if one of the wraplet's dependencies has been instantiated.
      */
-    protected onChildInstantiate(child: ChildInstance<M, keyof M>, id: keyof M): void;
+    protected onDependencyInstantiated(dependency: DependencyInstance<M, keyof M>, id: keyof M): 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
@@ -38,17 +38,17 @@ export declare abstract class AbstractWraplet<N extends Node = Node, M extends W
     protected supportedNodeTypesGuard<T extends readonly Constructable<N>[]>(types: T & (Exclude<N, InstanceType<T[number]>> extends never ? T : never)): T;
     /**
      * This method makes sure that the given instance is an instance of a class belonging to the
-     * given child.
+     * given dependency.
      *
      * @param item
      * @param actualUnknownId
      * @param onlyId
-     *   By hardcoding onlyId you can filter out any other children. It allows you to learn not only
-     *   that the class is correct, but also that the child is correct (in case multiple children can
-     *   use the same class).
+     *   By hardcoding onlyId you can filter out any other dependencies. It allows you to learn not
+     *   only that the class is correct, but also that the dependency is correct (in the case multiple
+     *   dependencies can use the same class).
      * @protected
      */
-    protected isChildInstance<K extends keyof M>(item: ChildInstance<M, keyof M>, actualUnknownId: keyof M, onlyId?: K | null): item is ChildInstance<M, K>;
-    protected static createCore<N extends Node, M extends WrapletChildrenMap>(node: N, map: M): Core<N, M>;
-    protected static createWraplets<N extends Node, T extends AbstractWraplet<N, any> = never>(node: ParentNode, map: WrapletChildrenMap, attribute: string, additional_args?: unknown[]): T[];
+    protected isDependencyInstance<K extends keyof M>(item: DependencyInstance<M, keyof M>, actualUnknownId: keyof M, onlyId?: K | null): item is DependencyInstance<M, K>;
+    protected static createCore<N extends Node, M extends WrapletDependencyMap>(node: N, map: M): Core<N, M>;
+    protected static createWraplets<N extends Node, T extends AbstractWraplet<N, any> = never>(node: ParentNode, map: WrapletDependencyMap, attribute: string, additional_args?: unknown[]): T[];
 }

package/dist/Core/DefaultArgCreator.d.ts

@@ -1,10 +1,10 @@
 import { ArgCreator, ArgCreatorSymbol } from "./types/ArgCreator";
-import { WrapletChildrenMap } from "../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "../Wraplet/types/WrapletDependencyMap";
 import { WrapletCreatorArgs } from "./types/WrapletCreator";
-export declare class DefaultArgCreator<N extends Node, M extends WrapletChildrenMap = WrapletChildrenMap> implements ArgCreator<N, M> {
+export declare class DefaultArgCreator<N extends Node, M extends WrapletDependencyMap = WrapletDependencyMap> 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>;
+    static create<N extends Node, M extends WrapletDependencyMap = WrapletDependencyMap>(creator: ArgCreator<N, M>["createArg"]): DefaultArgCreator<N, M>;
 }

package/dist/Core/DefaultCore.d.ts

@@ -1,25 +1,25 @@
-import { WrapletChildren } from "../Wraplet/types/WrapletChildren";
+import { WrapletDependencies } from "../Wraplet/types/WrapletDependencies";
 import { Wraplet } from "../Wraplet/types/Wraplet";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
-import { InstantiateChildListener } from "./types/InstantiateChildListener";
-import { DestroyChildListener } from "./types/DestroyChildListener";
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
+import { DependencyInstantiatedListener } from "./types/DependencyInstantiatedListener";
+import { DependencyDestroyedListener } from "./types/DestroyDependencyListener";
 import { CoreInitOptions } from "./types/CoreInitOptions";
 import { Core, CoreSymbol } from "./types/Core";
 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> {
+export declare class DefaultCore<N extends Node = Node, M extends WrapletDependencyMap = {}> implements Core<N, M> {
     node: N;
     [CoreSymbol]: true;
     [NodeTreeParentSymbol]: true;
-    private childrenAreInstantiated;
+    private dependenciesAreInstantiated;
     private statusWritable;
     get status(): Status;
     mapWrapper: MapWrapper<M>;
-    private instantiatedChildren;
-    private destroyChildListeners;
-    private instantiateChildListeners;
+    private instantiatedDependencies;
+    private destroyedDependencyListeners;
+    private instantiatedDependencyListeners;
     private listeners;
     private wrapletCreator;
     constructor(node: N, map: M | MapWrapper<M>, initOptions?: Partial<CoreInitOptions<M>>);
@@ -27,38 +27,38 @@ export declare class DefaultCore<N extends Node = Node, M extends WrapletChildre
      * Initialize core.
      *
      * We couldn't put this step in the constructor, because during initialization some wraplet
-     * processing occurs (instantiate child listeners) that needs access to the children manager,
-     * so the children manager has to exist already.
+     * processing occurs (instantiate dependency listeners) that needs access to the Core,
+     * so the Core has to exist already.
      */
-    initializeChildren(): Promise<void>;
-    get map(): WrapletChildrenMapWithDefaults<M>;
-    instantiateChildren(): void;
-    syncChildren(): Promise<void>;
-    getNodeTreeChildren(): Wraplet[];
+    initializeDependencies(): Promise<void>;
+    get map(): WrapletDependencyMapWithDefaults<M>;
+    instantiateDependencies(): void;
+    syncDependencies(): Promise<void>;
+    getChildrenDependencies(): Wraplet[];
     private findExistingWraplet;
-    private instantiateSingleWrapletChild;
+    private instantiateSingleWrapletDependency;
     private instantiateWrapletItem;
-    private instantiateMultipleWrapletsChild;
-    addDestroyChildListener(callback: DestroyChildListener<M, keyof M>): void;
-    addInstantiateChildListener(callback: InstantiateChildListener<M, keyof M>): void;
-    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletChildrenMap>): void;
+    private instantiateMultipleDependencies;
+    addDependencyDestroyedListener(callback: DependencyDestroyedListener<M, keyof M>): void;
+    addDependencyInstantiatedListener(callback: DependencyInstantiatedListener<M, keyof M>): void;
+    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletDependencyMap>): void;
     private prepareIndividualWraplet;
     /**
-     * This method removes from nodes references to this wraplet and its children recursively.
+     * This method removes from nodes references to this wraplet and its dependencies recursively.
      */
     destroy(): Promise<void>;
-    private findChildren;
+    private findChildrenElements;
     addEventListener(node: Node, eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
-    get children(): WrapletChildren<M>;
-    private removeChild;
+    get dependencies(): WrapletDependencies<M>;
+    private removeDependency;
     private validateMapItem;
     private validateMapItemForNonParent;
     private validateElements;
     /**
-     * Set up a proxy to check if children have not been destroyed before fetching them.
+     * Set up a proxy to check if dependencies have not been destroyed before fetching them.
      */
-    private wrapChildren;
+    private wrapDependencies;
     private defaultInitOptions;
     private processInitOptions;
-    private destroyChildren;
+    private destroyDependencies;
 }

package/dist/Core/defaultWrapletCreator.d.ts

@@ -1,6 +1,6 @@
 import { WrapletCreatorArgs } from "./types/WrapletCreator";
-import { WrapletChildrenMap } from "../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "../Wraplet/types/WrapletDependencyMap";
 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;
+export declare function defaultWrapletCreator(args: WrapletCreatorArgs<Node, WrapletDependencyMap>, currentCoreClass: Constructable<Core>): Wraplet;

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

@@ -1,9 +1,9 @@
 import { WrapletCreatorArgs } from "./WrapletCreator";
-import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
 declare const ArgCreatorSymbol: unique symbol;
 export { ArgCreatorSymbol };
-export interface ArgCreator<N extends Node, M extends WrapletChildrenMap = {}> {
+export interface ArgCreator<N extends Node, M extends WrapletDependencyMap = {}> {
     [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>;
+export declare function isArgCreator<N extends Node, M extends WrapletDependencyMap = {}>(object: unknown): object is ArgCreator<N, M>;

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

@@ -1,17 +1,17 @@
-import { WrapletChildren } from "../../Wraplet/types/WrapletChildren";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../../Wraplet/types/WrapletChildrenMap";
-import { DestroyChildListener } from "./DestroyChildListener";
-import { InstantiateChildListener } from "./InstantiateChildListener";
+import { WrapletDependencies } from "../../Wraplet/types/WrapletDependencies";
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../../Wraplet/types/WrapletDependencyMap";
+import { DependencyDestroyedListener } from "./DestroyDependencyListener";
+import { DependencyInstantiatedListener } from "./DependencyInstantiatedListener";
 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
+ * Dependency manager interface that defines the public API for managing wraplet relationships
  * and lifecycles.
  */
-export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}> {
+export interface Core<N extends Node = Node, M extends WrapletDependencyMap = {}> {
     [CoreSymbol]: true;
     /**
      * Core status.
@@ -20,47 +20,47 @@ export interface Core<N extends Node = Node, M extends WrapletChildrenMap = {}>
     /**
      * The children map that defines the relationships between nodes.
      */
-    map: WrapletChildrenMapWithDefaults<M>;
+    map: WrapletDependencyMapWithDefaults<M>;
     /**
      * Node attached to the current wraplet.
      */
     node: N;
     /**
-     * Instantiate children based on the map and the current node.
+     * Instantiate dependencies based on the map and the current node.
      */
-    instantiateChildren(): void;
+    instantiateDependencies(): void;
     /**
-     * Initialize children.
+     * Initialize dependencies.
      */
-    initializeChildren(): Promise<void>;
+    initializeDependencies(): Promise<void>;
     /**
-     * Synchronize the children instances with the DOM.
+     * Synchronize the dependencies instances with the DOM.
      */
-    syncChildren(): Promise<void>;
+    syncDependencies(): Promise<void>;
     /**
-     * Add a listener that will be called when a child is destroyed.
+     * Add a listener that will be called when a dependency is destroyed.
      */
-    addDestroyChildListener(callback: DestroyChildListener<M, keyof M>): void;
+    addDependencyDestroyedListener(callback: DependencyDestroyedListener<M, keyof M>): void;
     /**
-     * Add a listener that will be called when a child is instantiated.
+     * Add a listener that will be called when a dependency is instantiated.
      */
-    addInstantiateChildListener(callback: InstantiateChildListener<M, keyof M>): void;
+    addDependencyInstantiatedListener(callback: DependencyInstantiatedListener<M, keyof M>): void;
     /**
-     * Destroy all children.
+     * Destroy all dependencies.
      */
     destroy(): Promise<void>;
     /**
      * Add an event listener to a node and track it for cleanup.
      */
     addEventListener(node: Node, eventName: string, callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
-    getNodeTreeChildren(): Wraplet[];
+    getChildrenDependencies(): Wraplet[];
     /**
      * Allows for overriding the default wraplet creation process.
      */
-    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletChildrenMap>): void;
+    setWrapletCreator(wrapletCreator: WrapletCreator<Node, WrapletDependencyMap>): void;
     /**
-     * Get the instantiated children.
+     * Get the available dependencies.
      */
-    readonly children: WrapletChildren<M>;
+    readonly dependencies: WrapletDependencies<M>;
 }
 export declare function isCore(object: unknown): object is Core;

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

@@ -1,7 +1,7 @@
-import { InstantiateChildListener } from "./InstantiateChildListener";
-import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
-import { DestroyChildListener } from "./DestroyChildListener";
-export type CoreInitOptions<M extends WrapletChildrenMap = WrapletChildrenMap> = {
-    instantiateChildListeners: InstantiateChildListener<M, keyof M>[];
-    destroyChildListeners: DestroyChildListener<M, keyof M>[];
+import { DependencyInstantiatedListener } from "./DependencyInstantiatedListener";
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
+import { DependencyDestroyedListener } from "./DestroyDependencyListener";
+export type CoreInitOptions<M extends WrapletDependencyMap = WrapletDependencyMap> = {
+    dependencyInstantiatedListeners?: DependencyInstantiatedListener<M, keyof M>[];
+    dependencyDestroyedListeners?: DependencyDestroyedListener<M, keyof M>[];
 };

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

@@ -0,0 +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;

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

@@ -0,0 +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;

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

@@ -1,11 +1,11 @@
 import { Wraplet } from "../../Wraplet/types/Wraplet";
 import { MapWrapper } from "../../Map/MapWrapper";
-import { WrapletChildrenMap } from "../../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "../../Wraplet/types/WrapletDependencyMap";
 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> = {
+export type WrapletCreator<N extends Node, M extends WrapletDependencyMap> = (args: WrapletCreatorArgs<N, M>, currentCoreClass: Constructable<Core>) => Wraplet<N>;
+export type WrapletCreatorArgs<N extends Node, M extends WrapletDependencyMap> = {
     id: keyof M;
     Class: Constructable<Wraplet<N>>;
     element: N;

package/dist/Map/MapRepeat.d.ts

@@ -1,10 +1,10 @@
 import { MapWrapper } from "./MapWrapper";
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
 import { DynamicMap, DynamicMapSymbol } from "./types/DynamicMap";
 export declare class MapRepeat implements DynamicMap {
     private readonly levels;
     [DynamicMapSymbol]: true;
     constructor(levels?: number);
-    create<M extends WrapletChildrenMap>(parentMapClone: MapWrapper<M>): WrapletChildrenMapWithDefaults<M>;
+    create<M extends WrapletDependencyMap>(parentMapClone: MapWrapper<M>): WrapletDependencyMapWithDefaults<M>;
     static create(levels?: number): MapRepeat;
 }

package/dist/Map/MapWrapper.d.ts

@@ -1,10 +1,10 @@
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../Wraplet/types/WrapletChildrenMap";
-type RecursiveMapKeys<T extends WrapletChildrenMap> = {
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../Wraplet/types/WrapletDependencyMap";
+type RecursiveMapKeys<T extends WrapletDependencyMap> = {
     [K in keyof T]: T[K] extends {
-        map: infer M extends WrapletChildrenMap;
+        map: infer M extends WrapletDependencyMap;
     } ? K | RecursiveMapKeys<M> : K;
 }[keyof T];
-export declare class MapWrapper<M extends WrapletChildrenMap> {
+export declare class MapWrapper<M extends WrapletDependencyMap> {
     private readonly fullMap;
     private startingPath;
     private currentMap;
@@ -17,8 +17,8 @@ export declare class MapWrapper<M extends WrapletChildrenMap> {
      * @param resolveImmediately
      */
     constructor(fullMap: M, path?: (RecursiveMapKeys<M> | string)[], resolveImmediately?: boolean);
-    getStartingMap(): WrapletChildrenMapWithDefaults<M>;
-    getCurrentMap(): WrapletChildrenMapWithDefaults<M>;
+    getStartingMap(): WrapletDependencyMapWithDefaults<M>;
+    getCurrentMap(): WrapletDependencyMapWithDefaults<M>;
     /**
      * @param path
      * @private
@@ -27,7 +27,7 @@ export declare class MapWrapper<M extends WrapletChildrenMap> {
     up(pathPart: string, resolve?: boolean): void;
     private pathExists;
     down(resolve?: boolean): void;
-    clone(path: string[], resolveImmediately?: boolean): MapWrapper<WrapletChildrenMapWithDefaults<M>>;
-    resolve(path: string[]): WrapletChildrenMapWithDefaults<M>;
+    clone(path: string[], resolveImmediately?: boolean): MapWrapper<WrapletDependencyMapWithDefaults<M>>;
+    resolve(path: string[]): WrapletDependencyMapWithDefaults<M>;
 }
 export {};

package/dist/Map/types/DynamicMap.d.ts

@@ -1,9 +1,9 @@
-import { WrapletChildrenMap, WrapletChildrenMapWithDefaults } from "../../Wraplet/types/WrapletChildrenMap";
+import { WrapletDependencyMap, WrapletDependencyMapWithDefaults } from "../../Wraplet/types/WrapletDependencyMap";
 import { MapWrapper } from "../MapWrapper";
 declare const DynamicMapSymbol: unique symbol;
 export { DynamicMapSymbol };
 export interface DynamicMap {
     [DynamicMapSymbol]: true;
-    create<M extends WrapletChildrenMap>(parentMapClone: MapWrapper<M>): WrapletChildrenMapWithDefaults<M>;
+    create<M extends WrapletDependencyMap>(parentMapClone: MapWrapper<M>): WrapletDependencyMapWithDefaults<M>;
 }
 export declare function isDynamicMap(object: unknown): object is DynamicMap;

package/dist/Map/utils.d.ts

@@ -1,4 +1,4 @@
-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>;
+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 fillMapWithDefaults<M extends WrapletDependencyMap>(map: M): WrapletDependencyMapWithDefaults<M>;

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

@@ -4,7 +4,7 @@ export { NodeTreeParentSymbol };
 export interface NodeTreeParent {
     [NodeTreeParentSymbol]: true;
     wraplet: {
-        getNodeTreeChildren(): Wraplet[];
+        getChildrenDependencies(): Wraplet[];
     };
 }
 export declare function isNodeTreeParent(object: object): object is NodeTreeParent;

package/dist/Wraplet/createDefaultDestroyCallback.d.ts

@@ -3,11 +3,11 @@ import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryBasicCa
 import { Core } from "../Core/types/Core";
 import { Wraplet } from "./types/Wraplet";
 import { DestroyListener } from "../Core/types/DestroyListener";
-import { WrapletChildrenMap } from "./types/WrapletChildrenMap";
-export type DefaultDestroyCallbackArgs<N extends Node, M extends WrapletChildrenMap> = {
+import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
+export type DefaultDestroyCallbackArgs<N extends Node, M extends WrapletDependencyMap> = {
     core: Core<N, M>;
     wraplet: Wraplet<N>;
     destroyListeners: DestroyListener<Wraplet<N>>[];
     status?: Status;
 };
-export declare function createDefaultDestroyCallback<N extends Node, M extends WrapletChildrenMap>(args: DefaultDestroyCallbackArgs<N, M>, customDestroyLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;
+export declare function createDefaultDestroyCallback<N extends Node, M extends WrapletDependencyMap>(args: DefaultDestroyCallbackArgs<N, M>, customDestroyLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;

package/dist/Wraplet/createDefaultInitializeCallback.d.ts

@@ -1,13 +1,15 @@
-import { WrapletChildrenMap } from "./types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
 import { Status } from "./types/Status";
 import { Core } from "../Core/types/Core";
 import { WrapletApiFactoryBasicCallback } from "./types/WrapletApiFactoryBasicCallback";
-export type DefaultInitializeCallbackArgs<N extends Node, M extends WrapletChildrenMap> = {
+import { Wraplet } from "./types/Wraplet";
+export type DefaultInitializeCallbackArgs<N extends Node, M extends WrapletDependencyMap> = {
     core: Core<N, M>;
+    wraplet: Wraplet<N>;
     destroyCallback: () => Promise<void>;
     status?: Status;
 };
 /**
  * Note: If status is not provided, this function will attempt to get it from "this".
  */
-export declare function createDefaultInitializeCallback<N extends Node, M extends WrapletChildrenMap>(args: DefaultInitializeCallbackArgs<N, M>, customInitializeLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;
+export declare function createDefaultInitializeCallback<N extends Node, M extends WrapletDependencyMap>(args: DefaultInitializeCallbackArgs<N, M>, customInitializeLogic?: WrapletApiFactoryBasicCallback): () => Promise<void>;

package/dist/Wraplet/createRichWrapletApi.d.ts

@@ -1,5 +1,5 @@
-import { WrapletChildrenMap } from "./types/WrapletChildrenMap";
+import { WrapletDependencyMap } from "./types/WrapletDependencyMap";
 import { WrapletApiDebug } from "./types/WrapletApi";
 import { RichWrapletApi } from "./types/RichWrapletApi";
 import { RichWrapletApiFactoryArgs } from "./types/RichWrapletApiFactoryArgs";
-export declare const createRichWrapletApi: <N extends Node, M extends WrapletChildrenMap>(args: RichWrapletApiFactoryArgs<N, M>) => RichWrapletApi<N> & WrapletApiDebug<N>;
+export declare const createRichWrapletApi: <N extends Node, M extends WrapletDependencyMap>(args: RichWrapletApiFactoryArgs<N, M>) => RichWrapletApi<N> & WrapletApiDebug<N>;

package/dist/Wraplet/createWrapletApi.d.ts

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

package/dist/Wraplet/statusActions.d.ts

@@ -2,8 +2,8 @@ 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 { WrapletChildrenMap } from "../Wraplet/types/WrapletChildrenMap";
-export declare function initializationStarted<N extends Node, M extends WrapletChildrenMap>(status: StatusWritable, core: Core<N, M>): Promise<boolean>;
+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 initializationCompleted(status: StatusWritable, destroyMethod: () => Promise<void>): Promise<void>;
-export declare function destructionStarted<N extends Node, W extends Wraplet<N>, M extends WrapletChildrenMap>(status: StatusWritable, core: Core<N, M>, wraplet: W, destroyListeners: DestroyListener<W>[]): Promise<boolean>;
-export declare function destructionCompleted(status: StatusWritable): 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>;

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

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

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

@@ -1,6 +1,6 @@
-import { WrapletChildrenMap } from "./WrapletChildrenMap";
+import { WrapletDependencyMap } from "./WrapletDependencyMap";
 import { GroupExtractor } from "../../types/Groupable";
 import { WrapletApiFactoryArgs } from "./WrapletApiFactoryArgs";
-export type RichWrapletApiFactoryArgs<N extends Node = Node, M extends WrapletChildrenMap = WrapletChildrenMap> = {
+export type RichWrapletApiFactoryArgs<N extends Node = Node, M extends WrapletDependencyMap = WrapletDependencyMap> = {
     groupExtractor?: GroupExtractor;
 } & WrapletApiFactoryArgs<N, M>;

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

@@ -1,9 +1,9 @@
-import { WrapletChildrenMap } from "./WrapletChildrenMap";
+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 WrapletChildrenMap = WrapletChildrenMap> = {
+export type WrapletApiFactoryArgs<N extends Node = Node, M extends WrapletDependencyMap = WrapletDependencyMap> = {
     core: Core<N, M>;
     wraplet: Wraplet<N>;
     destroyListeners?: DestroyListener<Wraplet<N>>[];

package/dist/Wraplet/types/{WrapletChildren.d.ts → WrapletDependencies.d.ts}

@@ -1,7 +1,7 @@
-import { WrapletChildrenMap } from "./WrapletChildrenMap";
+import { WrapletDependencyMap } from "./WrapletDependencyMap";
 import { InstantiableReturnType } from "../../utils/types/Utils";
 import { WrapletSet } from "../../Set/types/WrapletSet";
-export type OptionalSingleInstantiableReturnType<T extends WrapletChildrenMap, K extends keyof T> = T[K]["required"] extends true ? InstantiableReturnType<T[K]["Class"]> : InstantiableReturnType<T[K]["Class"]> | null;
-export type WrapletChildren<T extends WrapletChildrenMap> = {
+export type OptionalSingleInstantiableReturnType<T extends WrapletDependencyMap, K extends keyof T> = T[K]["required"] extends true ? InstantiableReturnType<T[K]["Class"]> : InstantiableReturnType<T[K]["Class"]> | null;
+export type WrapletDependencies<T extends WrapletDependencyMap> = {
     [id in keyof T]: T[id]["multiple"] extends true ? WrapletSet<InstantiableReturnType<T[id]["Class"]>> : OptionalSingleInstantiableReturnType<T, id>;
 };

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

@@ -1,10 +1,10 @@
 import { Wraplet } from "./Wraplet";
-import { WrapletChildrenMap } from "./WrapletChildrenMap";
+import { WrapletDependencyMap } from "./WrapletDependencyMap";
 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> = {
+export type WrapletDependencyDefinition<M extends WrapletDependencyMap = WrapletDependencyMap> = {
     selector?: string | SelectorCallback;
     Class: Constructable<Wraplet<any>>;
     map?: M | DynamicMap;
@@ -14,7 +14,7 @@ export type WrapletChildDefinition<M extends WrapletChildrenMap = WrapletChildre
     args?: unknown[];
     destructible?: boolean;
 };
-export type WrapletChildDefinitionWithDefaults<T extends WrapletChildDefinition = WrapletChildDefinition, M extends WrapletChildrenMap = WrapletChildrenMap> = T & {
+export type WrapletDependencyDefinitionWithDefaults<T extends WrapletDependencyDefinition = WrapletDependencyDefinition, M extends WrapletDependencyMap = WrapletDependencyMap> = T & {
     args: unknown[];
     destructible: boolean;
     map: M | DynamicMap;

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

@@ -0,0 +1,8 @@
+import { WrapletDependencyDefinition, WrapletDependencyDefinitionWithDefaults } from "./WrapletDependencyDefinition";
+export type WrapletDependencyMap = {
+    [id: string]: WrapletDependencyDefinition;
+};
+export type WrapletDependencyMapWithDefaults<M extends WrapletDependencyMap = WrapletDependencyMap> = {
+    [key in keyof M]: WrapletDependencyDefinitionWithDefaults<M[key], M>;
+};
+export declare function isWrapletDependencyMap(object: unknown): object is WrapletDependencyMapWithDefaults;

package/dist/errors.d.ts

@@ -1,16 +1,16 @@
-export declare class MissingRequiredChildError extends Error {
+export declare class MissingRequiredDependencyError extends Error {
 }
 export declare class MapError extends Error {
 }
-export declare class RequiredChildDestroyedError extends Error {
+export declare class RequiredDependencyDestroyedError extends Error {
 }
-export declare class ChildrenAreNotAvailableError extends Error {
+export declare class DependenciesAreNotAvailableError extends Error {
 }
 export declare class StorageValidationError extends Error {
 }
-export declare class ChildrenTooManyFoundError extends Error {
+export declare class TooManyChildrenFoundError extends Error {
 }
-export declare class ChildrenAreAlreadyDestroyedError extends Error {
+export declare class DependenciesAreAlreadyDestroyedError extends Error {
 }
 export declare class InternalLogicError extends Error {
 }