@limble/limble-tree 2.0.0 → 4.0.0

package/esm2022/lib/core/tree-root/tree-root.mjs

@@ -0,0 +1,193 @@
+import { TreeBranch } from "../tree-branch";
+import { TreeNodeBase } from "../tree-node-base";
+import { config } from "../configuration";
+import { RootController } from "../tree-root/root-controller";
+import { dropzoneRenderer } from "../../extras/drag-and-drop";
+import { TreeError } from "../../errors";
+import { DestructionEvent } from "../../events";
+/**
+ * Represents the base of the tree. It renders a very simple container for child
+ * branches. It has methods for creating and accessing those branches. It emits
+ * events when things happen in the tree.
+ */
+export class TreeRoot {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+        this.treeNodeBase = new TreeNodeBase();
+        this.rootController = new RootController(this, viewContainerRef);
+        this.detectChanges();
+    }
+    /** @returns All child branches as an array of TreeBranch instances */
+    branches() {
+        return this.treeNodeBase.branches();
+    }
+    /**
+     * Recursively destroys all branches of the tree, as well as itself.
+     *
+     * @remarks
+     * This releases all resources held or consumed by the tree.
+     *
+     * It is important to call this method when a tree is discarded, otherwise
+     * the tree will remain in memory and continue to consume resources.
+     */
+    destroy() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot destroy a destroyed tree root");
+        }
+        dropzoneRenderer.clearTreeFromRegistry(this);
+        this.treeNodeBase.destroy();
+        this.rootController.destroy();
+        this.viewContainerRef.clear();
+        config.delete(this);
+        this.dispatch(new DestructionEvent(this));
+    }
+    /** Run Angular change detection on the root of the tree */
+    detectChanges() {
+        this.rootController.detectChanges();
+    }
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
+    dispatch(event) {
+        this.treeNodeBase.dispatch(event);
+    }
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in the root or any of its descendant branches.
+     */
+    events() {
+        return this.treeNodeBase.events();
+    }
+    /**
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
+    getBranch(index) {
+        return this.treeNodeBase.getBranch(index);
+    }
+    /** @returns The ViewContainerRef in which child branches are rendered */
+    getBranchesContainer() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get branches container from a destroyed tree root");
+        }
+        return this.rootController.getBranchesContainer();
+    }
+    /**
+     * Retrieves the RootComponent.
+     *
+     * @remarks
+     * The RootComponent holds the BranchesContainer, as well as a single Dropzone
+     * for drag-and-drop operations.
+     *
+     * @returns The instance of RootComponent that is rendered by this class.
+     */
+    getComponentInstance() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component instance from a destroyed tree root");
+        }
+        return this.rootController.getComponentInstance();
+    }
+    /** @returns The Host View in which the RootComponent is rendered */
+    getHostView() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component host view from a destroyed tree root");
+        }
+        return this.rootController.getHostView();
+    }
+    /** @returns The RootComponent as a native HTML Element */
+    getNativeElement() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get native element from a destroyed tree root");
+        }
+        return this.rootController.getNativeElement();
+    }
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
+    grow(component, options) {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot grow a branch on a destroyed tree root");
+        }
+        try {
+            return new TreeBranch(this, { component, ...options });
+        }
+        catch (error) {
+            throw this.handleUserlandError(error);
+        }
+    }
+    /** @returns `true` if the tree is destroyed, `false` otherwise */
+    isDestroyed() {
+        return this.treeNodeBase.isDestroyed();
+    }
+    /**
+     * Provides a model describing the shape of the tree.
+     *
+     * @returns A multi-dimensional Map which describes the shape of the tree.
+     *
+     * @example
+     * For example, an empty tree will return an empty Map. A tree with a single
+     * branch will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Root-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
+    plot() {
+        return this.treeNodeBase.plot();
+    }
+    /** @returns Itself */
+    root() {
+        return this;
+    }
+    /**
+     * Traverses the tree in depth-first pre-order, executing the provided
+     * callback function on each node. Traversal includes the Root.
+     *
+     * @param callback - A function to execute on each node.
+     */
+    traverse(callback) {
+        callback(this);
+        this.treeNodeBase.traverse(callback);
+    }
+    handleUserlandError(error) {
+        /* When an error occurs in a userland component during a tree operation,
+         * it can cause undefined, bizarre behavior in the tree. To prevent this,
+         * we destroy the tree and throw an error instead. This helps protect
+         * the end-user's data from corruption. */
+        this.destroy();
+        return this.treeNodeBase.handleUserlandError(error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-root.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/core/tree-root/tree-root.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Observable } from \"rxjs\";\nimport { TreeBranch } from \"../tree-branch\";\nimport type { TreePlot } from \"../tree-plot.interface\";\nimport type { TreeNode } from \"../tree-node.interface\";\nimport { TreeNodeBase } from \"../tree-node-base\";\nimport type { BranchOptions } from \"../branch-options.interface\";\nimport { config } from \"../configuration\";\nimport { RootController } from \"../tree-root/root-controller\";\nimport type { Type, ViewContainerRef, ViewRef } from \"@angular/core\";\nimport { RootComponent } from \"../../components\";\nimport { dropzoneRenderer } from \"../../extras/drag-and-drop\";\nimport { TreeError } from \"../../errors\";\nimport { DestructionEvent, TreeEvent } from \"../../events\";\n\n/**\n * Represents the base of the tree. It renders a very simple container for child\n * branches. It has methods for creating and accessing those branches. It emits\n * events when things happen in the tree.\n */\nexport class TreeRoot<UserlandComponent>\n   implements TreeNode<UserlandComponent>\n{\n   private readonly rootController: RootController<UserlandComponent>;\n   private readonly treeNodeBase: TreeNodeBase<UserlandComponent>;\n\n   public constructor(private readonly viewContainerRef: ViewContainerRef) {\n      this.treeNodeBase = new TreeNodeBase();\n      this.rootController = new RootController(this, viewContainerRef);\n      this.detectChanges();\n   }\n\n   /** @returns All child branches as an array of TreeBranch instances */\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return this.treeNodeBase.branches();\n   }\n\n   /**\n    * Recursively destroys all branches of the tree, as well as itself.\n    *\n    * @remarks\n    * This releases all resources held or consumed by the tree.\n    *\n    * It is important to call this method when a tree is discarded, otherwise\n    * the tree will remain in memory and continue to consume resources.\n    */\n   public destroy(): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot destroy a destroyed tree root\");\n      }\n      dropzoneRenderer.clearTreeFromRegistry(this);\n      this.treeNodeBase.destroy();\n      this.rootController.destroy();\n      this.viewContainerRef.clear();\n      config.delete(this);\n      this.dispatch(new DestructionEvent(this));\n   }\n\n   /** Run Angular change detection on the root of the tree */\n   public detectChanges(): void {\n      this.rootController.detectChanges();\n   }\n\n   /**\n    * Emits the specified TreeEvent.\n    *\n    * @remarks\n    * Caution: It is not recommended to manually emit TreeEvents that are already\n    * provided by the library. For example, it is not recommended to emit a\n    * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,\n    * and emitting them manually may cause unexpected behavior. Instead, we\n    * recommend implementing the TreeEvent interface with your own custom events\n    * and dispatching those.\n    *\n    * @param event - The TreeEvent that will be emitted.\n    */\n   public dispatch(event: TreeEvent<UserlandComponent>): void {\n      this.treeNodeBase.dispatch(event);\n   }\n\n   /**\n    * @returns\n    * An observable that emits TreeEvents whenever an event is dispatched\n    * in the root or any of its descendant branches.\n    */\n   public events(): Observable<TreeEvent<UserlandComponent>> {\n      return this.treeNodeBase.events();\n   }\n\n   /**\n    * @returns\n    * The child branch at the specified index, or undefined if there is\n    * no child branch at the specified index.\n    */\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this.treeNodeBase.getBranch(index);\n   }\n\n   /** @returns The ViewContainerRef in which child branches are rendered */\n   public getBranchesContainer(): ViewContainerRef | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get branches container from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getBranchesContainer();\n   }\n\n   /**\n    * Retrieves the RootComponent.\n    *\n    * @remarks\n    * The RootComponent holds the BranchesContainer, as well as a single Dropzone\n    * for drag-and-drop operations.\n    *\n    * @returns The instance of RootComponent that is rendered by this class.\n    */\n   public getComponentInstance(): RootComponent {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component instance from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getComponentInstance();\n   }\n\n   /** @returns The Host View in which the RootComponent is rendered */\n   public getHostView(): ViewRef {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component host view from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getHostView();\n   }\n\n   /** @returns The RootComponent as a native HTML Element */\n   public getNativeElement(): HTMLElement {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get native element from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getNativeElement();\n   }\n\n   /**\n    * Appends a new child branch to this branch. The child branch will render\n    * the specified component according to the (optional) configuration parameter.\n    *\n    * @param component - The component to render in the new child branch.\n    * @param options - Configuration options for the new child branch.\n    *\n    * @returns\n    * The newly-created child branch.\n    */\n   public grow(\n      component: Type<UserlandComponent>,\n      options?: BranchOptions<UserlandComponent>\n   ): TreeBranch<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot grow a branch on a destroyed tree root\");\n      }\n      try {\n         return new TreeBranch(this, { component, ...options });\n      } catch (error) {\n         throw this.handleUserlandError(error);\n      }\n   }\n\n   /** @returns `true` if the tree is destroyed, `false` otherwise */\n   public isDestroyed(): boolean {\n      return this.treeNodeBase.isDestroyed();\n   }\n\n   /**\n    * Provides a model describing the shape of the tree.\n    *\n    * @returns A multi-dimensional Map which describes the shape of the tree.\n    *\n    * @example\n    * For example, an empty tree will return an empty Map. A tree with a single\n    * branch will return a Map with a single entry, where the key is the index\n    * of the branch (zero) and the value is an empty Map. A Tree like this:\n    *\n    * ```\n    *         ---Branch-------Branch\n    *        /\n    * Root-------Branch\n    *        \\\n    *         ---Branch\n    * ```\n    * Will return a Map of matching shape:\n    * ```\n    * Map {\n    *    0: Map { 0: Map {}},\n    *    1: Map {},\n    *    2: Map {}\n    * }\n    * ```\n    */\n   public plot(): TreePlot {\n      return this.treeNodeBase.plot();\n   }\n\n   /** @returns Itself */\n   public root(): this {\n      return this;\n   }\n\n   /**\n    * Traverses the tree in depth-first pre-order, executing the provided\n    * callback function on each node. Traversal includes the Root.\n    *\n    * @param callback - A function to execute on each node.\n    */\n   public traverse(\n      callback: (node: TreeNode<UserlandComponent>) => void\n   ): void {\n      callback(this);\n      this.treeNodeBase.traverse(callback);\n   }\n\n   private handleUserlandError(error: unknown): TreeError {\n      /* When an error occurs in a userland component during a tree operation,\n       * it can cause undefined, bizarre behavior in the tree. To prevent this,\n       * we destroy the tree and throw an error instead. This helps protect\n       * the end-user's data from corruption. */\n      this.destroy();\n      return this.treeNodeBase.handleUserlandError(error);\n   }\n}\n"]}

