concepto-user-controls 0.0.7 → 0.0.9

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

@@ -0,0 +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, { "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/lib/entity-comparison/components/entity-comparison.component.d.ts

@@ -0,0 +1,49 @@
+import { EntityComparisonService } from '../core/services/entity-comparison.service';
+import * as i0 from "@angular/core";
+export interface ComparisonResult {
+    leftOnly: any[];
+    rightOnly: any[];
+    modified: any[];
+    unchanged: any[];
+}
+export declare class EntityComparisonComponent {
+    private comparisonService;
+    leftFile: string;
+    rightFile: string;
+    leftEntities: any[];
+    rightEntities: any[];
+    selectedLeftEntity: any;
+    selectedRightEntity: any;
+    comparisonResult: ComparisonResult | null;
+    expandedNodes: Set<string>;
+    isFullScreen: boolean;
+    currentDifferenceIndex: number;
+    differences: any[];
+    constructor(comparisonService: EntityComparisonService);
+    onLeftFileSelected(event: any): void;
+    onRightFileSelected(event: any): void;
+    selectLeftEntity(entity: any): void;
+    selectRightEntity(entity: any): void;
+    private compareIfBothSelected;
+    private buildDifferencesList;
+    navigateToNextDifference(): void;
+    navigateToPreviousDifference(): void;
+    private scrollToDifference;
+    private expandPathToNode;
+    private expandParentsInStructure;
+    get hasDifferences(): boolean;
+    get currentDifferenceNumber(): number;
+    get totalDifferences(): number;
+    toggleNode(nodeId: string): void;
+    isExpanded(nodeId: string): boolean;
+    getNodeId(node: any, prefix: string): string;
+    hasChildren(node: any): boolean;
+    getChildren(node: any): any[];
+    getProperties(node: any): any;
+    getPropertyKeys(node: any): string[];
+    getChangeType(node: any): string;
+    getModifiedProperties(node: any): string[];
+    toggleFullScreen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityComparisonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityComparisonComponent, "app-entity-comparison", never, {}, {}, never, never, true, never>;
+}

package/lib/entity-comparison/core/services/entity-comparison.service.d.ts

@@ -0,0 +1,10 @@
+import { ComparisonResult } from '../../components/entity-comparison.component';
+import * as i0 from "@angular/core";
+export declare class EntityComparisonService {
+    parseEntities(xmlString: string): any[];
+    compareStructures(leftStructure: any[], rightStructure: any[]): ComparisonResult;
+    private createNodeMap;
+    private compareNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityComparisonService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityComparisonService>;
+}

package/package.json

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

package/public-api.d.ts

@@ -2,3 +2,6 @@ export * from './lib/concepto-user-controls.service';
 export * from './lib/concepto-user-controls.component';
 export * from './lib/concepto-message/concepto-message.component';
 export * from './lib/concepto-context-menu/concepto-context-menu.component';
+export * from './lib/concepto-tree/concepto-tree.component';
+export * from './lib/entity-comparison/components/entity-comparison.component';
+export * from './lib/entity-comparison/core/services/entity-comparison.service';