@xlabs-store/core 0.0.1

package/dist/collection/utils/workflow/flow.service.js

@@ -0,0 +1,382 @@
+export class FlowService {
+    nodes = [];
+    edges = [];
+    viewport = { x: 0, y: 0, zoom: 1 };
+    selectedNodeIds = [];
+    selectedEdgeIds = [];
+    nodeValues = {};
+    clipboardNodes = [];
+    clipboardEdges = [];
+    history = [];
+    historyIndex = -1;
+    listeners = [];
+    constructor(initialNodes = [], initialEdges = []) {
+        this.nodes = initialNodes;
+        this.edges = initialEdges;
+        this.saveToHistory();
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== listener);
+        };
+    }
+    notify() {
+        this.listeners.forEach(l => l());
+    }
+    forceLayout() {
+        // Basic force layout implementation or trigger
+        this.notify();
+    }
+    saveToHistory() {
+        const last = this.history[this.historyIndex];
+        if (last && JSON.stringify(last.nodes) === JSON.stringify(this.nodes) && JSON.stringify(last.edges) === JSON.stringify(this.edges))
+            return;
+        this.history = this.history.slice(0, this.historyIndex + 1);
+        this.history.push({ nodes: JSON.parse(JSON.stringify(this.nodes)), edges: JSON.parse(JSON.stringify(this.edges)) });
+        this.historyIndex = this.history.length - 1;
+        if (this.history.length > 50) {
+            this.history.shift();
+            this.historyIndex--;
+        }
+    }
+    undo() {
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            const snapshot = this.history[this.historyIndex];
+            this.nodes = JSON.parse(JSON.stringify(snapshot.nodes));
+            this.edges = JSON.parse(JSON.stringify(snapshot.edges));
+            this.notify();
+        }
+    }
+    redo() {
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            const snapshot = this.history[this.historyIndex];
+            this.nodes = JSON.parse(JSON.stringify(snapshot.nodes));
+            this.edges = JSON.parse(JSON.stringify(snapshot.edges));
+            this.notify();
+        }
+    }
+    getNodes() { return this.nodes.filter(n => this.isNodeVisible(n.id)); }
+    isNodeVisible(nodeId) {
+        const node = this.nodes.find(n => n.id === nodeId);
+        if (!node)
+            return false;
+        if (node.hidden)
+            return false;
+        let parent = this.nodes.find(n => n.id === node.parentId);
+        while (parent) {
+            if (parent.isCollapsed)
+                return false;
+            parent = this.nodes.find(n => n.id === parent.parentId);
+        }
+        return true;
+    }
+    getEdges() { return this.edges.filter(e => this.isNodeVisible(e.source) && this.isNodeVisible(e.target)); }
+    getViewport() { return this.viewport; }
+    getSelectedNodes() { return this.selectedNodeIds; }
+    getSelectedEdges() { return this.selectedEdgeIds; }
+    setNodes(nodes) {
+        // Preserve width and height if not provided in the new array, keeping the service as the source of truth for these
+        this.nodes = nodes.map(newNode => {
+            const existingNode = this.nodes.find(n => n.id === newNode.id);
+            if (existingNode) {
+                return {
+                    ...newNode,
+                    width: newNode.width || existingNode.width,
+                    height: newNode.height || existingNode.height,
+                    shape: newNode.shape || existingNode.shape
+                };
+            }
+            return newNode;
+        });
+        this.notify();
+    }
+    setEdges(edges) { this.edges = edges; this.notify(); }
+    setViewport(viewport) { this.viewport = viewport; this.notify(); }
+    updateNodeValue(nodeId, value) { this.nodeValues[nodeId] = value; this.propagate(nodeId); this.notify(); }
+    propagate(nodeId) {
+        const value = this.nodeValues[nodeId];
+        this.edges.filter(e => e.source === nodeId).forEach(edge => {
+            if (this.nodes.find(n => n.id === edge.target))
+                console.log(`Propagating from ${nodeId} to ${edge.target}:`, value);
+        });
+    }
+    addNode(node) { this.nodes = [...this.nodes, node]; this.saveToHistory(); this.notify(); }
+    updateNodePosition(nodeId, x, y, snapToGridSize = 0) {
+        const node = this.nodes.find(n => n.id === nodeId);
+        if (!node)
+            return;
+        let finalX = snapToGridSize > 0 ? Math.round(x / snapToGridSize) * snapToGridSize : x;
+        let finalY = snapToGridSize > 0 ? Math.round(y / snapToGridSize) * snapToGridSize : y;
+        // Boundary constraints for children
+        if (node.parentId) {
+            const parent = this.nodes.find(n => n.id === node.parentId);
+            if (parent) {
+                finalX = Math.max(0, Math.min(finalX, (parent.width || 400) - (node.width || 150)));
+                finalY = Math.max(0, Math.min(finalY, (parent.height || 300) - (node.height || 48)));
+            }
+        }
+        // Helper Line Snapping
+        const threshold = 10;
+        this.nodes.forEach(other => {
+            if (other.id === nodeId || other.parentId === nodeId)
+                return;
+            if (Math.abs(finalX - other.position.x) < threshold)
+                finalX = other.position.x;
+            if (Math.abs(finalY - other.position.y) < threshold)
+                finalY = other.position.y;
+        });
+        const dx = finalX - node.position.x, dy = finalY - node.position.y;
+        if (dx === 0 && dy === 0)
+            return;
+        const idsToMove = this.selectedNodeIds.includes(nodeId) ? this.selectedNodeIds : [nodeId];
+        const movedNodesSet = new Set();
+        // Find all nodes in the hierarchy to move
+        const nodesToUpdate = new Map();
+        idsToMove.forEach(id => {
+            this.collectNodesToMove(id, dx, dy, movedNodesSet, nodesToUpdate);
+        });
+        // Single pass update
+        this.nodes = this.nodes.map(n => {
+            const update = nodesToUpdate.get(n.id);
+            return update ? { ...n, position: update } : n;
+        });
+        this.notify();
+    }
+    collectNodesToMove(id, dx, dy, movedNodesSet, map) {
+        if (movedNodesSet.has(id))
+            return;
+        const node = this.nodes.find(n => n.id === id);
+        if (!node)
+            return;
+        movedNodesSet.add(id);
+        map.set(id, { x: node.position.x + dx, y: node.position.y + dy });
+        this.nodes.filter(n => n.parentId === id).forEach(child => this.collectNodesToMove(child.id, dx, dy, movedNodesSet, map));
+    }
+    onConnect(connection) {
+        if (!this.isValidConnection(connection))
+            return null;
+        // STRICT: Only one connection between the same pair of nodes in the same direction
+        // (regardless of handles if user just wants "1 line")
+        // Or at least catch if handles are effectively the same.
+        const isDuplicate = this.edges.some(e => e.source === connection.source &&
+            e.target === connection.target &&
+            (e.sourceHandle || 'floating') === (connection.sourceHandle || 'floating') &&
+            (e.targetHandle || 'floating') === (connection.targetHandle || 'floating'));
+        if (isDuplicate)
+            return null;
+        const id = `e-${connection.source}-${connection.target}-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
+        this.edges = [...this.edges, {
+                id,
+                ...connection,
+                type: 'default',
+                animated: false,
+                sourceHandle: connection.sourceHandle || 'floating',
+                targetHandle: connection.targetHandle || 'floating'
+            }];
+        this.saveToHistory();
+        this.notify();
+        return id;
+    }
+    toggleNodeCollapse(nodeId) { this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, isCollapsed: !n.isCollapsed } : n); this.saveToHistory(); this.notify(); }
+    isValidConnection(connection) {
+        if (connection.source === connection.target)
+            return false;
+        if (this.isCycle(connection.source, connection.target))
+            return false;
+        // Check if any connection already exists between these two nodes in this direction
+        // to strictly enforce "one line per pair" as requested.
+        const alreadyConnected = this.edges.some(e => e.source === connection.source && e.target === connection.target);
+        if (alreadyConnected)
+            return false;
+        const sourceNode = this.nodes.find(n => n.id === connection.source), targetNode = this.nodes.find(n => n.id === connection.target);
+        if (sourceNode?.maxConnections !== undefined && this.edges.filter(e => e.source === connection.source).length >= sourceNode.maxConnections)
+            return false;
+        if (targetNode?.maxConnections !== undefined && this.edges.filter(e => e.target === connection.target).length >= targetNode.maxConnections)
+            return false;
+        return true;
+    }
+    updateEdge(edgeId, updates) { this.edges = this.edges.map(e => e.id === edgeId ? { ...e, ...updates } : e); this.saveToHistory(); this.notify(); }
+    isCycle(source, target) {
+        if (source === target)
+            return true;
+        const visited = new Set(), queue = [target];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                continue;
+            if (current === source)
+                return true;
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            this.edges.filter(e => e.source === current).forEach(e => queue.push(e.target));
+        }
+        return false;
+    }
+    deleteSelected() {
+        this.nodes = this.nodes.filter(n => !this.selectedNodeIds.includes(n.id));
+        this.edges = this.edges.filter(e => !this.selectedEdgeIds.includes(e.id) && !this.selectedNodeIds.includes(e.source) && !this.selectedNodeIds.includes(e.target));
+        this.selectedNodeIds = [];
+        this.selectedEdgeIds = [];
+        this.saveToHistory();
+        this.notify();
+    }
+    groupSelected() {
+        if (this.selectedNodeIds.length < 2)
+            return;
+        const selectedNodes = this.nodes.filter(n => this.selectedNodeIds.includes(n.id));
+        const minX = Math.min(...selectedNodes.map(n => n.position.x)), minY = Math.min(...selectedNodes.map(n => n.position.y)), maxX = Math.max(...selectedNodes.map(n => n.position.x + (n.width || 150))), maxY = Math.max(...selectedNodes.map(n => n.position.y + (n.height || 48)));
+        const groupId = `group-${Date.now()}`;
+        const groupNode = { id: groupId, type: 'group', position: { x: minX - 20, y: minY - 40 }, width: maxX - minX + 40, height: maxY - minY + 60, data: { label: 'New Group' }, zIndex: 1, style: { background: 'rgba(0,0,0,0.02)', border: '1px dashed #ccc' } };
+        this.nodes = [...this.nodes.map(n => this.selectedNodeIds.includes(n.id) ? { ...n, parentId: groupId } : n), groupNode];
+        this.selectedNodeIds = [groupId];
+        this.saveToHistory();
+        this.notify();
+    }
+    autoLayout(direction = 'LR') {
+        const visited = new Set(), levelMap = {}, rootNodes = this.nodes.filter(n => !this.edges.some(e => e.target === n.id));
+        const assignLevels = (nodeId, level) => {
+            levelMap[nodeId] = Math.max(levelMap[nodeId] || 0, level);
+            if (visited.has(nodeId))
+                return;
+            visited.add(nodeId);
+            this.edges.filter(e => e.source === nodeId).forEach(e => assignLevels(e.target, level + 1));
+        };
+        rootNodes.forEach(n => assignLevels(n.id, 0));
+        this.nodes.forEach(n => {
+            if (levelMap[n.id] === undefined)
+                assignLevels(n.id, 0);
+        });
+        const nodesByLevel = {};
+        Object.entries(levelMap).forEach(([id, level]) => { nodesByLevel[level] = [...(nodesByLevel[level] || []), id]; });
+        const gapX = 250, gapY = 100;
+        this.nodes = this.nodes.map(n => { const level = levelMap[n.id], index = nodesByLevel[level].indexOf(n.id); return { ...n, position: direction === 'LR' ? { x: level * gapX, y: index * gapY + 100 } : { x: index * gapX + 200, y: level * gapY + 100 } }; });
+        this.saveToHistory();
+        this.notify();
+    }
+    selectNode(nodeId, multi = false) {
+        if (multi) {
+            if (this.selectedNodeIds.includes(nodeId))
+                this.selectedNodeIds = this.selectedNodeIds.filter(id => id !== nodeId);
+            else
+                this.selectedNodeIds = [...this.selectedNodeIds, nodeId];
+        }
+        else {
+            this.selectedNodeIds = [nodeId];
+            this.selectedEdgeIds = [];
+        }
+        this.notify();
+    }
+    setParent(nodeId, parentId) {
+        const node = this.nodes.find(n => n.id === nodeId);
+        if (!node || node.parentId === parentId)
+            return;
+        if (parentId) {
+            const parent = this.nodes.find(n => n.id === parentId);
+            if (parent) {
+                // Move to relative coordinates
+                const relX = node.position.x - parent.position.x;
+                const relY = node.position.y - parent.position.y;
+                this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, parentId, position: { x: relX, y: relY } } : n);
+            }
+        }
+        else {
+            // Move back to absolute coordinates if it has a parent
+            const parent = node.parentId ? this.nodes.find(n => n.id === node.parentId) : null;
+            if (parent) {
+                this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, parentId: null, position: { x: node.position.x + parent.position.x, y: node.position.y + parent.position.y } } : n);
+            }
+            else {
+                this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, parentId: null } : n);
+            }
+        }
+        this.saveToHistory();
+        this.notify();
+    }
+    updateNode(nodeId, updates) {
+        this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, ...updates, data: { ...n.data, ...updates.data } } : n);
+        this.notify();
+    }
+    rotateNode(nodeId, angle) {
+        this.nodes = this.nodes.map(n => n.id === nodeId ? { ...n, rotation: angle } : n);
+        this.notify(); // Don't save to history every drag step, maybe on up
+    }
+    selectEdge(edgeId, multi = false) {
+        if (multi) {
+            if (this.selectedEdgeIds.includes(edgeId))
+                this.selectedEdgeIds = this.selectedEdgeIds.filter(id => id !== edgeId);
+            else
+                this.selectedEdgeIds = [...this.selectedEdgeIds, edgeId];
+        }
+        else {
+            this.selectedEdgeIds = [edgeId];
+            this.selectedNodeIds = [];
+        }
+        this.notify();
+    }
+    clearSelection() { this.selectedNodeIds = []; this.selectedEdgeIds = []; this.notify(); }
+    deleteEdge(edgeId) { this.edges = this.edges.filter(e => e.id !== edgeId); this.saveToHistory(); this.notify(); }
+    deleteNode(nodeId) {
+        const inEdges = this.edges.filter(e => e.target === nodeId);
+        const outEdges = this.edges.filter(e => e.source === nodeId);
+        // Delete Middle Node logic: If exactly one in and one out, reconnect them
+        if (inEdges.length === 1 && outEdges.length === 1) {
+            const sourceId = inEdges[0].source;
+            const targetId = outEdges[0].target;
+            this.addEdge({
+                id: `reconnect-${Date.now()}`,
+                source: sourceId,
+                target: targetId,
+                sourceHandle: inEdges[0].sourceHandle,
+                targetHandle: outEdges[0].targetHandle,
+                type: inEdges[0].type
+            });
+        }
+        this.nodes = this.nodes.filter(n => n.id !== nodeId);
+        this.edges = this.edges.filter(e => e.source !== nodeId && e.target !== nodeId);
+        this.selectedNodeIds = this.selectedNodeIds.filter(id => id !== nodeId);
+        this.saveToHistory();
+        this.notify();
+    }
+    addEdge(edge) { this.edges = [...this.edges, edge]; this.saveToHistory(); this.notify(); }
+    copySelected() {
+        this.clipboardNodes = this.nodes.filter(n => this.selectedNodeIds.includes(n.id)).map(n => ({ ...n }));
+        this.clipboardEdges = this.edges.filter(e => this.selectedNodeIds.includes(e.source) && this.selectedNodeIds.includes(e.target)).map(e => ({ ...e }));
+    }
+    paste(x, y) {
+        if (this.clipboardNodes.length === 0)
+            return;
+        const idMap = {};
+        const minX = Math.min(...this.clipboardNodes.map(n => n.position.x)), minY = Math.min(...this.clipboardNodes.map(n => n.position.y));
+        const targetX = x === undefined ? minX + 20 : x, targetY = y === undefined ? minY + 20 : y;
+        const dx = targetX - minX, dy = targetY - minY;
+        const newNodes = this.clipboardNodes.map(n => {
+            const newId = `node-${Date.now()}-${Math.random()}`;
+            idMap[n.id] = newId;
+            return { ...n, id: newId, position: { x: n.position.x + dx, y: n.position.y + dy }, selected: true };
+        });
+        const newEdges = this.clipboardEdges.map(e => ({ ...e, id: `edge-${Date.now()}-${Math.random()}`, source: idMap[e.source], target: idMap[e.target] }));
+        this.nodes = [...this.nodes.map(n => ({ ...n, selected: false })), ...newNodes];
+        this.edges = [...this.edges, ...newEdges];
+        this.selectedNodeIds = newNodes.map(n => n.id);
+        this.saveToHistory();
+        this.notify();
+    }
+    generateStressTest(count) {
+        const newNodes = [];
+        for (let i = 0; i < count; i++) {
+            newNodes.push({
+                id: `stress-${i}`,
+                position: { x: Math.random() * 2000, y: Math.random() * 2000 },
+                data: { label: `Node ${i}` },
+                zIndex: 10
+            });
+        }
+        this.nodes = [...this.nodes, ...newNodes];
+        this.notify();
+    }
+    getFullState() { return { nodes: this.nodes, edges: this.edges, viewport: this.viewport, nodeValues: this.nodeValues }; }
+}

package/dist/collection/utils/workflow/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/abstract-control-XBF88YT_.js

@@ -0,0 +1,275 @@
+/**
+ * AbstractControl — Base class mirroring Angular's AbstractControl
+ * Provides: value, status, errors, dirty, touched, pristine, valid, invalid
+ */
+class AbstractControl {
+    _value = null;
+    _status = 'VALID';
+    _errors = null;
+    _validators = [];
+    _asyncValidators = [];
+    _updateOn = 'change';
+    _dirty = false;
+    _touched = false;
+    _pending = false;
+    // Listeners
+    _onChange = [];
+    _onStatusChange = [];
+    _valueChangeListeners = new Set();
+    _statusChangeListeners = new Set();
+    _stateChangeListeners = new Set();
+    parent = null;
+    getRawValue() {
+        return this.value;
+    }
+    get valid() { return this._status === 'VALID'; }
+    get invalid() { return this._status === 'INVALID'; }
+    get pending() { return this._status === 'PENDING'; }
+    get disabled() { return this._status === 'DISABLED'; }
+    get enabled() { return this._status !== 'DISABLED'; }
+    get dirty() { return this._dirty; }
+    get pristine() { return !this._dirty; }
+    get touched() { return this._touched; }
+    get untouched() { return !this._touched; }
+    get status() { return this._status; }
+    get errors() { return this._errors; }
+    get updateOn() { return this._updateOn; }
+    // ─── Value Change Observable ──────────────────────────────────
+    /**
+     * Subscribe to value changes — returns unsubscribe fn
+     */
+    valueChanges(listener) {
+        this._valueChangeListeners.add(listener);
+        return () => this._valueChangeListeners.delete(listener);
+    }
+    /**
+     * Subscribe to status changes — returns unsubscribe fn
+     */
+    statusChanges(listener) {
+        this._statusChangeListeners.add(listener);
+        return () => this._statusChangeListeners.delete(listener);
+    }
+    /**
+     * Subscribe to state changes (value + status + errors)
+     */
+    stateChanges(listener) {
+        this._stateChangeListeners.add(listener);
+        return () => this._stateChangeListeners.delete(listener);
+    }
+    // ─── State Mutations ──────────────────────────────────────────
+    markAsDirty(opts = {}) {
+        this._dirty = true;
+        if (!opts.onlySelf && this.parent) {
+            this.parent.markAsDirty(opts);
+        }
+    }
+    markAsPristine(opts = {}) {
+        this._dirty = false;
+        this._forEachChild((control) => control.markAsPristine({ onlySelf: true }));
+        if (!opts.onlySelf && this.parent) {
+            this.parent._updateDirty();
+        }
+    }
+    markAsTouched(opts = {}) {
+        this._touched = true;
+        if (!opts.onlySelf && this.parent) {
+            this.parent.markAsTouched(opts);
+        }
+    }
+    markAsUntouched(opts = {}) {
+        this._touched = false;
+        this._forEachChild((control) => control.markAsUntouched({ onlySelf: true }));
+        if (!opts.onlySelf && this.parent) {
+            this.parent._updateTouched();
+        }
+    }
+    markAllAsTouched() {
+        this.markAsTouched({ onlySelf: true });
+        this._forEachChild((control) => control.markAllAsTouched());
+    }
+    markAllAsDirty() {
+        this.markAsDirty({ onlySelf: true });
+        this._forEachChild((control) => control.markAllAsDirty());
+    }
+    // ─── Enable / Disable ─────────────────────────────────────────
+    enable(opts = {}) {
+        this._status = 'VALID';
+        this._forEachChild((control) => control.enable({ onlySelf: true }));
+        this._updateValueAndValidity(opts);
+        if (opts.emitEvent !== false) {
+            this._emitStatusChange(this._status);
+        }
+    }
+    disable(opts = {}) {
+        this._status = 'DISABLED';
+        this._errors = null;
+        this._forEachChild((control) => control.disable({ onlySelf: true }));
+        if (opts.emitEvent !== false) {
+            this._emitStatusChange(this._status);
+        }
+        if (!opts.onlySelf && this.parent) {
+            this.parent._updateValueAndValidity(opts);
+        }
+    }
+    // ─── Validators ───────────────────────────────────────────────
+    setValidators(validators) {
+        this._validators = this._coerceToArray(validators);
+        this._runValidation();
+    }
+    addValidators(validators) {
+        const arr = this._coerceToArray(validators);
+        this._validators = [...this._validators, ...arr.filter(v => !this._validators.includes(v))];
+    }
+    removeValidators(validators) {
+        const arr = this._coerceToArray(validators);
+        this._validators = this._validators.filter(v => !arr.includes(v));
+    }
+    clearValidators() {
+        this._validators = [];
+    }
+    hasValidator(validator) {
+        return this._validators.includes(validator);
+    }
+    setAsyncValidators(validators) {
+        this._asyncValidators = this._coerceToArray(validators);
+    }
+    clearAsyncValidators() {
+        this._asyncValidators = [];
+    }
+    // ─── Errors ───────────────────────────────────────────────────
+    setErrors(errors, opts = {}) {
+        this._setErrors(errors, opts);
+    }
+    getError(errorCode, path) {
+        const control = path ? this.get(path) : this;
+        return control && control._errors ? control._errors[errorCode] : null;
+    }
+    hasError(errorCode, path) {
+        return !!this.getError(errorCode, path);
+    }
+    // ─── Traverse ────────────────────────────────────────────────
+    get(path) {
+        return _find(this, path);
+    }
+    get root() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let x = this;
+        while (x.parent)
+            x = x.parent;
+        return x;
+    }
+    // ─── Internal ────────────────────────────────────────────────
+    _applyValidators(validatorsOrOptions, asyncValidators) {
+        if (validatorsOrOptions && typeof validatorsOrOptions === 'object' && !Array.isArray(validatorsOrOptions) && 'validators' in validatorsOrOptions) {
+            const opts = validatorsOrOptions;
+            this._validators = this._coerceToArray(opts.validators);
+            this._asyncValidators = this._coerceToArray(opts.asyncValidators);
+        }
+        else {
+            this._validators = this._coerceToArray(validatorsOrOptions);
+            this._asyncValidators = this._coerceToArray(asyncValidators);
+        }
+    }
+    _runValidators(_value) {
+        if (this._validators.length === 0)
+            return null;
+        const errors = {};
+        let hasError = false;
+        for (const validator of this._validators) {
+            const result = validator(this);
+            if (result) {
+                Object.assign(errors, result);
+                hasError = true;
+            }
+        }
+        return hasError ? errors : null;
+    }
+    async _runAsyncValidators(_value) {
+        if (this._asyncValidators.length === 0)
+            return;
+        this._status = 'PENDING';
+        this._emitStatusChange('PENDING');
+        try {
+            const results = await Promise.all(this._asyncValidators.map(v => v(this)));
+            const merged = {};
+            let hasError = false;
+            for (const r of results) {
+                if (r) {
+                    Object.assign(merged, r);
+                    hasError = true;
+                }
+            }
+            this._setErrors(hasError ? merged : null);
+        }
+        catch {
+            // silently ignore async validator errors
+        }
+    }
+    _setErrors(errors, opts = {}) {
+        this._errors = errors;
+        this._status = this._calculateStatus();
+        if (opts.emitEvent !== false) {
+            this._emitStatusChange(this._status);
+        }
+        if (this.parent) {
+            this.parent._updateValueAndValidity({ onlySelf: true });
+        }
+    }
+    _updateValueAndValidity(opts = {}) {
+        this._runValidation();
+        if (opts.emitEvent !== false) {
+            this._emitStatusChange(this._status);
+        }
+        if (!opts.onlySelf && this.parent) {
+            this.parent._updateValueAndValidity(opts);
+        }
+    }
+    _calculateStatus() {
+        if (this._status === 'DISABLED')
+            return 'DISABLED';
+        if (this._errors)
+            return 'INVALID';
+        if (this._pending)
+            return 'PENDING';
+        return 'VALID';
+    }
+    _emitValueChange(value) {
+        this._valueChangeListeners.forEach(fn => fn(value));
+        this._emitStateChange();
+    }
+    _emitStatusChange(status) {
+        this._statusChangeListeners.forEach(fn => fn(status));
+        this._emitStateChange();
+    }
+    _emitStateChange() {
+        const state = { value: this.value, status: this.status, errors: this.errors };
+        this._stateChangeListeners.forEach(fn => fn(state));
+    }
+    _updateDirty() {
+        this._dirty = this._anyControls((c) => c.dirty);
+    }
+    _updateTouched() {
+        this._touched = this._anyControls((c) => c.touched);
+    }
+    _anyControls(_condition) { return false; }
+    _forEachChild(_fn) { }
+    _coerceToArray(v) {
+        if (!v)
+            return [];
+        return Array.isArray(v) ? v : [v];
+    }
+}
+function _find(control, path) {
+    const segments = Array.isArray(path) ? path : path.split('.');
+    return segments.reduce((c, seg) => {
+        if (!c)
+            return null;
+        if (c instanceof Object && '_controls' in c) {
+            const ctrl = c._controls;
+            return typeof ctrl === 'object' ? ctrl[seg] ?? null : null;
+        }
+        return null;
+    }, control);
+}
+
+export { AbstractControl as A };