@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/validation/TypeRegistry.js

@@ -0,0 +1,358 @@
+"use strict";
+// TypeRegistry - Manages custom node, port, and link types with validation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeRegistry = void 0;
+class TypeRegistry {
+    constructor() {
+        this.nodeTypes = new Map();
+        this.portTypes = new Map();
+        this.linkTypes = new Map();
+        this.groupTypes = new Map(); // Phase 2
+    }
+    /**
+     * Register a node type
+     */
+    registerNodeType(definition) {
+        // Phase 2: Validate parent type exists and check circular inheritance FIRST
+        if (definition.extends) {
+            if (!this.nodeTypes.has(definition.extends)) {
+                throw new Error(`Parent type '${definition.extends}' not found`);
+            }
+            // Detect circular inheritance (check before duplicate check)
+            this.detectCircularInheritance(definition.type, definition.extends);
+        }
+        if (this.nodeTypes.has(definition.type)) {
+            throw new Error(`Node type '${definition.type}' is already registered`);
+        }
+        this.nodeTypes.set(definition.type, definition);
+    }
+    /**
+     * Detect circular inheritance in type chain
+     */
+    detectCircularInheritance(childType, parentType) {
+        // Check if parent's inheritance chain leads back to child
+        const visited = new Set();
+        let current = parentType;
+        while (current) {
+            if (current === childType) {
+                throw new Error('Circular inheritance detected');
+            }
+            if (visited.has(current)) {
+                // Already checked this path, no cycle involving childType
+                break;
+            }
+            visited.add(current);
+            const parentDef = this.nodeTypes.get(current);
+            if (!parentDef || !parentDef.extends) {
+                break;
+            }
+            current = parentDef.extends;
+        }
+    }
+    /**
+     * Register a port type
+     */
+    registerPortType(definition) {
+        if (this.portTypes.has(definition.type)) {
+            throw new Error(`Port type '${definition.type}' is already registered`);
+        }
+        this.portTypes.set(definition.type, definition);
+    }
+    /**
+     * Register a link type
+     */
+    registerLinkType(definition) {
+        if (this.linkTypes.has(definition.type)) {
+            throw new Error(`Link type '${definition.type}' is already registered`);
+        }
+        this.linkTypes.set(definition.type, definition);
+    }
+    /**
+     * Register a group type (Phase 2)
+     */
+    registerGroupType(definition) {
+        if (this.groupTypes.has(definition.type)) {
+            throw new Error(`Group type '${definition.type}' is already registered`);
+        }
+        this.groupTypes.set(definition.type, definition);
+    }
+    /**
+     * Unregister a node type
+     */
+    unregisterNodeType(type) {
+        return this.nodeTypes.delete(type);
+    }
+    /**
+     * Unregister a port type
+     */
+    unregisterPortType(type) {
+        return this.portTypes.delete(type);
+    }
+    /**
+     * Unregister a link type
+     */
+    unregisterLinkType(type) {
+        return this.linkTypes.delete(type);
+    }
+    /**
+     * Unregister a group type (Phase 2)
+     */
+    unregisterGroupType(type) {
+        return this.groupTypes.delete(type);
+    }
+    /**
+     * Get node type definition
+     */
+    getNodeType(type) {
+        return this.nodeTypes.get(type);
+    }
+    /**
+     * Get port type definition
+     */
+    getPortType(type) {
+        return this.portTypes.get(type);
+    }
+    /**
+     * Get link type definition
+     */
+    getLinkType(type) {
+        return this.linkTypes.get(type);
+    }
+    /**
+     * Get group type definition (Phase 2)
+     */
+    getGroupType(type) {
+        return this.groupTypes.get(type);
+    }
+    /**
+     * Check if node type exists
+     */
+    hasNodeType(type) {
+        return this.nodeTypes.has(type);
+    }
+    /**
+     * Check if port type exists
+     */
+    hasPortType(type) {
+        return this.portTypes.has(type);
+    }
+    /**
+     * Check if link type exists
+     */
+    hasLinkType(type) {
+        return this.linkTypes.has(type);
+    }
+    /**
+     * Check if group type exists (Phase 2)
+     */
+    hasGroupType(type) {
+        return this.groupTypes.has(type);
+    }
+    /**
+     * List all node types
+     */
+    listNodeTypes() {
+        return Array.from(this.nodeTypes.values());
+    }
+    /**
+     * List all port types
+     */
+    listPortTypes() {
+        return Array.from(this.portTypes.values());
+    }
+    /**
+     * List all link types
+     */
+    listLinkTypes() {
+        return Array.from(this.linkTypes.values());
+    }
+    /**
+     * List all group types (Phase 2)
+     */
+    listGroupTypes() {
+        return Array.from(this.groupTypes.values());
+    }
+    /**
+     * Clear all registered types
+     */
+    clear() {
+        this.nodeTypes.clear();
+        this.portTypes.clear();
+        this.linkTypes.clear();
+        this.groupTypes.clear(); // Phase 2
+    }
+    /**
+     * Get type statistics
+     */
+    getStats() {
+        return {
+            nodeTypes: this.nodeTypes.size,
+            portTypes: this.portTypes.size,
+            linkTypes: this.linkTypes.size,
+            groupTypes: this.groupTypes.size, // Phase 2
+        };
+    }
+    // ========================================
+    // Phase 2: Type System Enhancements
+    // ========================================
+    /**
+     * Resolve a node type with all inherited properties
+     */
+    resolveNodeType(type) {
+        const typeDef = this.nodeTypes.get(type);
+        if (!typeDef) {
+            throw new Error(`Node type '${type}' not found`);
+        }
+        // If no inheritance, return as-is
+        if (!typeDef.extends) {
+            return Object.assign({}, typeDef);
+        }
+        // Walk up the inheritance chain and merge properties
+        const chain = [];
+        let current = type;
+        while (current) {
+            const def = this.nodeTypes.get(current);
+            if (!def)
+                break;
+            chain.push(def);
+            current = def.extends;
+        }
+        // Merge from parent to child (child overrides parent)
+        const resolved = { type };
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const def = chain[i];
+            // Simple property merging
+            if (def.label !== undefined)
+                resolved.label = def.label;
+            if (def.description !== undefined)
+                resolved.description = def.description;
+            if (def.minPorts !== undefined)
+                resolved.minPorts = def.minPorts;
+            if (def.maxPorts !== undefined)
+                resolved.maxPorts = def.maxPorts;
+            if (def.category !== undefined)
+                resolved.category = def.category;
+            if (def.family !== undefined)
+                resolved.family = def.family;
+            if (def.validator !== undefined)
+                resolved.validator = def.validator;
+            // Phase 2: Template system properties
+            if (def.templateId !== undefined)
+                resolved.templateId = def.templateId;
+            // Array merging (tags)
+            if (def.tags !== undefined) {
+                resolved.tags = [...def.tags];
+            }
+            // Array merging (allowedPortTypes)
+            if (def.allowedPortTypes !== undefined) {
+                resolved.allowedPortTypes = [...def.allowedPortTypes];
+            }
+            // Object merging (defaultData)
+            if (def.defaultData !== undefined) {
+                resolved.defaultData = Object.assign(Object.assign({}, resolved.defaultData), def.defaultData);
+            }
+            // Object merging (defaultBehavior)
+            if (def.defaultBehavior !== undefined) {
+                resolved.defaultBehavior = Object.assign(Object.assign({}, resolved.defaultBehavior), def.defaultBehavior);
+            }
+            // Object merging (defaultStyle)
+            if (def.defaultStyle !== undefined) {
+                resolved.defaultStyle = Object.assign(Object.assign({}, resolved.defaultStyle), def.defaultStyle);
+            }
+            // Object merging (defaultSize)
+            if (def.defaultSize !== undefined) {
+                resolved.defaultSize = Object.assign(Object.assign({}, resolved.defaultSize), def.defaultSize);
+            }
+            // Object merging (defaultPortRendering) - Phase 2
+            if (def.defaultPortRendering !== undefined) {
+                resolved.defaultPortRendering = Object.assign(Object.assign({}, resolved.defaultPortRendering), def.defaultPortRendering);
+            }
+        }
+        return resolved;
+    }
+    /**
+     * Get all node types in a category
+     */
+    getNodeTypesByCategory(category) {
+        return Array.from(this.nodeTypes.values()).filter((def) => {
+            // Check direct category or resolve inherited category
+            if (def.category === category)
+                return true;
+            if (def.extends) {
+                try {
+                    const resolved = this.resolveNodeType(def.type);
+                    return resolved.category === category;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get all node types in a family
+     */
+    getNodeTypesByFamily(family) {
+        return Array.from(this.nodeTypes.values()).filter((def) => {
+            // Check direct family or resolve inherited family
+            if (def.family === family)
+                return true;
+            if (def.extends) {
+                try {
+                    const resolved = this.resolveNodeType(def.type);
+                    return resolved.family === family;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get all node types with a specific tag
+     */
+    getNodeTypesByTag(tag) {
+        return Array.from(this.nodeTypes.values()).filter((def) => {
+            var _a, _b, _c;
+            // Check direct tags or resolve inherited tags
+            if ((_a = def.tags) === null || _a === void 0 ? void 0 : _a.includes(tag))
+                return true;
+            if (def.extends) {
+                try {
+                    const resolved = this.resolveNodeType(def.type);
+                    return (_c = (_b = resolved.tags) === null || _b === void 0 ? void 0 : _b.includes(tag)) !== null && _c !== void 0 ? _c : false;
+                }
+                catch (_d) {
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get all node types using a specific template (Phase 2)
+     * Includes types that inherit template ID from parent
+     */
+    getNodeTypesByTemplate(templateId) {
+        return Array.from(this.nodeTypes.values()).filter((def) => {
+            // Check direct template ID
+            if (def.templateId === templateId)
+                return true;
+            // Check inherited template ID
+            if (def.extends) {
+                try {
+                    const resolved = this.resolveNodeType(def.type);
+                    return resolved.templateId === templateId;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+}
+exports.TypeRegistry = TypeRegistry;
+//# sourceMappingURL=TypeRegistry.js.map

package/src/libs/engine/src/validation/ValidationEngine.d.ts

@@ -0,0 +1,79 @@
+import { TypeRegistry } from './TypeRegistry';
+import { EventBus } from '../events/EventBus';
+import type { ValidationResult } from '../types';
+import type { DiagramModel } from '../models/DiagramModel';
+import type { NodeModel } from '../models/NodeModel';
+import type { PortModel } from '../models/PortModel';
+import type { LinkModel } from '../models/LinkModel';
+import type { GroupModel } from '../models/GroupModel';
+export type { ValidationResult, ValidationError, ValidationWarning } from '../types';
+export interface ValidationOptions {
+    validateTypes?: boolean;
+    validateConnections?: boolean;
+    validatePorts?: boolean;
+    strict?: boolean;
+}
+export type ValidationRule<T = any> = (entity: T) => ValidationResult;
+export declare class ValidationEngine {
+    private typeRegistry;
+    private customRules;
+    private realTimeValidation;
+    private eventBus?;
+    constructor(typeRegistry: TypeRegistry, eventBus?: EventBus);
+    /**
+     * Enable real-time validation
+     */
+    enableRealTimeValidation(): void;
+    /**
+     * Disable real-time validation
+     */
+    disableRealTimeValidation(): void;
+    /**
+     * Check if real-time validation is enabled (Phase 1 - Critical Fixes)
+     */
+    isRealTimeValidationEnabled(): boolean;
+    /**
+     * Validate entire diagram
+     */
+    validateDiagram(diagram: DiagramModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate a node
+     */
+    validateNode(node: NodeModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate a port
+     */
+    validatePort(port: PortModel, node: NodeModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate a link
+     */
+    validateLink(link: LinkModel, diagram: DiagramModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate node hierarchy (Phase 2 - Hierarchy-aware validation)
+     */
+    validateHierarchy(node: NodeModel, diagram: DiagramModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate group (Phase 2 - Group validation)
+     */
+    validateGroup(group: GroupModel, diagram: DiagramModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Validate layout configuration (Phase 3 - Layout validation)
+     */
+    validateLayout(group: GroupModel, diagram: DiagramModel, options?: ValidationOptions): ValidationResult;
+    /**
+     * Add custom validation rule
+     */
+    addRule(entityType: 'diagram' | 'node' | 'port' | 'link', rule: ValidationRule): void;
+    /**
+     * Remove all custom rules for an entity type
+     */
+    clearRules(entityType: 'diagram' | 'node' | 'port' | 'link'): void;
+    /**
+     * Clear all custom rules
+     */
+    clearAllRules(): void;
+    /**
+     * Get custom rules count
+     */
+    getRulesCount(entityType?: 'diagram' | 'node' | 'port' | 'link'): number;
+}