package/{esm2020 → esm2022}/lib/core/tree-service/tree.service.mjs

@@ -15,11 +15,11 @@ export class TreeService {
         config.setConfig(root, options);
         return root;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeService, providedIn: "root" }); }
 }
-TreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeService, providedIn: "root" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeService, decorators: [{
             type: Injectable,
             args: [{ providedIn: "root" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9jb3JlL3RyZWUtc2VydmljZS90cmVlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBeUIsTUFBTSxlQUFlLENBQUM7QUFDbEUsT0FBTyxFQUFFLE1BQU0sRUFBb0IsTUFBTSxrQkFBa0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sY0FBYyxDQUFDOztBQUV4QyxpREFBaUQ7QUFFakQsTUFBTSxPQUFPLFdBQVc7SUFDckI7Ozs7T0FJRztJQUNJLGVBQWUsQ0FDbkIsU0FBMkIsRUFDM0IsVUFBdUIsRUFBRTtRQUV6QixTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEdBQUcsSUFBSSxRQUFRLENBQVksU0FBUyxDQUFDLENBQUM7UUFDaEQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDaEMsT0FBTyxJQUFJLENBQUM7SUFDZixDQUFDOzt3R0FkUyxXQUFXOzRHQUFYLFdBQVcsY0FERSxNQUFNOzJGQUNuQixXQUFXO2tCQUR2QixVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIHR5cGUgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBjb25maWcsIHR5cGUgVHJlZU9wdGlvbnMgfSBmcm9tIFwiLi4vY29uZmlndXJhdGlvblwiO1xuaW1wb3J0IHsgVHJlZVJvb3QgfSBmcm9tIFwiLi4vdHJlZS1yb290XCI7XG5cbi8qKiBSZXNwb25zaWJsZSBmb3IgdGhlIGNyZWF0aW9uIG9mIG5ldyB0cmVlcy4gKi9cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogXCJyb290XCIgfSlcbmV4cG9ydCBjbGFzcyBUcmVlU2VydmljZSB7XG4gICAvKipcbiAgICAqIENyZWF0ZXMgYSBuZXcsIGVtcHR5IHRyZWUgc3RydWN0dXJlIGluc2lkZSB0aGUgcHJvdmlkZWQgY29udGFpbmVyLlxuICAgICpcbiAgICAqIEByZXR1cm5zIEEgYFRyZWVSb290YCByZXByZXNlbnRpbmcgdGhlIGJhc2Ugb2YgdGhlIG5ldyB0cmVlLlxuICAgICovXG4gICBwdWJsaWMgY3JlYXRlRW1wdHlUcmVlPENvbXBvbmVudD4oXG4gICAgICBjb250YWluZXI6IFZpZXdDb250YWluZXJSZWYsXG4gICAgICBvcHRpb25zOiBUcmVlT3B0aW9ucyA9IHt9XG4gICApOiBUcmVlUm9vdDxDb21wb25lbnQ+IHtcbiAgICAgIGNvbnRhaW5lci5jbGVhcigpO1xuICAgICAgY29uc3Qgcm9vdCA9IG5ldyBUcmVlUm9vdDxDb21wb25lbnQ+KGNvbnRhaW5lcik7XG4gICAgICBjb25maWcuc2V0Q29uZmlnKHJvb3QsIG9wdGlvbnMpO1xuICAgICAgcmV0dXJuIHJvb3Q7XG4gICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9jb3JlL3RyZWUtc2VydmljZS90cmVlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBeUIsTUFBTSxlQUFlLENBQUM7QUFDbEUsT0FBTyxFQUFFLE1BQU0sRUFBb0IsTUFBTSxrQkFBa0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sY0FBYyxDQUFDOztBQUV4QyxpREFBaUQ7QUFFakQsTUFBTSxPQUFPLFdBQVc7SUFDckI7Ozs7T0FJRztJQUNJLGVBQWUsQ0FDbkIsU0FBMkIsRUFDM0IsVUFBdUIsRUFBRTtRQUV6QixTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEdBQUcsSUFBSSxRQUFRLENBQVksU0FBUyxDQUFDLENBQUM7UUFDaEQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDaEMsT0FBTyxJQUFJLENBQUM7SUFDZixDQUFDOzhHQWRTLFdBQVc7a0hBQVgsV0FBVyxjQURFLE1BQU07OzJGQUNuQixXQUFXO2tCQUR2QixVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIHR5cGUgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBjb25maWcsIHR5cGUgVHJlZU9wdGlvbnMgfSBmcm9tIFwiLi4vY29uZmlndXJhdGlvblwiO1xuaW1wb3J0IHsgVHJlZVJvb3QgfSBmcm9tIFwiLi4vdHJlZS1yb290XCI7XG5cbi8qKiBSZXNwb25zaWJsZSBmb3IgdGhlIGNyZWF0aW9uIG9mIG5ldyB0cmVlcy4gKi9cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogXCJyb290XCIgfSlcbmV4cG9ydCBjbGFzcyBUcmVlU2VydmljZSB7XG4gICAvKipcbiAgICAqIENyZWF0ZXMgYSBuZXcsIGVtcHR5IHRyZWUgc3RydWN0dXJlIGluc2lkZSB0aGUgcHJvdmlkZWQgY29udGFpbmVyLlxuICAgICpcbiAgICAqIEByZXR1cm5zIEEgYFRyZWVSb290YCByZXByZXNlbnRpbmcgdGhlIGJhc2Ugb2YgdGhlIG5ldyB0cmVlLlxuICAgICovXG4gICBwdWJsaWMgY3JlYXRlRW1wdHlUcmVlPENvbXBvbmVudD4oXG4gICAgICBjb250YWluZXI6IFZpZXdDb250YWluZXJSZWYsXG4gICAgICBvcHRpb25zOiBUcmVlT3B0aW9ucyA9IHt9XG4gICApOiBUcmVlUm9vdDxDb21wb25lbnQ+IHtcbiAgICAgIGNvbnRhaW5lci5jbGVhcigpO1xuICAgICAgY29uc3Qgcm9vdCA9IG5ldyBUcmVlUm9vdDxDb21wb25lbnQ+KGNvbnRhaW5lcik7XG4gICAgICBjb25maWcuc2V0Q29uZmlnKHJvb3QsIG9wdGlvbnMpO1xuICAgICAgcmV0dXJuIHJvb3Q7XG4gICB9XG59XG4iXX0=

package/{esm2020 → esm2022}/lib/extras/collapse/collapse.module.mjs

@@ -3,14 +3,14 @@ import { TreeCollapseService } from "./collapse.service";
 import * as i0 from "@angular/core";
 /** A module containing the entities which provide collapse functionality */
 export class TreeCollapseModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseModule, providers: [TreeCollapseService] }); }
 }
-TreeCollapseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-TreeCollapseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseModule });
-TreeCollapseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseModule, providers: [TreeCollapseService] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [TreeCollapseService]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGFwc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9leHRyYXMvY29sbGFwc2UvY29sbGFwc2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRXpELDRFQUE0RTtBQUk1RSxNQUFNLE9BQU8sa0JBQWtCOzsrR0FBbEIsa0JBQWtCO2dIQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixhQUZqQixDQUFDLG1CQUFtQixDQUFDOzJGQUV0QixrQkFBa0I7a0JBSDlCLFFBQVE7bUJBQUM7b0JBQ1AsU0FBUyxFQUFFLENBQUMsbUJBQW1CLENBQUM7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZUNvbGxhcHNlU2VydmljZSB9IGZyb20gXCIuL2NvbGxhcHNlLnNlcnZpY2VcIjtcblxuLyoqIEEgbW9kdWxlIGNvbnRhaW5pbmcgdGhlIGVudGl0aWVzIHdoaWNoIHByb3ZpZGUgY29sbGFwc2UgZnVuY3Rpb25hbGl0eSAqL1xuQE5nTW9kdWxlKHtcbiAgIHByb3ZpZGVyczogW1RyZWVDb2xsYXBzZVNlcnZpY2VdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVDb2xsYXBzZU1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGFwc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9leHRyYXMvY29sbGFwc2UvY29sbGFwc2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRXpELDRFQUE0RTtBQUk1RSxNQUFNLE9BQU8sa0JBQWtCOzhHQUFsQixrQkFBa0I7K0dBQWxCLGtCQUFrQjsrR0FBbEIsa0JBQWtCLGFBRmpCLENBQUMsbUJBQW1CLENBQUM7OzJGQUV0QixrQkFBa0I7a0JBSDlCLFFBQVE7bUJBQUM7b0JBQ1AsU0FBUyxFQUFFLENBQUMsbUJBQW1CLENBQUM7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZUNvbGxhcHNlU2VydmljZSB9IGZyb20gXCIuL2NvbGxhcHNlLnNlcnZpY2VcIjtcblxuLyoqIEEgbW9kdWxlIGNvbnRhaW5pbmcgdGhlIGVudGl0aWVzIHdoaWNoIHByb3ZpZGUgY29sbGFwc2UgZnVuY3Rpb25hbGl0eSAqL1xuQE5nTW9kdWxlKHtcbiAgIHByb3ZpZGVyczogW1RyZWVDb2xsYXBzZVNlcnZpY2VdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVDb2xsYXBzZU1vZHVsZSB7fVxuIl19

