@limble/limble-tree 0.13.0 → 1.0.0-alpha.1

package/index.d.ts

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@limble/limble-tree" />
-export * from './public-api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@limble/limble-tree" />
+export * from './public-api';

package/lib/components/branch/branch.component.d.ts

@@ -0,0 +1,26 @@
+import { AfterViewInit, ApplicationRef, ComponentRef, EventEmitter, OnDestroy, QueryList, Type, ViewContainerRef } from "@angular/core";
+import { DropzoneComponent } from "../dropzone/dropzone.component";
+import { HostComponent } from "../host-component.interface";
+import { NodeComponent } from "../node-component.interface";
+import * as i0 from "@angular/core";
+export declare class BranchComponent<T> implements NodeComponent, HostComponent<T>, AfterViewInit, OnDestroy {
+    private readonly appRef;
+    branchesContainer: ViewContainerRef | undefined;
+    contentContainer: ViewContainerRef | undefined;
+    dropzones: QueryList<DropzoneComponent> | undefined;
+    contentToHost?: Type<T>;
+    readonly contentCreated: EventEmitter<T>;
+    readonly showDropzones: EventEmitter<"upper" | "lower">;
+    readonly dropped: EventEmitter<"inner" | "lateral">;
+    showInnerDropzone: boolean;
+    showLateralDropzone: boolean;
+    private hostedContent?;
+    constructor(appRef: ApplicationRef);
+    ngAfterViewInit(): void;
+    getHostedContent(): ComponentRef<T> | undefined;
+    triggerChangeDetection(): void;
+    protected dragoverHandler(event: DragEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BranchComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BranchComponent<any>, "branch", never, { "contentToHost": "contentToHost"; }, { "contentCreated": "contentCreated"; "showDropzones": "showDropzones"; "dropped": "dropped"; }, never, never, true>;
+}

package/lib/components/dropzone/dropzone.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class DropzoneComponent {
+    placement?: "inner" | "lateral";
+    readonly dropped: EventEmitter<DragEvent>;
+    protected active: boolean;
+    dragenterHandler(): void;
+    dragleaveHandler(): void;
+    dragoverHandler(event: DragEvent): void;
+    dropHandler(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropzoneComponent, "dropzone", never, { "placement": "placement"; }, { "dropped": "dropped"; }, never, never, true>;
+}

package/lib/components/host-component.interface.d.ts

@@ -0,0 +1,6 @@
+import { ComponentRef, EventEmitter, Type } from "@angular/core";
+export interface HostComponent<UserlandComponent> {
+    contentCreated: EventEmitter<UserlandComponent>;
+    contentToHost?: Type<UserlandComponent>;
+    getHostedContent: () => ComponentRef<UserlandComponent> | undefined;
+}

package/lib/components/node-component.interface.d.ts

@@ -0,0 +1,5 @@
+import { ViewContainerRef } from "@angular/core";
+export interface NodeComponent {
+    branchesContainer: ViewContainerRef | undefined;
+    showInnerDropzone: boolean;
+}

package/lib/components/root/root.component.d.ts

@@ -0,0 +1,14 @@
+import { AfterViewInit, EventEmitter, ViewContainerRef } from "@angular/core";
+import { DropzoneComponent } from "../dropzone/dropzone.component";
+import { NodeComponent } from "../node-component.interface";
+import * as i0 from "@angular/core";
+export declare class RootComponent implements NodeComponent, AfterViewInit {
+    branchesContainer: ViewContainerRef | undefined;
+    dropzone: DropzoneComponent | undefined;
+    readonly afterViewInit: EventEmitter<void>;
+    readonly dropped: EventEmitter<void>;
+    showInnerDropzone: boolean;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RootComponent, "root", never, {}, { "afterViewInit": "afterViewInit"; "dropped": "dropped"; }, never, never, true>;
+}

package/lib/core/branch-options.interface.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter, Type } from "@angular/core";
+export interface BranchOptions<Component> {
+    inputBindings?: {
+        [K in keyof Component]?: Component[K];
+    };
+    outputBindings?: {
+        [K in keyof Component]?: Component[K] extends EventEmitter<infer T> ? (value: T) => void : never;
+    };
+    startCollapsed?: boolean;
+    meta?: Record<string, any>;
+}
+export interface FullBranchOptions<Component> extends BranchOptions<Component> {
+    component: Type<Component>;
+}

package/lib/core/configuration/configuration.d.ts

@@ -0,0 +1,11 @@
+import { TreeRoot } from "../tree-root/tree-root";
+import { TreeOptions } from "./tree-options.interface";
+declare class Configuration {
+    private readonly configStorage;
+    constructor();
+    setConfig<T>(root: TreeRoot<T>, options: TreeOptions): void;
+    getConfig(root: any): TreeOptions | undefined;
+    delete(root: any): void;
+}
+export declare const config: Configuration;
+export {};

package/lib/core/configuration/tree-options.interface.d.ts

@@ -0,0 +1,35 @@
+import { TreeBranch } from "../tree-branch/tree-branch";
+import { TreeRoot } from "../tree-root/tree-root";
+export interface TreeOptions {
+    /**
+     * A function to indicate whether to allow a node to be dragged. The node in
+     * question is passed in. Defaults to a function that always returns true. This
+     * function runs when DragAndDropService.dragStart runs, and before the branch
+     * is pruned from the tree.
+     */
+    allowDragging?: <T>(treeBranch: TreeBranch<T>) => boolean;
+    /**
+     * A function to determine whether a sourceNode can be dropped at a particular location.
+     * The sourceNode, the new proposedParent for the sourceNode, and the new proposedIndex
+     * for the source node are passed in. This function runs just before displaying a
+     * family of dropzones.
+     */
+    allowDrop?: <T>(sourceNode: TreeBranch<T>, proposedParent: TreeBranch<T> | TreeRoot<T>, proposedIndex: number) => boolean;
+    /**
+     * A function to indicate whether to allow "nesting" (placing a branch one level
+     * deeper than its parent). The node in question is passed in. Defaults to a function
+     * that always returns true. This function runs just before displaying a family of
+     * dropzones.
+     */
+    allowNesting?: <T>(treeBranch: TreeBranch<T>) => boolean;
+    /**
+     * The number of pixels each level of the tree will be indented relative to
+     * its parent. Defaults to 16.
+     */
+    indentation?: number;
+    /**
+     * Whether all branches should start out in a collapsed state, so that only one
+     * level of the tree is visible at first. Defaults to false.
+     */
+    startAllCollapsed?: boolean;
+}

package/lib/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./tree-service/tree.service";
+export * from "./tree-root/tree-root";
+export * from "./tree-branch/tree-branch";
+export * from "./configuration/tree-options.interface";
+export * from "./configuration/configuration";

package/lib/core/relationship.interface.d.ts

@@ -0,0 +1,6 @@
+import { ComponentRef } from "@angular/core";
+import { NodeComponent } from "../components/node-component.interface";
+import { ContainerTreeNode } from "../structure/container-tree-node.interface";
+import { TreeRelationship } from "../structure/tree-relationship.interface";
+import { TreeBranch } from "./tree-branch/tree-branch";
+export declare type Relationship<UserlandComponent> = TreeRelationship<ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>, TreeBranch<UserlandComponent>>;

package/lib/core/tree-branch/tree-branch.d.ts

@@ -0,0 +1,44 @@
+import { TreePlot } from "../../structure/tree-plot";
+import { Observable } from "rxjs";
+import { TreeEvent } from "../../structure/tree-event.interface";
+import { TreeBranchNode } from "../../structure/tree-branch-node.interface";
+import { ComponentRef, Type } from "@angular/core";
+import { BranchComponent } from "../../components/branch/branch.component";
+import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
+import { NodeComponent } from "../../components/node-component.interface";
+import { BranchOptions, FullBranchOptions } from "../branch-options.interface";
+import { TreeRoot } from "..";
+export declare class TreeBranch<UserlandComponent> implements TreeBranchNode<ComponentRef<BranchComponent<UserlandComponent>>, TreeBranch<UserlandComponent>, ComponentRef<NodeComponent>> {
+    readonly branchOptions: FullBranchOptions<UserlandComponent>;
+    private readonly contents;
+    private readonly instanceSubscriptions;
+    private readonly outputBindingSubscriptions;
+    private _parent;
+    private readonly treeNodeBase;
+    private readonly userlandComponent;
+    private detachedView;
+    constructor(parent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>, branchOptions: FullBranchOptions<UserlandComponent>);
+    branches(): Array<TreeBranch<UserlandComponent>>;
+    deleteBranch(index?: number): void;
+    destroy(): void;
+    dispatch(event: TreeEvent): void;
+    events(): Observable<TreeEvent>;
+    getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    getContents(): ComponentRef<BranchComponent<UserlandComponent>>;
+    graftTo(newParent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>, index?: number): number;
+    grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    index(): number | undefined;
+    meta(): Record<string, any>;
+    parent(): ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>> | undefined;
+    plot(): TreePlot;
+    position(): Array<number>;
+    prune(): this | undefined;
+    root(): TreeRoot<UserlandComponent> | undefined;
+    traverse(callback: (node: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>) => void): void;
+    private getContentCreatedSub;
+    private getInstanceSubscriptions;
+    private getShowLowerZonesSub;
+    private getShowUpperZonesSub;
+    private reattachView;
+    private setIndentation;
+}

package/lib/core/tree-node-base.d.ts

@@ -0,0 +1,26 @@
+import { ComponentRef } from "@angular/core";
+import { Observable } from "rxjs";
+import { NodeComponent } from "../components/node-component.interface";
+import { TreeEvent } from "../structure/tree-event.interface";
+import { ContainerTreeNode } from "../structure/container-tree-node.interface";
+import { TreeNode } from "../structure/tree-node.interface";
+import { TreePlot } from "../structure/tree-plot";
+import { TreeBranch } from "./tree-branch/tree-branch";
+export declare class TreeNodeBase<UserlandComponent> implements Partial<TreeNode<TreeBranch<UserlandComponent>>> {
+    private readonly _branches;
+    private readonly events$;
+    private readonly subscriptions;
+    constructor();
+    branches(): Array<TreeBranch<UserlandComponent>>;
+    deleteBranch(index?: number): void;
+    destroy(): void;
+    dispatch(event: TreeEvent): void;
+    events(): Observable<TreeEvent>;
+    getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    plot(): TreePlot;
+    traverse(callback: (node: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>) => void): void;
+    private deregisterChildRelationship;
+    private graftsToSelf;
+    private prunesToSelf;
+    private registerChildRelationship;
+}

package/lib/core/tree-root/tree-root.d.ts

@@ -0,0 +1,28 @@
+import { TreePlot } from "../../structure/tree-plot";
+import { Observable } from "rxjs";
+import { TreeEvent } from "../../structure/tree-event.interface";
+import { TreeBranch } from "../tree-branch/tree-branch";
+import { ComponentRef, Type, ViewContainerRef } from "@angular/core";
+import { RootComponent } from "../../components/root/root.component";
+import { TreeRootNode } from "../../structure/tree-root.node.interface";
+import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
+import { NodeComponent } from "../../components/node-component.interface";
+import { BranchOptions } from "../branch-options.interface";
+export declare class TreeRoot<UserlandComponent> implements TreeRootNode<ComponentRef<RootComponent>, TreeBranch<UserlandComponent>> {
+    private readonly viewContainerRef;
+    private readonly instanceSubscriptions;
+    private readonly rootComponentRef;
+    private readonly treeNodeBase;
+    constructor(viewContainerRef: ViewContainerRef);
+    branches(): Array<TreeBranch<UserlandComponent>>;
+    deleteBranch(index?: number): void;
+    destroy(): void;
+    dispatch(event: TreeEvent): void;
+    events(): Observable<TreeEvent>;
+    getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    getContents(): ComponentRef<RootComponent>;
+    grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    plot(): TreePlot;
+    root(): this;
+    traverse(callback: (node: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<UserlandComponent>>) => void): void;
+}

package/lib/core/tree-service/tree.service.d.ts

@@ -0,0 +1,9 @@
+import { ViewContainerRef } from "@angular/core";
+import { TreeOptions } from "../configuration/tree-options.interface";
+import { TreeRoot } from "../tree-root/tree-root";
+import * as i0 from "@angular/core";
+export declare class TreeService {
+    createEmptyTree<Component>(container: ViewContainerRef, options?: TreeOptions): TreeRoot<Component>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeService>;
+}

package/lib/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./tree-error";

package/lib/errors/tree-error.d.ts

@@ -0,0 +1,2 @@
+export declare class TreeError extends Error {
+}

package/lib/events/drag/drag-end-event.d.ts

@@ -0,0 +1,25 @@
+import { ComponentRef } from "@angular/core";
+import { NodeComponent } from "../../components/node-component.interface";
+import { TreeBranch } from "../../core";
+import { ContainerTreeNode } from "../../structure";
+import { EventConduit } from "../../structure/event-conduit.interface";
+import { TreeEvent } from "../../structure/tree-event.interface";
+export declare class DragEndEvent<T> implements TreeEvent {
+    private readonly _source;
+    private readonly _newParent;
+    private readonly _newIndex;
+    private readonly _oldParent;
+    private readonly _oldIndex;
+    constructor(source: EventConduit, endpoints: {
+        oldParent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+        oldIndex: number;
+        newParent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+        newIndex: number;
+    });
+    type(): "drag end";
+    source(): EventConduit;
+    newIndex(): number;
+    newParent(): ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+    oldIndex(): number;
+    oldParent(): ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+}

package/lib/events/drag/drag-start-event.d.ts

@@ -0,0 +1,8 @@
+import { EventConduit } from "../../structure/event-conduit.interface";
+import { TreeEvent } from "../../structure/tree-event.interface";
+export declare class DragStartEvent implements TreeEvent {
+    private readonly _source;
+    constructor(source: EventConduit);
+    type(): "drag start";
+    source(): EventConduit;
+}

package/lib/events/drag/drop-event.d.ts

@@ -0,0 +1,16 @@
+import { ComponentRef } from "@angular/core";
+import { NodeComponent } from "../../components/node-component.interface";
+import { TreeBranch } from "../../core";
+import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
+import { EventConduit } from "../../structure/event-conduit.interface";
+import { TreeEvent } from "../../structure/tree-event.interface";
+export declare class DropEvent<T> implements TreeEvent {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _index;
+    constructor(source: EventConduit, parent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>, index: number);
+    type(): "drag end";
+    source(): EventConduit;
+    index(): number;
+    parent(): ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+}

package/lib/events/drag/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./drag-end-event";
+export * from "./drag-start-event";
+export * from "./drop-event";

package/lib/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./relational";
+export * from "./drag";

package/lib/events/relational/graft-event.d.ts

@@ -0,0 +1,15 @@
+import { EventConduit } from "../../structure/event-conduit.interface";
+import { RelationalTreeEvent } from "./relational-tree-event.interface";
+import { TreeRelationship } from "../../structure/tree-relationship.interface";
+export declare class GraftEvent<T extends TreeRelationship<any, any>> implements RelationalTreeEvent<T["parent"], T["child"]> {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _child;
+    private readonly _index;
+    constructor(source: EventConduit, relationship: T);
+    child(): T["child"];
+    type(): "graft";
+    index(): number;
+    parent(): T["parent"];
+    source(): EventConduit;
+}

package/lib/events/relational/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./graft-event";
+export * from "./prune-event";
+export * from "./relational-tree-event.interface";

package/lib/events/relational/prune-event.d.ts

@@ -0,0 +1,15 @@
+import { EventConduit } from "../../structure/event-conduit.interface";
+import { RelationalTreeEvent } from "./relational-tree-event.interface";
+import { TreeRelationship } from "../../structure/tree-relationship.interface";
+export declare class PruneEvent<T extends TreeRelationship<any, any>> implements RelationalTreeEvent<T["parent"], T["child"]> {
+    private readonly _source;
+    private readonly _parent;
+    private readonly _child;
+    private readonly _index;
+    constructor(source: EventConduit, relationship: T);
+    child(): T["child"];
+    type(): "prune";
+    index(): number;
+    parent(): T["parent"];
+    source(): EventConduit;
+}

package/lib/events/relational/relational-tree-event.interface.d.ts

@@ -0,0 +1,6 @@
+import { TreeEvent } from "../../structure/tree-event.interface";
+export interface RelationalTreeEvent<Parent, Child> extends TreeEvent {
+    parent: () => Parent;
+    child: () => Child;
+    index: () => number;
+}

package/lib/extras/collapse/collapse.d.ts

@@ -0,0 +1,11 @@
+import { TreeBranch } from "../../core";
+declare class TreeCollapser {
+    private readonly tempStorage;
+    constructor();
+    collapse<T>(treeBranch: TreeBranch<T>): void;
+    expand<T>(treeBranch: TreeBranch<T>): void;
+    isCollapsed<T>(treeBranch: TreeBranch<T>): boolean;
+    storePrecollapsedNode<T>(parent: TreeBranch<T>, branch: TreeBranch<T>): void;
+}
+export declare const treeCollapser: TreeCollapser;
+export {};

package/lib/extras/collapse/collapse.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class TreeCollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeCollapseModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeCollapseModule>;
+}

