concepto-user-controls 0.0.8 → 0.0.9

package/lib/concepto-tree/components/tree-root/tree-root.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { TreeModel } from '../../core/models/tree.model';
+import { TreeOptions } from '../../core/models/tree-options.model';
+import { TreeEvent } from '../../core/models/tree-events.model';
+import * as i0 from "@angular/core";
+export declare class TreeRootComponent implements OnInit, OnChanges, OnDestroy {
+    nodes: any[];
+    options: Partial<TreeOptions>;
+    initialized: EventEmitter<TreeEvent>;
+    toggleExpanded: EventEmitter<TreeEvent>;
+    activate: EventEmitter<TreeEvent>;
+    deactivate: EventEmitter<TreeEvent>;
+    select: EventEmitter<TreeEvent>;
+    deselect: EventEmitter<TreeEvent>;
+    focus: EventEmitter<TreeEvent>;
+    blur: EventEmitter<TreeEvent>;
+    moveNode: EventEmitter<TreeEvent>;
+    loadChildren: EventEmitter<TreeEvent>;
+    treeEvent: EventEmitter<TreeEvent>;
+    readonly nodeTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    treeModel: TreeModel;
+    mergedOptions: TreeOptions;
+    isFocused: import("@angular/core").WritableSignal<boolean>;
+    private eventsSubscription?;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initializeTreeModel;
+    ngOnDestroy(): void;
+    private handleTreeEvent;
+    onKeydown(event: KeyboardEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeRootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeRootComponent, "tree-root", never, { "nodes": { "alias": "nodes"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "initialized": "initialized"; "toggleExpanded": "toggleExpanded"; "activate": "activate"; "deactivate": "deactivate"; "select": "select"; "deselect": "deselect"; "focus": "focus"; "blur": "blur"; "moveNode": "moveNode"; "loadChildren": "loadChildren"; "treeEvent": "treeEvent"; }, ["nodeTemplate"], never, true, never>;
+}

package/lib/concepto-tree/components/tree-viewport/tree-viewport.component.d.ts

@@ -0,0 +1,33 @@
+import { OnInit, OnDestroy, ElementRef, TemplateRef } from '@angular/core';
+import { TreeModel } from '../../core/models/tree.model';
+import { TreeNode } from '../../core/models/tree-node.model';
+import { TreeOptions } from '../../core/models/tree-options.model';
+import * as i0 from "@angular/core";
+export declare class TreeViewportComponent implements OnInit, OnDestroy {
+    treeModel: TreeModel;
+    options: TreeOptions;
+    nodeTemplate?: TemplateRef<any>;
+    scrollContainer: ElementRef<HTMLElement>;
+    private destroy$;
+    readonly scrollTop: import("@angular/core").WritableSignal<number>;
+    readonly viewportHeight: import("@angular/core").WritableSignal<number>;
+    readonly flattenedNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly totalHeight: import("@angular/core").Signal<number>;
+    readonly visibleRange: import("@angular/core").Signal<{
+        startIndex: number;
+        endIndex: number;
+    }>;
+    readonly visibleNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly paddingTop: import("@angular/core").Signal<number>;
+    readonly paddingBottom: import("@angular/core").Signal<number>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupScrollListener;
+    private updateViewportHeight;
+    onScroll(): void;
+    private updateViewport;
+    scrollToNode(node: TreeNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeViewportComponent, "tree-viewport", never, { "treeModel": { "alias": "treeModel"; "required": true; }; "options": { "alias": "options"; "required": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/concepto-tree/concepto-tree.component.d.ts

@@ -1,5 +1,36 @@
+import { EventEmitter } from '@angular/core';
+import { TreeRootComponent } from './components/tree-root/tree-root.component';
+import { TreeOptions } from './core/models/tree-options.model';
+import { TreeEvent } from './core/models/tree-events.model';
+import { TreeNode } from './core/models/tree-node.model';
 import * as i0 from "@angular/core";
 export declare class ConceptoTreeComponent {
+    nodes: any[];
+    options: Partial<TreeOptions>;
+    initialized: EventEmitter<TreeEvent>;
+    toggleExpanded: EventEmitter<TreeEvent>;
+    activate: EventEmitter<TreeEvent>;
+    deactivate: EventEmitter<TreeEvent>;
+    select: EventEmitter<TreeEvent>;
+    deselect: EventEmitter<TreeEvent>;
+    focus: EventEmitter<TreeEvent>;
+    blur: EventEmitter<TreeEvent>;
+    moveNode: EventEmitter<TreeEvent>;
+    loadChildren: EventEmitter<TreeEvent>;
+    treeEvent: EventEmitter<TreeEvent>;
+    treeRoot: TreeRootComponent;
+    isDropdownOpen: import("@angular/core").WritableSignal<boolean>;
+    searchTerm: string;
+    selectedNode: import("@angular/core").WritableSignal<TreeNode | null>;
+    private allNodes;
+    filteredNodes: import("@angular/core").WritableSignal<TreeNode[]>;
+    get displayField(): string;
+    toggleDropdown(): void;
+    closeDropdown(): void;
+    filterNodes(): void;
+    selectNode(node: TreeNode): void;
+    onTreeInitialized(event: TreeEvent): void;
+    onNodeActivated(event: TreeEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConceptoTreeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConceptoTreeComponent, "lib-concepto-tree", never, {}, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConceptoTreeComponent, "lib-concepto-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "initialized": "initialized"; "toggleExpanded": "toggleExpanded"; "activate": "activate"; "deactivate": "deactivate"; "select": "select"; "deselect": "deselect"; "focus": "focus"; "blur": "blur"; "moveNode": "moveNode"; "loadChildren": "loadChildren"; "treeEvent": "treeEvent"; }, never, never, true, never>;
 }

package/lib/concepto-tree/core/models/tree-events.model.d.ts

@@ -0,0 +1,13 @@
+import { TreeNode } from './tree-node.model';
+import { TreeModel } from './tree.model';
+export type TreeEventType = 'initialized' | 'update' | 'expand' | 'collapse' | 'expandAll' | 'collapseAll' | 'activate' | 'deactivate' | 'select' | 'deselect' | 'focus' | 'blur' | 'moveNode' | 'loadChildren' | 'loadChildrenError' | 'filter' | 'clearFilter';
+export interface TreeEvent {
+    type: TreeEventType;
+    treeModel?: TreeModel;
+    node?: TreeNode;
+    to?: {
+        parent: TreeNode;
+        index: number;
+    };
+    error?: any;
+}

package/lib/concepto-tree/core/models/tree-node.model.d.ts

@@ -0,0 +1,39 @@
+import { Signal } from '@angular/core';
+import { TreeOptions } from './tree-options.model';
+export interface TreeNodeData {
+    id: string | number;
+    [key: string]: any;
+}
+export declare class TreeNode {
+    readonly isExpanded: import("@angular/core").WritableSignal<boolean>;
+    readonly isActive: import("@angular/core").WritableSignal<boolean>;
+    readonly isSelected: import("@angular/core").WritableSignal<boolean>;
+    readonly isFocused: import("@angular/core").WritableSignal<boolean>;
+    readonly isHidden: import("@angular/core").WritableSignal<boolean>;
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly isCollapsed: Signal<boolean>;
+    readonly isLeaf: Signal<boolean>;
+    readonly isVisible: Signal<boolean>;
+    id: string | number;
+    data: TreeNodeData;
+    parent: TreeNode | null;
+    children: TreeNode[];
+    level: number;
+    path: Array<string | number>;
+    index: number;
+    hasChildren: boolean;
+    icon?: string;
+    constructor(data: TreeNodeData, parent: TreeNode | null, level: number, index: number, options: TreeOptions);
+    expand(): void;
+    collapse(): void;
+    toggle(): void;
+    setActive(value: boolean): void;
+    setSelected(value: boolean): void;
+    setFocus(value: boolean): void;
+    setHidden(value: boolean): void;
+    setLoading(value: boolean): void;
+    ensureVisible(): void;
+    setActiveAndVisible(): void;
+    getAncestors(): TreeNode[];
+    getDescendants(): TreeNode[];
+}

package/lib/concepto-tree/core/models/tree-options.model.d.ts

@@ -0,0 +1,28 @@
+import { TreeNode } from './tree-node.model';
+export interface TreeOptions {
+    idField?: string;
+    childrenField?: string;
+    displayField?: string;
+    isExpandedField?: string;
+    hasChildrenField?: string;
+    iconField?: string;
+    allowDrag?: boolean | ((node: TreeNode) => boolean);
+    allowDrop?: boolean | ((node: TreeNode, to: any) => boolean);
+    useCheckbox?: boolean;
+    useTriState?: boolean;
+    levelPadding?: number;
+    useVirtualScroll?: boolean;
+    nodeHeight?: number | ((node: TreeNode) => number);
+    scrollContainerHeight?: number;
+    bufferAmount?: number;
+    getChildren?: (node: TreeNode) => Promise<any[]>;
+    animateExpand?: boolean;
+    animateSpeed?: number;
+    animateAcceleration?: number;
+    scrollOnActivate?: boolean;
+    scrollContainer?: HTMLElement;
+    rtl?: boolean;
+    multiSelect?: boolean;
+    useMetaKey?: boolean;
+}
+export declare const DEFAULT_TREE_OPTIONS: TreeOptions;

package/lib/concepto-tree/core/models/tree.model.d.ts

@@ -0,0 +1,54 @@
+import { Subject } from 'rxjs';
+import { TreeNode } from './tree-node.model';
+import { TreeOptions } from './tree-options.model';
+import { TreeEvent } from './tree-events.model';
+export declare class TreeModel {
+    options: TreeOptions;
+    readonly roots: import("@angular/core").WritableSignal<TreeNode[]>;
+    readonly focusedNodeId: import("@angular/core").WritableSignal<string | number | null>;
+    readonly expandedNodeIds: import("@angular/core").WritableSignal<Set<string | number>>;
+    readonly activeNodeIds: import("@angular/core").WritableSignal<Set<string | number>>;
+    readonly selectedNodeIds: import("@angular/core").WritableSignal<Set<string | number>>;
+    readonly hiddenNodeIds: import("@angular/core").WritableSignal<Set<string | number>>;
+    readonly focusedNode: import("@angular/core").Signal<TreeNode | null>;
+    readonly expandedNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly activeNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly selectedNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly visibleNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly flattenedNodes: import("@angular/core").Signal<TreeNode[]>;
+    readonly events$: Subject<TreeEvent>;
+    virtualRoot: TreeNode | null;
+    private nodeRegistry;
+    constructor(options: TreeOptions);
+    setData(data: any[]): void;
+    private buildNodes;
+    update(): void;
+    getNodeById(id: string | number): TreeNode | null;
+    getNodeBy(predicate: (node: TreeNode) => boolean): TreeNode | null;
+    getAllNodes(): TreeNode[];
+    focusNode(node: TreeNode | null): void;
+    focusNextNode(): void;
+    focusPreviousNode(): void;
+    focusDrillDown(): void;
+    focusDrillUp(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    expandNode(node: TreeNode): void;
+    collapseNode(node: TreeNode): void;
+    activateNode(node: TreeNode, multi?: boolean): void;
+    deactivateNode(node: TreeNode): void;
+    selectNode(node: TreeNode, multi?: boolean): void;
+    filterNodes(filterFn: (node: TreeNode) => boolean, autoShow?: boolean): void;
+    clearFilter(): void;
+    canMoveNode(node: TreeNode, to: {
+        parent: TreeNode;
+        index: number;
+    }): boolean;
+    moveNode(node: TreeNode, to: {
+        parent: TreeNode;
+        index: number;
+    }): void;
+    private updateNodeLevels;
+    loadChildren(node: TreeNode): Promise<void>;
+    private emitEvent;
+}

package/lib/concepto-tree/core/services/tree-drag-drop.service.d.ts

@@ -0,0 +1,11 @@
+import { TreeNode } from '../models/tree-node.model';
+import * as i0 from "@angular/core";
+export declare class TreeDragDropService {
+    private readonly draggedNode;
+    setDraggedNode(node: TreeNode): void;
+    getDraggedNode(): TreeNode | null;
+    clearDraggedNode(): void;
+    isDragging(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragDropService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeDragDropService>;
+}

package/lib/concepto-tree/directives/tree-drag.directive.d.ts

@@ -0,0 +1,16 @@
+import { TreeNode } from '../core/models/tree-node.model';
+import { TreeModel } from '../core/models/tree.model';
+import { TreeOptions } from '../core/models/tree-options.model';
+import * as i0 from "@angular/core";
+export declare class TreeDragDirective {
+    node: TreeNode;
+    treeModel: TreeModel;
+    options: TreeOptions;
+    private readonly elementRef;
+    private readonly dragDropService;
+    get draggable(): boolean;
+    onDragStart(event: DragEvent): void;
+    onDragEnd(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDragDirective, "[treeDrag]", never, { "node": { "alias": "treeDrag"; "required": true; }; "treeModel": { "alias": "treeModel"; "required": true; }; "options": { "alias": "options"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/concepto-tree/directives/tree-drop.directive.d.ts

@@ -0,0 +1,25 @@
+import { TreeNode } from '../core/models/tree-node.model';
+import { TreeModel } from '../core/models/tree.model';
+import { TreeOptions } from '../core/models/tree-options.model';
+import * as i0 from "@angular/core";
+type DropPosition = 'before' | 'after' | 'inside';
+export declare class TreeDropDirective {
+    node: TreeNode;
+    treeModel: TreeModel;
+    options: TreeOptions;
+    dropPosition: DropPosition;
+    private readonly elementRef;
+    private readonly dragDropService;
+    readonly isDraggingOver: import("@angular/core").WritableSignal<boolean>;
+    readonly canDrop: import("@angular/core").WritableSignal<boolean>;
+    get isDropTarget(): boolean;
+    get isDropDisabled(): boolean;
+    onDragEnter(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    private getDropTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDropDirective, "[treeDrop]", never, { "node": { "alias": "treeDrop"; "required": true; }; "treeModel": { "alias": "treeModel"; "required": true; }; "options": { "alias": "options"; "required": true; }; "dropPosition": { "alias": "dropPosition"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/concepto-tree/directives/tree-node-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TreeNodeTemplateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeTemplateDirective, "[treeNodeTemplate]", never, {}, {}, never, never, true, never>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "concepto-user-controls",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "peerDependencies": {
     "@angular/common": "^18.2.0 || ^19.0.0",
     "@angular/core": "^18.2.0 || ^19.0.0"