@ngx-km/layout 0.0.1

package/README.md

@@ -0,0 +1,186 @@
+# @ngx-km/layout
+
+Layout calculation library for Angular graph visualization. Uses an abstracted engine architecture (default: ELK.js) that can be swapped for alternative layout engines.
+
+## Features
+
+- Pluggable layout engine architecture
+- ELK.js implementation included (default)
+- Multiple layout algorithms: layered, force, stress, radial, tree
+- Configurable spacing, direction, and padding
+- Incremental layout support (add/remove nodes while preserving positions)
+- Returns node coordinates only (no rendering)
+- Validation of input graphs
+
+## Installation
+
+```bash
+npm install @ngx-km/layout elkjs
+```
+
+## Basic Usage
+
+```typescript
+import { Component, inject } from '@angular/core';
+import { LayoutService, LayoutNode, LayoutEdge } from '@ngx-km/layout';
+
+@Component({
+  providers: [LayoutService],
+  // ...
+})
+export class MyComponent {
+  private layoutService = inject(LayoutService);
+
+  async calculateLayout() {
+    const nodes: LayoutNode[] = [
+      { id: 'a', width: 100, height: 50 },
+      { id: 'b', width: 100, height: 50 },
+      { id: 'c', width: 100, height: 50 },
+    ];
+
+    const edges: LayoutEdge[] = [
+      { id: 'e1', sourceId: 'a', targetId: 'b' },
+      { id: 'e2', sourceId: 'a', targetId: 'c' },
+    ];
+
+    const result = await this.layoutService.layout(nodes, edges, {
+      algorithm: 'layered',
+      direction: 'DOWN',
+      nodeSpacing: 50,
+      layerSpacing: 100,
+    });
+
+    // result.nodes contains positioned nodes with x, y coordinates
+    console.log(result.nodes);
+  }
+}
+```
+
+## Incremental Layout
+
+The library supports incremental layout operations for dynamic graphs:
+
+### Adding Nodes
+
+```typescript
+// Start with initial layout
+const initialResult = await layoutService.layout(nodes, edges);
+
+// Add new nodes while preserving existing positions
+const newNodes = [{ id: 'd', width: 100, height: 50 }];
+const allEdges = [...edges, { id: 'e3', sourceId: 'c', targetId: 'd' }];
+
+const updatedResult = await layoutService.addNodesToLayout(
+  initialResult,
+  newNodes,
+  allEdges
+);
+```
+
+### Removing Nodes
+
+```typescript
+// Remove nodes (connected edges are automatically filtered)
+const result = await layoutService.removeNodesFromLayout(
+  previousResult,
+  ['nodeIdToRemove'],
+  allEdges,
+  options,
+  true // preservePositions: remaining nodes keep their positions
+);
+```
+
+### Recalculating with Position Preservation
+
+```typescript
+// Manually specify which positions to preserve
+const existingPositions = new Map<string, { x: number; y: number }>();
+existingPositions.set('a', { x: 100, y: 50 });
+existingPositions.set('b', { x: 200, y: 50 });
+
+const result = await layoutService.recalculateLayout(
+  allNodes,
+  allEdges,
+  existingPositions,
+  options
+);
+```
+
+## Layout Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `algorithm` | `'layered' \| 'force' \| 'stress' \| 'radial' \| 'tree'` | `'layered'` | Layout algorithm |
+| `direction` | `'DOWN' \| 'UP' \| 'RIGHT' \| 'LEFT'` | `'DOWN'` | Direction for hierarchical layouts |
+| `nodeSpacing` | `number` | `50` | Horizontal spacing between nodes |
+| `layerSpacing` | `number` | `50` | Vertical spacing between layers |
+| `padding` | `number` | `20` | Padding around the graph |
+| `considerEdges` | `boolean` | `true` | Whether edges affect layout |
+
+## Edge Types
+
+Edges can be directed (default) or bidirectional:
+
+```typescript
+const edges: LayoutEdge[] = [
+  { id: 'e1', sourceId: 'a', targetId: 'b' },                    // directed (default)
+  { id: 'e2', sourceId: 'b', targetId: 'c', type: 'directed' },  // explicitly directed
+  { id: 'e3', sourceId: 'c', targetId: 'd', type: 'bidirectional' }, // two-way
+];
+```
+
+## Custom Layout Engine
+
+You can provide a custom layout engine by implementing the `LayoutEngine` interface:
+
+```typescript
+import { LAYOUT_ENGINE, LayoutEngine, LayoutInput, LayoutResult } from '@ngx-km/layout';
+
+class CustomLayoutEngine implements LayoutEngine {
+  readonly name = 'Custom';
+
+  async calculateLayout(input: LayoutInput): Promise<LayoutResult> {
+    // Your custom layout logic
+  }
+
+  dispose?(): void {
+    // Optional cleanup
+  }
+}
+
+// Provide in component or module
+providers: [
+  LayoutService,
+  { provide: LAYOUT_ENGINE, useClass: CustomLayoutEngine }
+]
+```
+
+## API Reference
+
+### LayoutService Methods
+
+| Method | Description |
+|--------|-------------|
+| `calculateLayout(input)` | Calculate layout from LayoutInput object |
+| `layout(nodes, edges, options?)` | Convenience method with separate parameters |
+| `calculateLayoutMap(input)` | Returns Map of node ID to position |
+| `recalculateLayout(nodes, edges, existingPositions, options?)` | Recalculate with position preservation |
+| `addNodesToLayout(previousResult, newNodes, allEdges, options?)` | Add nodes incrementally |
+| `removeNodesFromLayout(previousResult, nodeIds, allEdges, options?, preservePositions?)` | Remove nodes |
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `LayoutNode` | Input node with id, width, height, optional fixedX/fixedY |
+| `LayoutEdge` | Edge with id, sourceId, targetId, optional type |
+| `LayoutOptions` | Configuration for layout algorithm |
+| `LayoutResult` | Output with positioned nodes and graph dimensions |
+| `LayoutNodeResult` | Positioned node with x, y coordinates |
+| `LayoutEngine` | Interface for custom layout engines |
+
+## Running unit tests
+
+```bash
+nx test ngx-layout
+```

package/fesm2022/ngx-km-layout.mjs