package/lib/extras/collapse/collapse.service.d.ts

@@ -0,0 +1,9 @@
+import { TreeBranch } from "../../core";
+import * as i0 from "@angular/core";
+export declare class TreeCollapseService {
+    collapse<T>(treeBranch: TreeBranch<T>): void;
+    expand<T>(treeBranch: TreeBranch<T>): void;
+    isCollapsed<T>(treeBranch: TreeBranch<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeCollapseService>;
+}

package/lib/extras/collapse/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./collapse.module";
+export * from "./collapse.service";

package/lib/extras/drag-and-drop/drag-and-drop.d.ts

@@ -0,0 +1,17 @@
+import { ComponentRef } from "@angular/core";
+import { Subject } from "rxjs";
+import { NodeComponent } from "../../components/node-component.interface";
+import { TreeBranch } from "../../core";
+import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
+declare class DragAndDrop {
+    readonly dragAborted$: Subject<DragEvent>;
+    dragStart<T>(treeBranch: TreeBranch<T>, event: DragEvent): void;
+    drop<T>(parent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>, index: number): void;
+    private getDragImageOffsets;
+    private setDragEffects;
+    private watchForDragend;
+    private draggingAllowed;
+    private graftDraggedBranch;
+}
+export declare const dragAndDrop: DragAndDrop;
+export {};

package/lib/extras/drag-and-drop/drag-and-drop.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./draggable.directive";
+import * as i2 from "./dragover-no-change-detect";
+export declare class TreeDragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeDragAndDropModule, never, [typeof i1.DraggableDirective, typeof i2.DragoverNoChangeDetectDirective], [typeof i1.DraggableDirective, typeof i2.DragoverNoChangeDetectDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeDragAndDropModule>;
+}

package/lib/extras/drag-and-drop/drag-and-drop.service.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from "rxjs";
+import { TreeBranch, TreeRoot } from "../../core";
+import { DragStates } from "./drag-state";
+import * as i0 from "@angular/core";
+export declare class TreeDragAndDropService {
+    clearDropzones(): void;
+    dragStart<T>(treeBranch: TreeBranch<T>, event: DragEvent): void;
+    getCurrentlyDisplayedDropzoneFamily(): {
+        treeBranch: TreeRoot<any> | TreeBranch<any>;
+        direction: "upper" | "lower";
+    } | null;
+    showRootDropzone<T>(root: TreeRoot<T>): void;
+    state(): Observable<DragStates>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeDragAndDropService>;
+}

package/lib/extras/drag-and-drop/drag-state.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from "rxjs";
+import { TreeBranch } from "../../core";
+export declare enum DragStates {
+    Idle = 0,
+    Starting = 1,
+    Dragging = 2,
+    Dropped = 3
+}
+declare class DragState {
+    private dragData;
+    private _state;
+    private readonly state$;
+    constructor();
+    getDragData<T>(): TreeBranch<T> | undefined;
+    starting<T>(treeBranch: TreeBranch<T>): void;
+    dragging(): void;
+    dropped(): void;
+    restart(): void;
+    events(): Observable<DragStates>;
+    state(): DragStates;
+}
+export declare const dragState: DragState;
+export {};

package/lib/extras/drag-and-drop/draggable.directive.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef, Renderer2 } from "@angular/core";
+import { TreeBranch } from "../../core";
+import { TreeDragAndDropService } from "./drag-and-drop.service";
+import * as i0 from "@angular/core";
+export declare class DraggableDirective {
+    private readonly dragAndDropService;
+    limbleTreeDraggable?: TreeBranch<any>;
+    constructor(dragAndDropService: TreeDragAndDropService, renderer: Renderer2, hostElement: ElementRef<HTMLElement>);
+    onDragstart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[limbleTreeDraggable]", never, { "limbleTreeDraggable": "limbleTreeDraggable"; }, {}, never, never, true>;
+}