package/{esm2020 → esm2022}/lib/extras/collapse/collapse.service.mjs

@@ -36,10 +36,10 @@ export class TreeCollapseService {
     isCollapsed(treeBranch) {
         return treeCollapser.isCollapsed(treeBranch);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseService }); }
 }
-TreeCollapseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TreeCollapseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeCollapseService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeCollapseService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extras/drag-and-drop/drag-and-drop.mjs

@@ -0,0 +1,83 @@
+import { Subject } from "rxjs";
+import { config } from "../../core";
+import { TreeError } from "../../errors";
+import { DragEndEvent, DragStartEvent, DropEvent } from "../../events";
+import { dragState, DragStates } from "./drag-state";
+import { assert } from "../../../shared";
+class DragAndDrop {
+    constructor() {
+        this.dragAborted$ = new Subject();
+    }
+    dragStart(treeBranch, event) {
+        if (!this.draggingAllowed(treeBranch)) {
+            event.preventDefault();
+            return;
+        }
+        treeBranch.dispatch(new DragStartEvent(treeBranch));
+        this.setDragEffects(treeBranch, event);
+        this.watchForDragend(treeBranch, event);
+        /* We have to do a setTimeout because DOM changes are not allowed during a
+         * dragstart event. */
+        setTimeout(() => {
+            dragState.starting(treeBranch);
+            treeBranch.prune();
+            dragState.dragging();
+        });
+    }
+    drop(parent, index) {
+        const treeBranch = dragState.getDragData();
+        if (treeBranch === undefined) {
+            throw new TreeError("Cannot get dragged branch");
+        }
+        this.graftDraggedBranch(treeBranch, parent, index);
+        treeBranch.dispatch(new DropEvent(treeBranch, parent, index));
+    }
+    getDragImageOffsets(event, element) {
+        const bounds = element.getBoundingClientRect();
+        const xOffset = event.clientX - bounds.left;
+        const yOffset = event.clientY - bounds.top;
+        return [xOffset, yOffset];
+    }
+    setDragEffects(treeBranch, event) {
+        const dataTransfer = event.dataTransfer;
+        assert(dataTransfer instanceof DataTransfer);
+        const nativeElement = treeBranch.getNativeElement();
+        const [xOffset, yOffset] = this.getDragImageOffsets(event, nativeElement);
+        dataTransfer.setDragImage(nativeElement, xOffset, yOffset);
+    }
+    watchForDragend(treeBranch, event) {
+        const oldParent = treeBranch.parent();
+        const oldIndex = treeBranch.index();
+        assert(oldParent !== undefined && oldIndex !== undefined);
+        event.target?.addEventListener("dragend", (dragend) => {
+            if (dragState.state() !== DragStates.Dropped) {
+                // The drag ended but a drop never occurred, so put the dragged branch back where it started.
+                this.dragAborted$.next(dragend);
+                this.graftDraggedBranch(treeBranch, oldParent, oldIndex);
+            }
+            dragState.restart();
+            const newParent = treeBranch.parent();
+            assert(newParent !== undefined);
+            const newIndex = treeBranch.index();
+            assert(newIndex !== undefined);
+            treeBranch.dispatch(new DragEndEvent(treeBranch, {
+                oldParent,
+                oldIndex,
+                newParent,
+                newIndex
+            }));
+        }, { once: true });
+    }
+    draggingAllowed(treeBranch) {
+        const allowDragging = config.getConfig(treeBranch.root())?.dragAndDrop?.allowDragging ??
+            (() => true);
+        return allowDragging(treeBranch);
+    }
+    graftDraggedBranch(treeBranch, parent, index) {
+        treeBranch.graftTo(parent, index);
+        treeBranch.getNativeElement().style.display = "block";
+        dragState.dropped();
+    }
+}
+export const dragAndDrop = new DragAndDrop();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-and-drop.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/extras/drag-and-drop/drag-and-drop.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from \"rxjs\";\nimport { type TreeBranch, type TreeNode, config } from \"../../core\";\nimport { TreeError } from \"../../errors\";\nimport { DragEndEvent, DragStartEvent, DropEvent } from \"../../events\";\nimport { dragState, DragStates } from \"./drag-state\";\nimport { assert } from \"../../../shared\";\n\nclass DragAndDrop {\n   public readonly dragAborted$ = new Subject<DragEvent>();\n\n   public dragStart<T>(treeBranch: TreeBranch<T>, event: DragEvent): void {\n      if (!this.draggingAllowed(treeBranch)) {\n         event.preventDefault();\n         return;\n      }\n      treeBranch.dispatch(new DragStartEvent(treeBranch));\n      this.setDragEffects(treeBranch, event);\n      this.watchForDragend(treeBranch, event);\n      /* We have to do a setTimeout because DOM changes are not allowed during a\n       * dragstart event. */\n      setTimeout(() => {\n         dragState.starting(treeBranch);\n         treeBranch.prune();\n         dragState.dragging();\n      });\n   }\n\n   public drop<T>(parent: TreeNode<T>, index: number): void {\n      const treeBranch = dragState.getDragData<T>();\n      if (treeBranch === undefined) {\n         throw new TreeError(\"Cannot get dragged branch\");\n      }\n      this.graftDraggedBranch(treeBranch, parent, index);\n      treeBranch.dispatch(new DropEvent(treeBranch, parent, index));\n   }\n\n   private getDragImageOffsets(\n      event: DragEvent,\n      element: Element\n   ): [number, number] {\n      const bounds = element.getBoundingClientRect();\n      const xOffset = event.clientX - bounds.left;\n      const yOffset = event.clientY - bounds.top;\n      return [xOffset, yOffset];\n   }\n\n   private setDragEffects<T>(\n      treeBranch: TreeBranch<T>,\n      event: DragEvent\n   ): void {\n      const dataTransfer = event.dataTransfer;\n      assert(dataTransfer instanceof DataTransfer);\n      const nativeElement = treeBranch.getNativeElement();\n      const [xOffset, yOffset] = this.getDragImageOffsets(event, nativeElement);\n      dataTransfer.setDragImage(nativeElement, xOffset, yOffset);\n   }\n\n   private watchForDragend<T>(\n      treeBranch: TreeBranch<T>,\n      event: DragEvent\n   ): void {\n      const oldParent = treeBranch.parent();\n      const oldIndex = treeBranch.index();\n      assert(oldParent !== undefined && oldIndex !== undefined);\n      event.target?.addEventListener(\n         \"dragend\",\n         (dragend) => {\n            if (dragState.state() !== DragStates.Dropped) {\n               // The drag ended but a drop never occurred, so put the dragged branch back where it started.\n               this.dragAborted$.next(dragend as DragEvent);\n               this.graftDraggedBranch(treeBranch, oldParent, oldIndex);\n            }\n            dragState.restart();\n            const newParent = treeBranch.parent();\n            assert(newParent !== undefined);\n            const newIndex = treeBranch.index();\n            assert(newIndex !== undefined);\n            treeBranch.dispatch(\n               new DragEndEvent(treeBranch, {\n                  oldParent,\n                  oldIndex,\n                  newParent,\n                  newIndex\n               })\n            );\n         },\n         { once: true }\n      );\n   }\n\n   private draggingAllowed<T>(treeBranch: TreeBranch<T>): boolean {\n      const allowDragging =\n         config.getConfig(treeBranch.root())?.dragAndDrop?.allowDragging ??\n         ((): true => true);\n      return allowDragging(treeBranch);\n   }\n\n   private graftDraggedBranch<T>(\n      treeBranch: TreeBranch<T>,\n      parent: TreeNode<T>,\n      index: number\n   ): void {\n      treeBranch.graftTo(parent, index);\n      treeBranch.getNativeElement().style.display = \"block\";\n      dragState.dropped();\n   }\n}\n\nexport const dragAndDrop = new DragAndDrop();\n"]}