@@ -0,0 +1,429 @@
+import ELK from 'elkjs/lib/elk.bundled.js';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable } from '@angular/core';
+
+/**
+ * Layout Library Models
+ *
+ * These interfaces are engine-agnostic and define the contract
+ * for any layout engine implementation (ELK, dagre, etc.)
+ */
+/**
+ * Default layout options
+ */
+const DEFAULT_LAYOUT_OPTIONS = {
+    algorithm: 'layered',
+    direction: 'DOWN',
+    nodeSpacing: 50,
+    layerSpacing: 50,
+    padding: 20,
+    considerEdges: true,
+};
+
+/**
+ * ELK algorithm identifiers
+ * Maps our abstract algorithm types to ELK-specific algorithm IDs
+ */
+const ELK_ALGORITHMS = {
+    layered: 'layered',
+    force: 'force',
+    stress: 'stress',
+    radial: 'radial',
+    tree: 'mrtree',
+};
+/**
+ * ELK direction values
+ * Maps our direction type to ELK-specific direction values
+ */
+const ELK_DIRECTIONS = {
+    DOWN: 'DOWN',
+    UP: 'UP',
+    RIGHT: 'RIGHT',
+    LEFT: 'LEFT',
+};
+/**
+ * ELK.js layout engine implementation
+ *
+ * Uses ELK.js (Eclipse Layout Kernel) for graph layout calculation.
+ * This is a high-quality layout library that supports multiple algorithms.
+ */
+class ElkLayoutEngine {
+    name = 'ELK';
+    elk;
+    constructor() {
+        this.elk = new ELK();
+    }
+    async calculateLayout(input) {
+        const options = { ...DEFAULT_LAYOUT_OPTIONS, ...input.options };
+        // Build ELK graph structure
+        const elkGraph = this.buildElkGraph(input, options);
+        // Calculate layout
+        const layoutedGraph = await this.elk.layout(elkGraph);
+        // Extract results
+        return this.extractResults(layoutedGraph);
+    }
+    dispose() {
+        // ELK doesn't require explicit cleanup, but we provide
+        // this method for consistency with the interface
+    }
+    /**
+     * Convert our abstract input to ELK-specific graph structure
+     */
+    buildElkGraph(input, options) {
+        const elkOptions = this.buildElkOptions(options);
+        // Build nodes
+        const children = input.nodes.map((node) => {
+            const elkNode = {
+                id: node.id,
+                width: node.width,
+                height: node.height,
+            };
+            // Handle fixed positions
+            if (node.fixedX !== undefined && node.fixedY !== undefined) {
+                elkNode.x = node.fixedX;
+                elkNode.y = node.fixedY;
+                // Mark as fixed in ELK
+                elkNode.layoutOptions = {
+                    'elk.position': `(${node.fixedX}, ${node.fixedY})`,
+                };
+            }
+            return elkNode;
+        });
+        // Build edges (handling bidirectional edges)
+        const edges = options.considerEdges
+            ? this.buildElkEdges(input.edges)
+            : [];
+        return {
+            id: 'root',
+            layoutOptions: elkOptions,
+            children,
+            edges,
+        };
+    }
+    /**
+     * Convert layout edges to ELK edges, expanding bidirectional edges
+     */
+    buildElkEdges(edges) {
+        const elkEdges = [];
+        for (const edge of edges) {
+            // Add the primary edge (source → target)
+            elkEdges.push({
+                id: edge.id,
+                sources: [edge.sourceId],
+                targets: [edge.targetId],
+            });
+            // For bidirectional edges, add reverse edge (target → source)
+            if (edge.type === 'bidirectional') {
+                elkEdges.push({
+                    id: `${edge.id}_reverse`,
+                    sources: [edge.targetId],
+                    targets: [edge.sourceId],
+                });
+            }
+        }
+        return elkEdges;
+    }
+    /**
+     * Convert our abstract options to ELK-specific layout options
+     */
+    buildElkOptions(options) {
+        const elkOptions = {
+            'elk.algorithm': ELK_ALGORITHMS[options.algorithm],
+            'elk.spacing.nodeNode': String(options.nodeSpacing),
+            'elk.padding': `[top=${options.padding}, left=${options.padding}, bottom=${options.padding}, right=${options.padding}]`,
+        };
+        // Algorithm-specific options
+        switch (options.algorithm) {
+            case 'layered':
+                elkOptions['elk.direction'] = ELK_DIRECTIONS[options.direction];
+                elkOptions['elk.layered.spacing.nodeNodeBetweenLayers'] = String(options.layerSpacing);
+                // Improve edge routing
+                elkOptions['elk.layered.spacing.edgeNodeBetweenLayers'] = String(options.layerSpacing / 2);
+                break;
+            case 'tree':
+                elkOptions['elk.direction'] = ELK_DIRECTIONS[options.direction];
+                elkOptions['elk.mrtree.weighting'] = 'CONSTRAINT';
+                break;
+            case 'force':
+                // Force-directed doesn't use direction
+                elkOptions['elk.force.iterations'] = '300';
+                break;
+            case 'stress':
+                // Stress-based layout options
+                elkOptions['elk.stress.desiredEdgeLength'] = String(options.nodeSpacing * 2);
+                break;
+            case 'radial':
+                // Radial layout options
+                elkOptions['elk.radial.radius'] = String(options.layerSpacing);
+                break;
+        }
+        return elkOptions;
+    }
+    /**
+     * Extract layout results from ELK's output
+     */
+    extractResults(elkGraph) {
+        const nodes = (elkGraph.children || []).map((child) => ({
+            id: child.id,
+            x: child.x ?? 0,
+            y: child.y ?? 0,
+            width: child.width ?? 0,
+            height: child.height ?? 0,
+        }));
+        return {
+            nodes,
+            width: elkGraph.width ?? 0,
+            height: elkGraph.height ?? 0,
+        };
+    }
+}
+
+/**
+ * Injection token for providing a custom layout engine
+ * Use this to swap the default ELK engine with a different implementation
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   { provide: LAYOUT_ENGINE, useClass: CustomLayoutEngine }
+ * ]
+ * ```
+ */
+const LAYOUT_ENGINE = new InjectionToken('LAYOUT_ENGINE');
+/**
+ * Factory function to create the default layout engine
+ */
+function defaultLayoutEngineFactory() {
+    return new ElkLayoutEngine();
+}
+/**
+ * Layout Service
+ *
+ * Provides graph layout calculation using a pluggable layout engine.
+ * By default uses ELK.js, but can be configured to use any engine
+ * that implements the LayoutEngine interface.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const result = await layoutService.calculateLayout({
+ *   nodes: [
+ *     { id: 'a', width: 100, height: 50 },
+ *     { id: 'b', width: 100, height: 50 },
+ *   ],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' }
+ *   ],
+ *   options: { algorithm: 'layered', direction: 'DOWN' }
+ * });
+ * ```
+ */
+class LayoutService {
+    engine;
+    constructor() {
+        // Try to inject a custom engine, fall back to default ELK engine
+        const injectedEngine = inject(LAYOUT_ENGINE, { optional: true });
+        this.engine = injectedEngine ?? defaultLayoutEngineFactory();
+    }
+    /**
+     * Get the name of the current layout engine
+     */
+    get engineName() {
+        return this.engine.name;
+    }
+    /**
+     * Calculate layout positions for nodes based on their relationships
+     *
+     * @param input Layout input containing nodes, edges, and options
+     * @returns Promise resolving to layout result with positioned nodes
+     */
+    async calculateLayout(input) {
+        // Validate input
+        this.validateInput(input);
+        return this.engine.calculateLayout(input);
+    }
+    /**
+     * Convenience method to calculate layout from separate parameters
+     *
+     * @param nodes Nodes to layout
+     * @param edges Edges/relationships between nodes
+     * @param options Layout options
+     * @returns Promise resolving to layout result
+     */
+    async layout(nodes, edges, options) {
+        return this.calculateLayout({ nodes, edges, options });
+    }
+    /**
+     * Calculate layout and return a map of node positions by ID
+     * Useful for quick position lookups
+     *
+     * @param input Layout input
+     * @returns Promise resolving to a Map of node ID to position
+     */
+    async calculateLayoutMap(input) {
+        const result = await this.calculateLayout(input);
+        const positionMap = new Map();
+        for (const node of result.nodes) {
+            positionMap.set(node.id, { x: node.x, y: node.y });
+        }
+        return positionMap;
+    }
+    /**
+     * Recalculate layout while preserving positions of existing nodes
+     *
+     * This is useful when adding new nodes to an existing layout.
+     * Existing nodes will keep their positions (as fixed points),
+     * and only new nodes will be positioned by the layout algorithm.
+     *
+     * @param nodes All nodes (existing + new)
+     * @param edges All edges
+     * @param existingPositions Map of existing node IDs to their positions
+     * @param options Layout options
+     * @returns Promise resolving to layout result
+     *
+     * @example
+     * ```typescript
+     * // Add a new node to existing layout
+     * const newNodes = [...existingNodes, { id: 'new', width: 100, height: 50 }];
+     * const result = await layoutService.recalculateLayout(
+     *   newNodes,
+     *   edges,
+     *   existingPositions, // Map from previous layout
+     *   options
+     * );
+     * ```
+     */
+    async recalculateLayout(nodes, edges, existingPositions, options) {
+        // Apply fixed positions to existing nodes
+        const nodesWithFixedPositions = nodes.map((node) => {
+            const existingPos = existingPositions.get(node.id);
+            if (existingPos) {
+                return {
+                    ...node,
+                    fixedX: existingPos.x,
+                    fixedY: existingPos.y,
+                };
+            }
+            return node;
+        });
+        return this.calculateLayout({
+            nodes: nodesWithFixedPositions,
+            edges,
+            options,
+        });
+    }
+    /**
+     * Calculate incremental layout for new nodes only
+     *
+     * Takes a previous layout result and adds new nodes to it.
+     * Existing nodes keep their positions, new nodes are positioned.
+     *
+     * @param previousResult Previous layout result
+     * @param newNodes New nodes to add
+     * @param allEdges All edges (including edges for new nodes)
+     * @param options Layout options
+     * @returns Promise resolving to updated layout result
+     */
+    async addNodesToLayout(previousResult, newNodes, allEdges, options) {
+        // Build position map from previous result
+        const existingPositions = new Map();
+        for (const node of previousResult.nodes) {
+            existingPositions.set(node.id, { x: node.x, y: node.y });
+        }
+        // Combine existing nodes (with dimensions) and new nodes
+        const existingNodes = previousResult.nodes.map((n) => ({
+            id: n.id,
+            width: n.width,
+            height: n.height,
+        }));
+        const allNodes = [...existingNodes, ...newNodes];
+        return this.recalculateLayout(allNodes, allEdges, existingPositions, options);
+    }
+    /**
+     * Remove nodes from layout and recalculate
+     *
+     * Removes specified nodes and their connected edges,
+     * then recalculates layout for remaining nodes.
+     *
+     * @param previousResult Previous layout result
+     * @param nodeIdsToRemove IDs of nodes to remove
+     * @param allEdges All edges (will be filtered to remove orphaned edges)
+     * @param options Layout options
+     * @param preservePositions If true, remaining nodes keep their positions
+     * @returns Promise resolving to updated layout result
+     */
+    async removeNodesFromLayout(previousResult, nodeIdsToRemove, allEdges, options, preservePositions = true) {
+        const removeSet = new Set(nodeIdsToRemove);
+        // Filter out removed nodes
+        const remainingNodes = previousResult.nodes
+            .filter((n) => !removeSet.has(n.id))
+            .map((n) => ({
+            id: n.id,
+            width: n.width,
+            height: n.height,
+        }));
+        // Filter out edges connected to removed nodes
+        const remainingEdges = allEdges.filter((e) => !removeSet.has(e.sourceId) && !removeSet.has(e.targetId));
+        if (remainingNodes.length === 0) {
+            return { nodes: [], width: 0, height: 0 };
+        }
+        if (preservePositions) {
+            const existingPositions = new Map();
+            for (const node of previousResult.nodes) {
+                if (!removeSet.has(node.id)) {
+                    existingPositions.set(node.id, { x: node.x, y: node.y });
+                }
+            }
+            return this.recalculateLayout(remainingNodes, remainingEdges, existingPositions, options);
+        }
+        return this.calculateLayout({
+            nodes: remainingNodes,
+            edges: remainingEdges,
+            options,
+        });
+    }
+    ngOnDestroy() {
+        this.engine.dispose?.();
+    }
+    /**
+     * Validate layout input
+     */
+    validateInput(input) {
+        if (!input.nodes || input.nodes.length === 0) {
+            throw new Error('LayoutService: At least one node is required');
+        }
+        // Check for duplicate node IDs
+        const nodeIds = new Set();
+        for (const node of input.nodes) {
+            if (nodeIds.has(node.id)) {
+                throw new Error(`LayoutService: Duplicate node ID "${node.id}"`);
+            }
+            nodeIds.add(node.id);
+        }
+        // Validate edges reference existing nodes
+        if (input.edges) {
+            for (const edge of input.edges) {
+                if (!nodeIds.has(edge.sourceId)) {
+                    throw new Error(`LayoutService: Edge "${edge.id}" references unknown source node "${edge.sourceId}"`);
+                }
+                if (!nodeIds.has(edge.targetId)) {
+                    throw new Error(`LayoutService: Edge "${edge.id}" references unknown target node "${edge.targetId}"`);
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: LayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: LayoutService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: LayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+// Models - Values
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_LAYOUT_OPTIONS, ElkLayoutEngine, LAYOUT_ENGINE, LayoutService, defaultLayoutEngineFactory };
+//# sourceMappingURL=ngx-km-layout.mjs.map

package/fesm2022/ngx-km-layout.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-km-layout.mjs","sources":["../../../../libs/ngx-km-layout/src/lib/models/layout.models.ts","../../../../libs/ngx-km-layout/src/lib/engines/elk-layout-engine.ts","../../../../libs/ngx-km-layout/src/lib/services/layout.service.ts","../../../../libs/ngx-km-layout/src/index.ts","../../../../libs/ngx-km-layout/src/ngx-km-layout.ts"],"sourcesContent":["/**\n * Layout Library Models\n *\n * These interfaces are engine-agnostic and define the contract\n * for any layout engine implementation (ELK, dagre, etc.)\n */\n\n/**\n * Direction for hierarchical/layered layouts\n */\nexport type LayoutDirection = 'DOWN' | 'UP' | 'RIGHT' | 'LEFT';\n\n/**\n * Available layout algorithm types\n * These are abstract algorithm categories that map to specific engine implementations\n */\nexport type LayoutAlgorithm =\n  | 'layered' // Hierarchical/layered layout (Sugiyama-style)\n  | 'force' // Force-directed layout\n  | 'stress' // Stress-minimization layout\n  | 'radial' // Radial tree layout\n  | 'tree'; // Simple tree layout\n\n/**\n * Input node definition for layout calculation\n */\nexport interface LayoutNode {\n  /** Unique identifier for the node */\n  id: string;\n  /** Width of the node in pixels */\n  width: number;\n  /** Height of the node in pixels */\n  height: number;\n  /** Optional: Fixed X position (node won't be moved if set) */\n  fixedX?: number;\n  /** Optional: Fixed Y position (node won't be moved if set) */\n  fixedY?: number;\n}\n\n/**\n * Edge type for layout calculation\n * - 'directed': One-way relationship (source → target)\n * - 'bidirectional': Two-way relationship (source ↔ target)\n */\nexport type EdgeType = 'directed' | 'bidirectional';\n\n/**\n * Edge/relationship between nodes for layout calculation\n */\nexport interface LayoutEdge {\n  /** Unique identifier for the edge */\n  id: string;\n  /** Source node ID */\n  sourceId: string;\n  /** Target node ID */\n  targetId: string;\n  /** Edge type (default: 'directed') */\n  type?: EdgeType;\n}\n\n/**\n * Configuration options for layout calculation\n */\nexport interface LayoutOptions {\n  /** Layout algorithm to use (default: 'layered') */\n  algorithm?: LayoutAlgorithm;\n\n  /** Direction for hierarchical layouts (default: 'DOWN') */\n  direction?: LayoutDirection;\n\n  /** Horizontal spacing between nodes in pixels (default: 50) */\n  nodeSpacing?: number;\n\n  /** Vertical spacing between layers in pixels (default: 50) */\n  layerSpacing?: number;\n\n  /** Padding around the entire graph in pixels (default: 20) */\n  padding?: number;\n\n  /** Whether edges should be considered for layout (default: true) */\n  considerEdges?: boolean;\n}\n\n/**\n * Result of layout calculation for a single node\n */\nexport interface LayoutNodeResult {\n  /** Node ID */\n  id: string;\n  /** Calculated X position (top-left corner) */\n  x: number;\n  /** Calculated Y position (top-left corner) */\n  y: number;\n  /** Node width (same as input) */\n  width: number;\n  /** Node height (same as input) */\n  height: number;\n}\n\n/**\n * Complete result of layout calculation\n */\nexport interface LayoutResult {\n  /** Positioned nodes */\n  nodes: LayoutNodeResult[];\n  /** Total width of the laid out graph */\n  width: number;\n  /** Total height of the laid out graph */\n  height: number;\n}\n\n/**\n * Input data for layout calculation\n */\nexport interface LayoutInput {\n  /** Nodes to layout */\n  nodes: LayoutNode[];\n  /** Edges/relationships between nodes */\n  edges: LayoutEdge[];\n  /** Layout options */\n  options?: LayoutOptions;\n}\n\n/**\n * Default layout options\n */\nexport const DEFAULT_LAYOUT_OPTIONS: Required<LayoutOptions> = {\n  algorithm: 'layered',\n  direction: 'DOWN',\n  nodeSpacing: 50,\n  layerSpacing: 50,\n  padding: 20,\n  considerEdges: true,\n};\n","import ELK, { ElkNode, ElkExtendedEdge, LayoutOptions as ElkLayoutOptions } from 'elkjs/lib/elk.bundled.js';\nimport { LayoutEngine } from './layout-engine';\nimport {\n  LayoutInput,\n  LayoutResult,\n  LayoutNodeResult,\n  LayoutOptions,\n  LayoutAlgorithm,\n  LayoutDirection,\n  LayoutEdge,\n  DEFAULT_LAYOUT_OPTIONS,\n} from '../models/layout.models';\n\n/**\n * ELK algorithm identifiers\n * Maps our abstract algorithm types to ELK-specific algorithm IDs\n */\nconst ELK_ALGORITHMS: Record<LayoutAlgorithm, string> = {\n  layered: 'layered',\n  force: 'force',\n  stress: 'stress',\n  radial: 'radial',\n  tree: 'mrtree',\n};\n\n/**\n * ELK direction values\n * Maps our direction type to ELK-specific direction values\n */\nconst ELK_DIRECTIONS: Record<LayoutDirection, string> = {\n  DOWN: 'DOWN',\n  UP: 'UP',\n  RIGHT: 'RIGHT',\n  LEFT: 'LEFT',\n};\n\n/**\n * ELK.js layout engine implementation\n *\n * Uses ELK.js (Eclipse Layout Kernel) for graph layout calculation.\n * This is a high-quality layout library that supports multiple algorithms.\n */\nexport class ElkLayoutEngine implements LayoutEngine {\n  readonly name = 'ELK';\n\n  private elk: InstanceType<typeof ELK>;\n\n  constructor() {\n    this.elk = new ELK();\n  }\n\n  async calculateLayout(input: LayoutInput): Promise<LayoutResult> {\n    const options = { ...DEFAULT_LAYOUT_OPTIONS, ...input.options };\n\n    // Build ELK graph structure\n    const elkGraph = this.buildElkGraph(input, options);\n\n    // Calculate layout\n    const layoutedGraph = await this.elk.layout(elkGraph);\n\n    // Extract results\n    return this.extractResults(layoutedGraph);\n  }\n\n  dispose(): void {\n    // ELK doesn't require explicit cleanup, but we provide\n    // this method for consistency with the interface\n  }\n\n  /**\n   * Convert our abstract input to ELK-specific graph structure\n   */\n  private buildElkGraph(\n    input: LayoutInput,\n    options: Required<LayoutOptions>\n  ): ElkNode {\n    const elkOptions = this.buildElkOptions(options);\n\n    // Build nodes\n    const children: ElkNode[] = input.nodes.map((node) => {\n      const elkNode: ElkNode = {\n        id: node.id,\n        width: node.width,\n        height: node.height,\n      };\n\n      // Handle fixed positions\n      if (node.fixedX !== undefined && node.fixedY !== undefined) {\n        elkNode.x = node.fixedX;\n        elkNode.y = node.fixedY;\n        // Mark as fixed in ELK\n        elkNode.layoutOptions = {\n          'elk.position': `(${node.fixedX}, ${node.fixedY})`,\n        };\n      }\n\n      return elkNode;\n    });\n\n    // Build edges (handling bidirectional edges)\n    const edges: ElkExtendedEdge[] = options.considerEdges\n      ? this.buildElkEdges(input.edges)\n      : [];\n\n    return {\n      id: 'root',\n      layoutOptions: elkOptions,\n      children,\n      edges,\n    };\n  }\n\n  /**\n   * Convert layout edges to ELK edges, expanding bidirectional edges\n   */\n  private buildElkEdges(edges: LayoutEdge[]): ElkExtendedEdge[] {\n    const elkEdges: ElkExtendedEdge[] = [];\n\n    for (const edge of edges) {\n      // Add the primary edge (source → target)\n      elkEdges.push({\n        id: edge.id,\n        sources: [edge.sourceId],\n        targets: [edge.targetId],\n      });\n\n      // For bidirectional edges, add reverse edge (target → source)\n      if (edge.type === 'bidirectional') {\n        elkEdges.push({\n          id: `${edge.id}_reverse`,\n          sources: [edge.targetId],\n          targets: [edge.sourceId],\n        });\n      }\n    }\n\n    return elkEdges;\n  }\n\n  /**\n   * Convert our abstract options to ELK-specific layout options\n   */\n  private buildElkOptions(options: Required<LayoutOptions>): ElkLayoutOptions {\n    const elkOptions: ElkLayoutOptions = {\n      'elk.algorithm': ELK_ALGORITHMS[options.algorithm],\n      'elk.spacing.nodeNode': String(options.nodeSpacing),\n      'elk.padding': `[top=${options.padding}, left=${options.padding}, bottom=${options.padding}, right=${options.padding}]`,\n    };\n\n    // Algorithm-specific options\n    switch (options.algorithm) {\n      case 'layered':\n        elkOptions['elk.direction'] = ELK_DIRECTIONS[options.direction];\n        elkOptions['elk.layered.spacing.nodeNodeBetweenLayers'] = String(\n          options.layerSpacing\n        );\n        // Improve edge routing\n        elkOptions['elk.layered.spacing.edgeNodeBetweenLayers'] = String(\n          options.layerSpacing / 2\n        );\n        break;\n\n      case 'tree':\n        elkOptions['elk.direction'] = ELK_DIRECTIONS[options.direction];\n        elkOptions['elk.mrtree.weighting'] = 'CONSTRAINT';\n        break;\n\n      case 'force':\n        // Force-directed doesn't use direction\n        elkOptions['elk.force.iterations'] = '300';\n        break;\n\n      case 'stress':\n        // Stress-based layout options\n        elkOptions['elk.stress.desiredEdgeLength'] = String(\n          options.nodeSpacing * 2\n        );\n        break;\n\n      case 'radial':\n        // Radial layout options\n        elkOptions['elk.radial.radius'] = String(options.layerSpacing);\n        break;\n    }\n\n    return elkOptions;\n  }\n\n  /**\n   * Extract layout results from ELK's output\n   */\n  private extractResults(elkGraph: ElkNode): LayoutResult {\n    const nodes: LayoutNodeResult[] = (elkGraph.children || []).map((child) => ({\n      id: child.id,\n      x: child.x ?? 0,\n      y: child.y ?? 0,\n      width: child.width ?? 0,\n      height: child.height ?? 0,\n    }));\n\n    return {\n      nodes,\n      width: elkGraph.width ?? 0,\n      height: elkGraph.height ?? 0,\n    };\n  }\n}\n","import { Injectable, InjectionToken, inject, OnDestroy } from '@angular/core';\nimport { LayoutEngine } from '../engines/layout-engine';\nimport { ElkLayoutEngine } from '../engines/elk-layout-engine';\nimport {\n  LayoutInput,\n  LayoutResult,\n  LayoutNode,\n  LayoutNodeResult,\n  LayoutEdge,\n  LayoutOptions,\n} from '../models/layout.models';\n\n/**\n * Injection token for providing a custom layout engine\n * Use this to swap the default ELK engine with a different implementation\n *\n * @example\n * ```typescript\n * providers: [\n *   { provide: LAYOUT_ENGINE, useClass: CustomLayoutEngine }\n * ]\n * ```\n */\nexport const LAYOUT_ENGINE = new InjectionToken<LayoutEngine>('LAYOUT_ENGINE');\n\n/**\n * Factory function to create the default layout engine\n */\nexport function defaultLayoutEngineFactory(): LayoutEngine {\n  return new ElkLayoutEngine();\n}\n\n/**\n * Layout Service\n *\n * Provides graph layout calculation using a pluggable layout engine.\n * By default uses ELK.js, but can be configured to use any engine\n * that implements the LayoutEngine interface.\n *\n * @example\n * ```typescript\n * // Basic usage\n * const result = await layoutService.calculateLayout({\n *   nodes: [\n *     { id: 'a', width: 100, height: 50 },\n *     { id: 'b', width: 100, height: 50 },\n *   ],\n *   edges: [\n *     { id: 'e1', sourceId: 'a', targetId: 'b' }\n *   ],\n *   options: { algorithm: 'layered', direction: 'DOWN' }\n * });\n * ```\n */\n@Injectable()\nexport class LayoutService implements OnDestroy {\n  private engine: LayoutEngine;\n\n  constructor() {\n    // Try to inject a custom engine, fall back to default ELK engine\n    const injectedEngine = inject(LAYOUT_ENGINE, { optional: true });\n    this.engine = injectedEngine ?? defaultLayoutEngineFactory();\n  }\n\n  /**\n   * Get the name of the current layout engine\n   */\n  get engineName(): string {\n    return this.engine.name;\n  }\n\n  /**\n   * Calculate layout positions for nodes based on their relationships\n   *\n   * @param input Layout input containing nodes, edges, and options\n   * @returns Promise resolving to layout result with positioned nodes\n   */\n  async calculateLayout(input: LayoutInput): Promise<LayoutResult> {\n    // Validate input\n    this.validateInput(input);\n\n    return this.engine.calculateLayout(input);\n  }\n\n  /**\n   * Convenience method to calculate layout from separate parameters\n   *\n   * @param nodes Nodes to layout\n   * @param edges Edges/relationships between nodes\n   * @param options Layout options\n   * @returns Promise resolving to layout result\n   */\n  async layout(\n    nodes: LayoutNode[],\n    edges: LayoutEdge[],\n    options?: LayoutOptions\n  ): Promise<LayoutResult> {\n    return this.calculateLayout({ nodes, edges, options });\n  }\n\n  /**\n   * Calculate layout and return a map of node positions by ID\n   * Useful for quick position lookups\n   *\n   * @param input Layout input\n   * @returns Promise resolving to a Map of node ID to position\n   */\n  async calculateLayoutMap(\n    input: LayoutInput\n  ): Promise<Map<string, { x: number; y: number }>> {\n    const result = await this.calculateLayout(input);\n\n    const positionMap = new Map<string, { x: number; y: number }>();\n    for (const node of result.nodes) {\n      positionMap.set(node.id, { x: node.x, y: node.y });\n    }\n\n    return positionMap;\n  }\n\n  /**\n   * Recalculate layout while preserving positions of existing nodes\n   *\n   * This is useful when adding new nodes to an existing layout.\n   * Existing nodes will keep their positions (as fixed points),\n   * and only new nodes will be positioned by the layout algorithm.\n   *\n   * @param nodes All nodes (existing + new)\n   * @param edges All edges\n   * @param existingPositions Map of existing node IDs to their positions\n   * @param options Layout options\n   * @returns Promise resolving to layout result\n   *\n   * @example\n   * ```typescript\n   * // Add a new node to existing layout\n   * const newNodes = [...existingNodes, { id: 'new', width: 100, height: 50 }];\n   * const result = await layoutService.recalculateLayout(\n   *   newNodes,\n   *   edges,\n   *   existingPositions, // Map from previous layout\n   *   options\n   * );\n   * ```\n   */\n  async recalculateLayout(\n    nodes: LayoutNode[],\n    edges: LayoutEdge[],\n    existingPositions: Map<string, { x: number; y: number }>,\n    options?: LayoutOptions\n  ): Promise<LayoutResult> {\n    // Apply fixed positions to existing nodes\n    const nodesWithFixedPositions = nodes.map((node) => {\n      const existingPos = existingPositions.get(node.id);\n      if (existingPos) {\n        return {\n          ...node,\n          fixedX: existingPos.x,\n          fixedY: existingPos.y,\n        };\n      }\n      return node;\n    });\n\n    return this.calculateLayout({\n      nodes: nodesWithFixedPositions,\n      edges,\n      options,\n    });\n  }\n\n  /**\n   * Calculate incremental layout for new nodes only\n   *\n   * Takes a previous layout result and adds new nodes to it.\n   * Existing nodes keep their positions, new nodes are positioned.\n   *\n   * @param previousResult Previous layout result\n   * @param newNodes New nodes to add\n   * @param allEdges All edges (including edges for new nodes)\n   * @param options Layout options\n   * @returns Promise resolving to updated layout result\n   */\n  async addNodesToLayout(\n    previousResult: LayoutResult,\n    newNodes: LayoutNode[],\n    allEdges: LayoutEdge[],\n    options?: LayoutOptions\n  ): Promise<LayoutResult> {\n    // Build position map from previous result\n    const existingPositions = new Map<string, { x: number; y: number }>();\n    for (const node of previousResult.nodes) {\n      existingPositions.set(node.id, { x: node.x, y: node.y });\n    }\n\n    // Combine existing nodes (with dimensions) and new nodes\n    const existingNodes: LayoutNode[] = previousResult.nodes.map((n) => ({\n      id: n.id,\n      width: n.width,\n      height: n.height,\n    }));\n\n    const allNodes = [...existingNodes, ...newNodes];\n\n    return this.recalculateLayout(allNodes, allEdges, existingPositions, options);\n  }\n\n  /**\n   * Remove nodes from layout and recalculate\n   *\n   * Removes specified nodes and their connected edges,\n   * then recalculates layout for remaining nodes.\n   *\n   * @param previousResult Previous layout result\n   * @param nodeIdsToRemove IDs of nodes to remove\n   * @param allEdges All edges (will be filtered to remove orphaned edges)\n   * @param options Layout options\n   * @param preservePositions If true, remaining nodes keep their positions\n   * @returns Promise resolving to updated layout result\n   */\n  async removeNodesFromLayout(\n    previousResult: LayoutResult,\n    nodeIdsToRemove: string[],\n    allEdges: LayoutEdge[],\n    options?: LayoutOptions,\n    preservePositions = true\n  ): Promise<LayoutResult> {\n    const removeSet = new Set(nodeIdsToRemove);\n\n    // Filter out removed nodes\n    const remainingNodes: LayoutNode[] = previousResult.nodes\n      .filter((n) => !removeSet.has(n.id))\n      .map((n) => ({\n        id: n.id,\n        width: n.width,\n        height: n.height,\n      }));\n\n    // Filter out edges connected to removed nodes\n    const remainingEdges = allEdges.filter(\n      (e) => !removeSet.has(e.sourceId) && !removeSet.has(e.targetId)\n    );\n\n    if (remainingNodes.length === 0) {\n      return { nodes: [], width: 0, height: 0 };\n    }\n\n    if (preservePositions) {\n      const existingPositions = new Map<string, { x: number; y: number }>();\n      for (const node of previousResult.nodes) {\n        if (!removeSet.has(node.id)) {\n          existingPositions.set(node.id, { x: node.x, y: node.y });\n        }\n      }\n      return this.recalculateLayout(\n        remainingNodes,\n        remainingEdges,\n        existingPositions,\n        options\n      );\n    }\n\n    return this.calculateLayout({\n      nodes: remainingNodes,\n      edges: remainingEdges,\n      options,\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.engine.dispose?.();\n  }\n\n  /**\n   * Validate layout input\n   */\n  private validateInput(input: LayoutInput): void {\n    if (!input.nodes || input.nodes.length === 0) {\n      throw new Error('LayoutService: At least one node is required');\n    }\n\n    // Check for duplicate node IDs\n    const nodeIds = new Set<string>();\n    for (const node of input.nodes) {\n      if (nodeIds.has(node.id)) {\n        throw new Error(`LayoutService: Duplicate node ID \"${node.id}\"`);\n      }\n      nodeIds.add(node.id);\n    }\n\n    // Validate edges reference existing nodes\n    if (input.edges) {\n      for (const edge of input.edges) {\n        if (!nodeIds.has(edge.sourceId)) {\n          throw new Error(\n            `LayoutService: Edge \"${edge.id}\" references unknown source node \"${edge.sourceId}\"`\n          );\n        }\n        if (!nodeIds.has(edge.targetId)) {\n          throw new Error(\n            `LayoutService: Edge \"${edge.id}\" references unknown target node \"${edge.targetId}\"`\n          );\n        }\n      }\n    }\n  }\n}\n","// Models - Types\nexport type {\n  LayoutDirection,\n  LayoutAlgorithm,\n  EdgeType,\n  LayoutNode,\n  LayoutEdge,\n  LayoutOptions,\n  LayoutNodeResult,\n  LayoutResult,\n  LayoutInput,\n} from './lib/models/layout.models';\n\n// Models - Values\nexport { DEFAULT_LAYOUT_OPTIONS } from './lib/models/layout.models';\n\n// Engine abstraction (for custom engine implementations)\nexport type { LayoutEngine } from './lib/engines/layout-engine';\nexport { ElkLayoutEngine } from './lib/engines/elk-layout-engine';\n\n// Service\nexport {\n  LayoutService,\n  LAYOUT_ENGINE,\n  defaultLayoutEngineFactory,\n} from './lib/services/layout.service';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,305 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, InjectionToken } from '@angular/core';
+
+/**
+ * Layout Library Models
+ *
+ * These interfaces are engine-agnostic and define the contract
+ * for any layout engine implementation (ELK, dagre, etc.)
+ */
+/**
+ * Direction for hierarchical/layered layouts
+ */
+type LayoutDirection = 'DOWN' | 'UP' | 'RIGHT' | 'LEFT';
+/**
+ * Available layout algorithm types
+ * These are abstract algorithm categories that map to specific engine implementations
+ */
+type LayoutAlgorithm = 'layered' | 'force' | 'stress' | 'radial' | 'tree';
+/**
+ * Input node definition for layout calculation
+ */
+interface LayoutNode {
+    /** Unique identifier for the node */
+    id: string;
+    /** Width of the node in pixels */
+    width: number;
+    /** Height of the node in pixels */
+    height: number;
+    /** Optional: Fixed X position (node won't be moved if set) */
+    fixedX?: number;
+    /** Optional: Fixed Y position (node won't be moved if set) */
+    fixedY?: number;
+}
+/**
+ * Edge type for layout calculation
+ * - 'directed': One-way relationship (source → target)
+ * - 'bidirectional': Two-way relationship (source ↔ target)
+ */
+type EdgeType = 'directed' | 'bidirectional';
+/**
+ * Edge/relationship between nodes for layout calculation
+ */
+interface LayoutEdge {
+    /** Unique identifier for the edge */
+    id: string;
+    /** Source node ID */
+    sourceId: string;
+    /** Target node ID */
+    targetId: string;
+    /** Edge type (default: 'directed') */
+    type?: EdgeType;
+}
+/**
+ * Configuration options for layout calculation
+ */
+interface LayoutOptions {
+    /** Layout algorithm to use (default: 'layered') */
+    algorithm?: LayoutAlgorithm;
+    /** Direction for hierarchical layouts (default: 'DOWN') */
+    direction?: LayoutDirection;
+    /** Horizontal spacing between nodes in pixels (default: 50) */
+    nodeSpacing?: number;
+    /** Vertical spacing between layers in pixels (default: 50) */
+    layerSpacing?: number;
+    /** Padding around the entire graph in pixels (default: 20) */
+    padding?: number;
+    /** Whether edges should be considered for layout (default: true) */
+    considerEdges?: boolean;
+}
+/**
+ * Result of layout calculation for a single node
+ */
+interface LayoutNodeResult {
+    /** Node ID */
+    id: string;
+    /** Calculated X position (top-left corner) */
+    x: number;
+    /** Calculated Y position (top-left corner) */
+    y: number;
+    /** Node width (same as input) */
+    width: number;
+    /** Node height (same as input) */
+    height: number;
+}
+/**
+ * Complete result of layout calculation
+ */
+interface LayoutResult {
+    /** Positioned nodes */
+    nodes: LayoutNodeResult[];
+    /** Total width of the laid out graph */
+    width: number;
+    /** Total height of the laid out graph */
+    height: number;
+}
+/**
+ * Input data for layout calculation
+ */
+interface LayoutInput {
+    /** Nodes to layout */
+    nodes: LayoutNode[];
+    /** Edges/relationships between nodes */
+    edges: LayoutEdge[];
+    /** Layout options */
+    options?: LayoutOptions;
+}
+/**
+ * Default layout options
+ */
+declare const DEFAULT_LAYOUT_OPTIONS: Required<LayoutOptions>;
+
+/**
+ * Abstract layout engine interface
+ *
+ * Implement this interface to create a new layout engine.
+ * The layout service uses this abstraction to allow swapping
+ * different layout engines (ELK, dagre, etc.) without changing
+ * the consumer API.
+ */
+interface LayoutEngine {
+    /**
+     * Name of the layout engine (for debugging/logging)
+     */
+    readonly name: string;
+    /**
+     * Calculate layout positions for the given input
+     * @param input Nodes, edges, and options for layout calculation
+     * @returns Promise resolving to the layout result with node positions
+     */
+    calculateLayout(input: LayoutInput): Promise<LayoutResult>;
+    /**
+     * Optional: Clean up any resources used by the engine
+     */
+    dispose?(): void;
+}
+
+/**
+ * ELK.js layout engine implementation
+ *
+ * Uses ELK.js (Eclipse Layout Kernel) for graph layout calculation.
+ * This is a high-quality layout library that supports multiple algorithms.
+ */
+declare class ElkLayoutEngine implements LayoutEngine {
+    readonly name = "ELK";
+    private elk;
+    constructor();
+    calculateLayout(input: LayoutInput): Promise<LayoutResult>;
+    dispose(): void;
+    /**
+     * Convert our abstract input to ELK-specific graph structure
+     */
+    private buildElkGraph;
+    /**
+     * Convert layout edges to ELK edges, expanding bidirectional edges
+     */
+    private buildElkEdges;
+    /**
+     * Convert our abstract options to ELK-specific layout options
+     */
+    private buildElkOptions;
+    /**
+     * Extract layout results from ELK's output
+     */
+    private extractResults;
+}
+
+/**
+ * Injection token for providing a custom layout engine
+ * Use this to swap the default ELK engine with a different implementation
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   { provide: LAYOUT_ENGINE, useClass: CustomLayoutEngine }
+ * ]
+ * ```
+ */
+declare const LAYOUT_ENGINE: InjectionToken<LayoutEngine>;
+/**
+ * Factory function to create the default layout engine
+ */
+declare function defaultLayoutEngineFactory(): LayoutEngine;
+/**
+ * Layout Service
+ *
+ * Provides graph layout calculation using a pluggable layout engine.
+ * By default uses ELK.js, but can be configured to use any engine
+ * that implements the LayoutEngine interface.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const result = await layoutService.calculateLayout({
+ *   nodes: [
+ *     { id: 'a', width: 100, height: 50 },
+ *     { id: 'b', width: 100, height: 50 },
+ *   ],
+ *   edges: [
+ *     { id: 'e1', sourceId: 'a', targetId: 'b' }
+ *   ],
+ *   options: { algorithm: 'layered', direction: 'DOWN' }
+ * });
+ * ```
+ */
+declare class LayoutService implements OnDestroy {
+    private engine;
+    constructor();
+    /**
+     * Get the name of the current layout engine
+     */
+    get engineName(): string;
+    /**
+     * Calculate layout positions for nodes based on their relationships
+     *
+     * @param input Layout input containing nodes, edges, and options
+     * @returns Promise resolving to layout result with positioned nodes
+     */
+    calculateLayout(input: LayoutInput): Promise<LayoutResult>;
+    /**
+     * Convenience method to calculate layout from separate parameters
+     *
+     * @param nodes Nodes to layout
+     * @param edges Edges/relationships between nodes
+     * @param options Layout options
+     * @returns Promise resolving to layout result
+     */
+    layout(nodes: LayoutNode[], edges: LayoutEdge[], options?: LayoutOptions): Promise<LayoutResult>;
+    /**
+     * Calculate layout and return a map of node positions by ID
+     * Useful for quick position lookups
+     *
+     * @param input Layout input
+     * @returns Promise resolving to a Map of node ID to position
+     */
+    calculateLayoutMap(input: LayoutInput): Promise<Map<string, {
+        x: number;
+        y: number;
+    }>>;
+    /**
+     * Recalculate layout while preserving positions of existing nodes
+     *
+     * This is useful when adding new nodes to an existing layout.
+     * Existing nodes will keep their positions (as fixed points),
+     * and only new nodes will be positioned by the layout algorithm.
+     *
+     * @param nodes All nodes (existing + new)
+     * @param edges All edges
+     * @param existingPositions Map of existing node IDs to their positions
+     * @param options Layout options
+     * @returns Promise resolving to layout result
+     *
+     * @example
+     * ```typescript
+     * // Add a new node to existing layout
+     * const newNodes = [...existingNodes, { id: 'new', width: 100, height: 50 }];
+     * const result = await layoutService.recalculateLayout(
+     *   newNodes,
+     *   edges,
+     *   existingPositions, // Map from previous layout
+     *   options
+     * );
+     * ```
+     */
+    recalculateLayout(nodes: LayoutNode[], edges: LayoutEdge[], existingPositions: Map<string, {
+        x: number;
+        y: number;
+    }>, options?: LayoutOptions): Promise<LayoutResult>;
+    /**
+     * Calculate incremental layout for new nodes only
+     *
+     * Takes a previous layout result and adds new nodes to it.
+     * Existing nodes keep their positions, new nodes are positioned.
+     *
+     * @param previousResult Previous layout result
+     * @param newNodes New nodes to add
+     * @param allEdges All edges (including edges for new nodes)
+     * @param options Layout options
+     * @returns Promise resolving to updated layout result
+     */
+    addNodesToLayout(previousResult: LayoutResult, newNodes: LayoutNode[], allEdges: LayoutEdge[], options?: LayoutOptions): Promise<LayoutResult>;
+    /**
+     * Remove nodes from layout and recalculate
+     *
+     * Removes specified nodes and their connected edges,
+     * then recalculates layout for remaining nodes.
+     *
+     * @param previousResult Previous layout result
+     * @param nodeIdsToRemove IDs of nodes to remove
+     * @param allEdges All edges (will be filtered to remove orphaned edges)
+     * @param options Layout options
+     * @param preservePositions If true, remaining nodes keep their positions
+     * @returns Promise resolving to updated layout result
+     */
+    removeNodesFromLayout(previousResult: LayoutResult, nodeIdsToRemove: string[], allEdges: LayoutEdge[], options?: LayoutOptions, preservePositions?: boolean): Promise<LayoutResult>;
+    ngOnDestroy(): void;
+    /**
+     * Validate layout input
+     */
+    private validateInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+export { DEFAULT_LAYOUT_OPTIONS, ElkLayoutEngine, LAYOUT_ENGINE, LayoutService, defaultLayoutEngineFactory };
+export type { EdgeType, LayoutAlgorithm, LayoutDirection, LayoutEdge, LayoutEngine, LayoutInput, LayoutNode, LayoutNodeResult, LayoutOptions, LayoutResult };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ngx-km/layout",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": ">=19.0.0",
+    "@angular/core": ">=19.0.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ngx-km-layout.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/ngx-km-layout.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}