package/lib/{custom-event-bindings/dragover-no-change-detect.directive.d.ts → extras/drag-and-drop/dragover-no-change-detect.d.ts}

@@ -1,14 +1,14 @@
-import { ElementRef, EventEmitter, NgZone, OnDestroy, OnInit } from "@angular/core";
-import * as i0 from "@angular/core";
-export declare class DragoverNoChangeDetectDirective implements OnInit, OnDestroy {
-    private readonly ngZone;
-    private readonly el;
-    dragoverEventThrottle: number;
-    readonly dragoverNoChangeDetect: EventEmitter<DragEvent>;
-    private eventSubscription;
-    constructor(ngZone: NgZone, el: ElementRef<Element>);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragoverNoChangeDetectDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DragoverNoChangeDetectDirective, "[dragoverNoChangeDetect]", never, { "dragoverEventThrottle": "dragoverEventThrottle"; }, { "dragoverNoChangeDetect": "dragoverNoChangeDetect"; }, never, never, false>;
-}
+import { ElementRef, EventEmitter, NgZone, OnDestroy, OnInit } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class DragoverNoChangeDetectDirective implements OnInit, OnDestroy {
+    private readonly ngZone;
+    private readonly el;
+    dragoverEventThrottle: number;
+    readonly dragoverNoChangeDetect: EventEmitter<DragEvent>;
+    private eventSubscription;
+    constructor(ngZone: NgZone, el: ElementRef<Element>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragoverNoChangeDetectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragoverNoChangeDetectDirective, "[dragoverNoChangeDetect]", never, { "dragoverEventThrottle": "dragoverEventThrottle"; }, { "dragoverNoChangeDetect": "dragoverNoChangeDetect"; }, never, never, true>;
+}

package/lib/extras/drag-and-drop/dropzone-renderer.d.ts

@@ -0,0 +1,28 @@
+import { DropzoneComponent } from "../../components/dropzone/dropzone.component";
+import { TreeBranch } from "../../core/tree-branch/tree-branch";
+import { TreeRoot } from "../../core/tree-root/tree-root";
+declare class DropzoneRenderer {
+    private currentDisplay;
+    private readonly registry;
+    constructor();
+    clearCurrentDisplay(): void;
+    clearTreeFromRegistry(tree: TreeRoot<any> | TreeBranch<any>): void;
+    getCurrentDisplay(): {
+        treeBranch: TreeBranch<any> | TreeRoot<any>;
+        direction: "upper" | "lower";
+    } | null;
+    getDropzoneLocation<T>(dropzone: DropzoneComponent): [TreeBranch<T> | TreeRoot<T>, "inner" | "lateral"];
+    handleDrop<T>(treeNode: TreeBranch<T> | TreeRoot<T>, placement: "inner" | "lateral"): void;
+    registerDropzone<T>(dropzone: DropzoneComponent, treeNode: TreeBranch<T> | TreeRoot<T>): void;
+    registerDropzones<T>(dropzones: Iterable<DropzoneComponent>, treeBranch: TreeBranch<T>): void;
+    showLowerZones<T>(treeNode: TreeBranch<T> | TreeRoot<T>): void;
+    showUpperZones<T>(treeBranch: TreeBranch<T>): void;
+    private loopThroughLowerZones;
+    private loopThroughUpperZones;
+    private nestingAllowed;
+    private dropAllowed;
+    private showInnerZone;
+    private showLateralZone;
+}
+export declare const dropzoneRenderer: DropzoneRenderer;
+export {};

package/lib/extras/drag-and-drop/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./drag-and-drop.module";
+export * from "./drag-and-drop.service";
+export * from "./draggable.directive";
+export * from "./dragover-no-change-detect";

package/lib/legacy/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./legacy-component-obj.interface";
+export * from "./legacy-tree-data.interface";
+export * from "./legacy-tree-options.interface";
+export * from "./legacy-tree";
+export * from "./limble-tree-root/limble-tree-root.component";
+export * from "./limble-tree-legacy.module";

package/lib/legacy/legacy-component-obj.interface.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@angular/core";
+/**
+ * An object that references the component to be rendered and its bindings
+ * @deprecated
+ */
+export interface ComponentObj {
+    /** The component class */
+    class: Type<unknown>;
+    /** The bindings (inputs and outputs) of the class */
+    bindings?: {
+        [index: string]: unknown;
+    };
+}

package/lib/legacy/legacy-tree-data.interface.d.ts

@@ -0,0 +1,18 @@
+import { ComponentObj } from "./legacy-component-obj.interface";
+/**
+ * An object describing a node of the tree
+ * @deprecated
+ */
+export interface LimbleTreeNode {
+    /** A list of nodes to be rendered "under" this one, one level deeper in the tree. */
+    nodes?: LimbleTreeData;
+    /** An object that describes the component which will represent this node in the visual tree */
+    component?: ComponentObj;
+    collapsed?: boolean;
+    [index: string]: unknown;
+}
+/**
+ * An object that the limble-tree-root component uses to build the tree
+ * @deprecated
+ */
+export declare type LimbleTreeData = Array<LimbleTreeNode>;