package/{esm2020 → esm2022}/lib/extras/drag-and-drop/drag-and-drop.module.mjs

@@ -7,11 +7,11 @@ import * as i0 from "@angular/core";
  * functionality.
  */
 export class TreeDragAndDropModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropModule, imports: [DraggableDirective], exports: [DraggableDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropModule, providers: [TreeDragAndDropService] }); }
 }
-TreeDragAndDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-TreeDragAndDropModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropModule, imports: [DraggableDirective], exports: [DraggableDirective] });
-TreeDragAndDropModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropModule, providers: [TreeDragAndDropService] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [DraggableDirective],
@@ -19,4 +19,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     exports: [DraggableDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V4dHJhcy9kcmFnLWFuZC1kcm9wL2RyYWctYW5kLWRyb3AubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRTNEOzs7R0FHRztBQU1ILE1BQU0sT0FBTyxxQkFBcUI7O2tIQUFyQixxQkFBcUI7bUhBQXJCLHFCQUFxQixZQUpyQixrQkFBa0IsYUFFbEIsa0JBQWtCO21IQUVsQixxQkFBcUIsYUFIcEIsQ0FBQyxzQkFBc0IsQ0FBQzsyRkFHekIscUJBQXFCO2tCQUxqQyxRQUFRO21CQUFDO29CQUNQLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO29CQUM3QixTQUFTLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDbkMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7aUJBQy9CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZURyYWdBbmREcm9wU2VydmljZSB9IGZyb20gXCIuL2RyYWctYW5kLWRyb3Auc2VydmljZVwiO1xuaW1wb3J0IHsgRHJhZ2dhYmxlRGlyZWN0aXZlIH0gZnJvbSBcIi4vZHJhZ2dhYmxlLmRpcmVjdGl2ZVwiO1xuXG4vKipcbiAqIEFuIEFuZ3VsYXIgbW9kdWxlIGNvbnRhaW5pbmcgYWxsIG9mIHRoZSBlbnRpdGllcyB3aGljaCBwcm92aWRlIERyYWctQW5kLURyb3BcbiAqIGZ1bmN0aW9uYWxpdHkuXG4gKi9cbkBOZ01vZHVsZSh7XG4gICBpbXBvcnRzOiBbRHJhZ2dhYmxlRGlyZWN0aXZlXSxcbiAgIHByb3ZpZGVyczogW1RyZWVEcmFnQW5kRHJvcFNlcnZpY2VdLFxuICAgZXhwb3J0czogW0RyYWdnYWJsZURpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgVHJlZURyYWdBbmREcm9wTW9kdWxlIHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V4dHJhcy9kcmFnLWFuZC1kcm9wL2RyYWctYW5kLWRyb3AubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRTNEOzs7R0FHRztBQU1ILE1BQU0sT0FBTyxxQkFBcUI7OEdBQXJCLHFCQUFxQjsrR0FBckIscUJBQXFCLFlBSnJCLGtCQUFrQixhQUVsQixrQkFBa0I7K0dBRWxCLHFCQUFxQixhQUhwQixDQUFDLHNCQUFzQixDQUFDOzsyRkFHekIscUJBQXFCO2tCQUxqQyxRQUFRO21CQUFDO29CQUNQLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO29CQUM3QixTQUFTLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDbkMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7aUJBQy9CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZURyYWdBbmREcm9wU2VydmljZSB9IGZyb20gXCIuL2RyYWctYW5kLWRyb3Auc2VydmljZVwiO1xuaW1wb3J0IHsgRHJhZ2dhYmxlRGlyZWN0aXZlIH0gZnJvbSBcIi4vZHJhZ2dhYmxlLmRpcmVjdGl2ZVwiO1xuXG4vKipcbiAqIEFuIEFuZ3VsYXIgbW9kdWxlIGNvbnRhaW5pbmcgYWxsIG9mIHRoZSBlbnRpdGllcyB3aGljaCBwcm92aWRlIERyYWctQW5kLURyb3BcbiAqIGZ1bmN0aW9uYWxpdHkuXG4gKi9cbkBOZ01vZHVsZSh7XG4gICBpbXBvcnRzOiBbRHJhZ2dhYmxlRGlyZWN0aXZlXSxcbiAgIHByb3ZpZGVyczogW1RyZWVEcmFnQW5kRHJvcFNlcnZpY2VdLFxuICAgZXhwb3J0czogW0RyYWdnYWJsZURpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgVHJlZURyYWdBbmREcm9wTW9kdWxlIHt9XG4iXX0=

package/{esm2020 → esm2022}/lib/extras/drag-and-drop/drag-and-drop.service.mjs

@@ -35,10 +35,10 @@ export class TreeDragAndDropService {
     state() {
         return dragState.events();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropService }); }
 }
-TreeDragAndDropService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TreeDragAndDropService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeDragAndDropService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: TreeDragAndDropService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/extras/drag-and-drop/draggable.directive.mjs

@@ -12,19 +12,19 @@ export class DraggableDirective {
             return;
         dragAndDrop.dragStart(this.limbleTreeDraggable, event);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: DraggableDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.0", type: DraggableDirective, isStandalone: true, selector: "[limbleTreeDraggable]", inputs: { limbleTreeDraggable: "limbleTreeDraggable" }, host: { listeners: { "dragstart": "onDragstart($event)" } }, ngImport: i0 }); }
 }
-DraggableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DraggableDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-DraggableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: DraggableDirective, isStandalone: true, selector: "[limbleTreeDraggable]", inputs: { limbleTreeDraggable: "limbleTreeDraggable" }, host: { listeners: { "dragstart": "onDragstart($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DraggableDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: DraggableDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: "[limbleTreeDraggable]",
                     standalone: true
                 }]
-        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { limbleTreeDraggable: [{
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }], propDecorators: { limbleTreeDraggable: [{
                 type: Input
             }], onDragstart: [{
                 type: HostListener,
                 args: ["dragstart", ["$event"]]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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