@grafloria/element 0.3.17 → 0.3.19

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

@@ -0,0 +1,1150 @@
+"use strict";
+// ValidationEngine - Validates diagrams, nodes, ports, and links
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationEngine = void 0;
+const event_types_1 = require("../types/event.types"); // Phase 1 - Critical Fixes
+class ValidationEngine {
+    constructor(typeRegistry, eventBus) {
+        this.customRules = new Map();
+        this.realTimeValidation = false;
+        this.typeRegistry = typeRegistry;
+        this.eventBus = eventBus; // Phase 1 - Critical Fixes
+    }
+    /**
+     * Enable real-time validation
+     */
+    enableRealTimeValidation() {
+        this.realTimeValidation = true;
+    }
+    /**
+     * Disable real-time validation
+     */
+    disableRealTimeValidation() {
+        this.realTimeValidation = false;
+    }
+    /**
+     * Check if real-time validation is enabled (Phase 1 - Critical Fixes)
+     */
+    isRealTimeValidationEnabled() {
+        return this.realTimeValidation;
+    }
+    /**
+     * Validate entire diagram
+     */
+    validateDiagram(diagram, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event (Phase 1 - Critical Fixes)
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'diagram',
+            timestamp: Date.now()
+        });
+        const opts = Object.assign({ validateTypes: true, validateConnections: true, validatePorts: true, strict: false }, options);
+        const errors = [];
+        const warnings = [];
+        // Validate all nodes
+        for (const node of diagram.getNodes()) {
+            const result = this.validateNode(node, opts);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        // Validate all links
+        for (const link of diagram.getLinks()) {
+            const result = this.validateLink(link, diagram, opts);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        // Phase 2: Validate hierarchy for all nodes
+        for (const node of diagram.getNodes()) {
+            const result = this.validateHierarchy(node, diagram, opts);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        // Phase 2: Validate all groups
+        for (const group of diagram.getGroups()) {
+            const result = this.validateGroup(group, diagram, opts);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        // Phase 3: Validate layout for all groups with layouts
+        for (const group of diagram.getGroups()) {
+            if (group.layoutType !== 'none') {
+                const result = this.validateLayout(group, diagram, opts);
+                errors.push(...result.errors);
+                warnings.push(...result.warnings);
+            }
+        }
+        // Custom diagram-level rules
+        const customRules = this.customRules.get('diagram') || [];
+        for (const rule of customRules) {
+            const result = rule(diagram);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events (Phase 1 - Critical Fixes)
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'diagram',
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'diagram',
+                result,
+                timestamp: Date.now()
+            });
+        }
+        // Emit individual error/warning events
+        errors.forEach(error => {
+            var _a;
+            (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_ERROR, error);
+        });
+        warnings.forEach(warning => {
+            var _a;
+            (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_WARNING, warning);
+        });
+        return result;
+    }
+    /**
+     * Validate a node
+     */
+    validateNode(node, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event (Phase 1 - Critical Fixes)
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'node',
+            entityId: node.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Validate node type if enabled
+        if (options.validateTypes !== false) {
+            const typeDef = this.typeRegistry.getNodeType(node.type);
+            if (!typeDef) {
+                if (options.strict) {
+                    errors.push({
+                        path: `node.${node.id}`,
+                        message: `Unknown node type: ${node.type}`,
+                        code: 'UNKNOWN_NODE_TYPE',
+                        severity: 'error',
+                    });
+                }
+                else {
+                    warnings.push({
+                        path: `node.${node.id}`,
+                        message: `Node type '${node.type}' is not registered`,
+                        code: 'UNREGISTERED_NODE_TYPE',
+                        severity: 'warning',
+                    });
+                }
+            }
+            else {
+                // Validate port count
+                const portCount = node.getPorts().length;
+                if (typeDef.minPorts !== undefined && portCount < typeDef.minPorts) {
+                    errors.push({
+                        path: `node.${node.id}`,
+                        message: `Node requires at least ${typeDef.minPorts} ports, has ${portCount}`,
+                        code: 'INSUFFICIENT_PORTS',
+                        severity: 'error',
+                    });
+                }
+                if (typeDef.maxPorts !== undefined && portCount > typeDef.maxPorts) {
+                    errors.push({
+                        path: `node.${node.id}`,
+                        message: `Node allows at most ${typeDef.maxPorts} ports, has ${portCount}`,
+                        code: 'EXCESSIVE_PORTS',
+                        severity: 'error',
+                    });
+                }
+                // Custom type validator
+                if (typeDef.validator) {
+                    const result = typeDef.validator(node);
+                    errors.push(...result.errors);
+                    warnings.push(...result.warnings);
+                }
+            }
+        }
+        // Validate ports if enabled
+        if (options.validatePorts !== false) {
+            for (const port of node.getPorts()) {
+                const result = this.validatePort(port, node, options);
+                errors.push(...result.errors);
+                warnings.push(...result.warnings);
+            }
+        }
+        // Custom node-level rules
+        const customRules = this.customRules.get('node') || [];
+        for (const rule of customRules) {
+            const result = rule(node);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events (Phase 1 - Critical Fixes)
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'node',
+                entityId: node.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'node',
+                entityId: node.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Validate a port
+     */
+    validatePort(port, node, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event (Phase 1 - Critical Fixes)
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'port',
+            entityId: port.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Validate port type if enabled
+        if (options.validateTypes !== false) {
+            const typeDef = this.typeRegistry.getPortType(port.systemType || 'default');
+            if (!typeDef && port.systemType) {
+                if (options.strict) {
+                    errors.push({
+                        path: `node.${node.id}.port.${port.id}`,
+                        message: `Unknown port type: ${port.systemType}`,
+                        code: 'UNKNOWN_PORT_TYPE',
+                        severity: 'error',
+                    });
+                }
+                else {
+                    warnings.push({
+                        path: `node.${node.id}.port.${port.id}`,
+                        message: `Port type '${port.systemType}' is not registered`,
+                        code: 'UNREGISTERED_PORT_TYPE',
+                        severity: 'warning',
+                    });
+                }
+            }
+            else if (typeDef) {
+                // Validate connection count
+                const connectionCount = port.getConnectionCount();
+                if (typeDef.maxConnections !== undefined &&
+                    connectionCount > typeDef.maxConnections) {
+                    errors.push({
+                        path: `node.${node.id}.port.${port.id}`,
+                        message: `Port allows at most ${typeDef.maxConnections} connections, has ${connectionCount}`,
+                        code: 'EXCESSIVE_CONNECTIONS',
+                        severity: 'error',
+                    });
+                }
+                // Custom type validator
+                if (typeDef.validator) {
+                    const result = typeDef.validator(port);
+                    errors.push(...result.errors);
+                    warnings.push(...result.warnings);
+                }
+            }
+        }
+        // Custom port-level rules
+        const customRules = this.customRules.get('port') || [];
+        for (const rule of customRules) {
+            const result = rule(port);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events (Phase 1 - Critical Fixes)
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'port',
+                entityId: port.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'port',
+                entityId: port.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Validate a link
+     */
+    validateLink(link, diagram, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event (Phase 1 - Critical Fixes)
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'link',
+            entityId: link.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Validate connections if enabled
+        if (options.validateConnections !== false) {
+            // Check if source and target nodes exist
+            const sourceNode = diagram
+                .getNodes()
+                .find((n) => n.getPorts().some((p) => p.id === link.sourcePortId));
+            const targetNode = diagram
+                .getNodes()
+                .find((n) => n.getPorts().some((p) => p.id === link.targetPortId));
+            if (!sourceNode) {
+                errors.push({
+                    path: `link.${link.id}`,
+                    message: `Source port ${link.sourcePortId} not found`,
+                    code: 'SOURCE_PORT_NOT_FOUND',
+                    severity: 'error',
+                });
+            }
+            if (!targetNode) {
+                errors.push({
+                    path: `link.${link.id}`,
+                    message: `Target port ${link.targetPortId} not found`,
+                    code: 'TARGET_PORT_NOT_FOUND',
+                    severity: 'error',
+                });
+            }
+            // Validate port types if both ports exist
+            if (sourceNode && targetNode) {
+                const sourcePort = sourceNode
+                    .getPorts()
+                    .find((p) => p.id === link.sourcePortId);
+                const targetPort = targetNode
+                    .getPorts()
+                    .find((p) => p.id === link.targetPortId);
+                if (sourcePort && targetPort) {
+                    // Check port directions
+                    if (sourcePort.type === 'input' && targetPort.type === 'input') {
+                        errors.push({
+                            path: `link.${link.id}`,
+                            message: 'Cannot connect two input ports',
+                            code: 'INVALID_PORT_CONNECTION',
+                            severity: 'error',
+                        });
+                    }
+                    if (sourcePort.type === 'output' && targetPort.type === 'output') {
+                        errors.push({
+                            path: `link.${link.id}`,
+                            message: 'Cannot connect two output ports',
+                            code: 'INVALID_PORT_CONNECTION',
+                            severity: 'error',
+                        });
+                    }
+                    // Validate against port type definitions
+                    const sourceTypeDef = this.typeRegistry.getPortType(sourcePort.systemType || 'default');
+                    const targetTypeDef = this.typeRegistry.getPortType(targetPort.systemType || 'default');
+                    if (sourceTypeDef && sourceTypeDef.allowedLinkTypes) {
+                        const linkType = link.type || 'default';
+                        if (!sourceTypeDef.allowedLinkTypes.includes(linkType)) {
+                            errors.push({
+                                path: `link.${link.id}`,
+                                message: `Source port does not allow link type '${linkType}'`,
+                                code: 'LINK_TYPE_NOT_ALLOWED',
+                                severity: 'error',
+                            });
+                        }
+                    }
+                    if (targetTypeDef && targetTypeDef.allowedLinkTypes) {
+                        const linkType = link.type || 'default';
+                        if (!targetTypeDef.allowedLinkTypes.includes(linkType)) {
+                            errors.push({
+                                path: `link.${link.id}`,
+                                message: `Target port does not allow link type '${linkType}'`,
+                                code: 'LINK_TYPE_NOT_ALLOWED',
+                                severity: 'error',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Custom link type validator (Phase 1 - Critical Fixes)
+        const linkType = link.systemType || link.type;
+        if (linkType) {
+            const linkTypeDef = this.typeRegistry.getLinkType(linkType);
+            if (linkTypeDef && linkTypeDef.validator) {
+                const customResult = linkTypeDef.validator(link);
+                errors.push(...customResult.errors);
+                warnings.push(...customResult.warnings);
+            }
+        }
+        // Custom link-level rules
+        const customRules = this.customRules.get('link') || [];
+        for (const rule of customRules) {
+            const result = rule(link);
+            errors.push(...result.errors);
+            warnings.push(...result.warnings);
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events (Phase 1 - Critical Fixes)
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'link',
+                entityId: link.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'link',
+                entityId: link.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Validate node hierarchy (Phase 2 - Hierarchy-aware validation)
+     */
+    validateHierarchy(node, diagram, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'hierarchy',
+            entityId: node.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Get node type definition with resolved inheritance
+        const typeDef = this.typeRegistry.getNodeType(node.type);
+        if (!typeDef) {
+            // Skip hierarchy validation if type not registered
+            return { valid: true, errors: [], warnings: [] };
+        }
+        // Resolve type definition with inheritance
+        const resolved = this.typeRegistry.resolveNodeType(node.type);
+        // 1. Validate canBeRoot constraint
+        if (!node.parentId && resolved.canBeRoot === false) {
+            errors.push({
+                path: `node.${node.id}.hierarchy`,
+                message: `Node type '${node.type}' cannot be a root node (requires parent)`,
+                code: 'INVALID_ROOT_NODE',
+                severity: 'error',
+            });
+        }
+        // 2. Validate parent type constraints
+        if (node.parentId) {
+            const parent = diagram.getNode(node.parentId);
+            if (parent) {
+                // Check if parent type is allowed
+                if (resolved.allowedParentTypes && resolved.allowedParentTypes.length > 0) {
+                    if (!resolved.allowedParentTypes.includes(parent.type)) {
+                        errors.push({
+                            path: `node.${node.id}.hierarchy`,
+                            message: `Node type '${node.type}' cannot have parent of type '${parent.type}'. Allowed: ${resolved.allowedParentTypes.join(', ')}`,
+                            code: 'INVALID_PARENT_TYPE',
+                            severity: 'error',
+                        });
+                    }
+                }
+                // Check if parent allows this child type
+                const parentResolved = this.typeRegistry.resolveNodeType(parent.type);
+                if (parentResolved.allowedChildTypes && parentResolved.allowedChildTypes.length > 0) {
+                    if (!parentResolved.allowedChildTypes.includes(node.type)) {
+                        errors.push({
+                            path: `node.${node.id}.hierarchy`,
+                            message: `Parent node type '${parent.type}' does not allow child of type '${node.type}'. Allowed: ${parentResolved.allowedChildTypes.join(', ')}`,
+                            code: 'INVALID_CHILD_TYPE',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+            else {
+                errors.push({
+                    path: `node.${node.id}.hierarchy`,
+                    message: `Parent node '${node.parentId}' not found`,
+                    code: 'PARENT_NOT_FOUND',
+                    severity: 'error',
+                });
+            }
+        }
+        // 3. Validate maxChildren constraint
+        if (resolved.maxChildren !== undefined) {
+            const childCount = node.children.size;
+            if (childCount > resolved.maxChildren) {
+                errors.push({
+                    path: `node.${node.id}.hierarchy`,
+                    message: `Node type '${node.type}' allows at most ${resolved.maxChildren} children, has ${childCount}`,
+                    code: 'EXCESSIVE_CHILDREN',
+                    severity: 'error',
+                });
+            }
+        }
+        // 4. Validate maxDepth constraint
+        if (resolved.maxDepth !== undefined) {
+            const actualDepth = node.depth;
+            if (actualDepth > resolved.maxDepth) {
+                errors.push({
+                    path: `node.${node.id}.hierarchy`,
+                    message: `Node type '${node.type}' allows maximum depth of ${resolved.maxDepth}, actual depth is ${actualDepth}`,
+                    code: 'EXCESSIVE_DEPTH',
+                    severity: 'error',
+                });
+            }
+        }
+        // 5. Validate child types
+        if (resolved.allowedChildTypes && resolved.allowedChildTypes.length > 0) {
+            for (const childId of node.children) {
+                const child = diagram.getNode(childId);
+                if (child) {
+                    if (!resolved.allowedChildTypes.includes(child.type)) {
+                        errors.push({
+                            path: `node.${node.id}.hierarchy`,
+                            message: `Node type '${node.type}' does not allow child of type '${child.type}'. Allowed: ${resolved.allowedChildTypes.join(', ')}`,
+                            code: 'INVALID_CHILD_TYPE',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'hierarchy',
+                entityId: node.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'hierarchy',
+                entityId: node.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Validate group (Phase 2 - Group validation)
+     */
+    validateGroup(group, diagram, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'group',
+            entityId: group.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Get group type definition
+        const groupType = group.type || 'default';
+        const typeDef = this.typeRegistry.getGroupType(groupType);
+        if (!typeDef) {
+            // If no type definition, skip validation
+            return { valid: true, errors: [], warnings: [] };
+        }
+        // 1. Validate member count
+        const memberCount = group.members.size;
+        if (typeDef.minMembers !== undefined && memberCount < typeDef.minMembers) {
+            errors.push({
+                path: `group.${group.id}`,
+                message: `Group type '${groupType}' requires at least ${typeDef.minMembers} members, has ${memberCount}`,
+                code: 'INSUFFICIENT_MEMBERS',
+                severity: 'error',
+            });
+        }
+        if (typeDef.maxMembers !== undefined && memberCount > typeDef.maxMembers) {
+            errors.push({
+                path: `group.${group.id}`,
+                message: `Group type '${groupType}' allows at most ${typeDef.maxMembers} members, has ${memberCount}`,
+                code: 'EXCESSIVE_MEMBERS',
+                severity: 'error',
+            });
+        }
+        // 2. Validate member types
+        if (typeDef.allowedMemberTypes && typeDef.allowedMemberTypes.length > 0) {
+            for (const memberId of group.members) {
+                const node = diagram.getNode(memberId);
+                if (node) {
+                    if (!typeDef.allowedMemberTypes.includes(node.type)) {
+                        errors.push({
+                            path: `group.${group.id}`,
+                            message: `Group type '${groupType}' does not allow member of type '${node.type}'. Allowed: ${typeDef.allowedMemberTypes.join(', ')}`,
+                            code: 'INVALID_MEMBER_TYPE',
+                            severity: 'error',
+                        });
+                    }
+                }
+                else {
+                    errors.push({
+                        path: `group.${group.id}`,
+                        message: `Group member '${memberId}' not found`,
+                        code: 'MEMBER_NOT_FOUND',
+                        severity: 'error',
+                    });
+                }
+            }
+        }
+        // 3. Validate nesting constraint
+        if (typeDef.canNest === false) {
+            // Check if any members are themselves groups
+            for (const memberId of group.members) {
+                const node = diagram.getNode(memberId);
+                // Check if this member is actually a group (groups can contain nodes, so check type)
+                if (node && node.type === 'group') {
+                    errors.push({
+                        path: `group.${group.id}`,
+                        message: `Group type '${groupType}' does not allow nested groups`,
+                        code: 'NESTED_GROUP_NOT_ALLOWED',
+                        severity: 'error',
+                    });
+                    break; // Only report once
+                }
+            }
+        }
+        // 4. Validate link types within group
+        if (typeDef.allowedLinkTypes && typeDef.allowedLinkTypes.length > 0) {
+            const memberIds = Array.from(group.members);
+            const links = diagram.getLinks();
+            for (const link of links) {
+                // Check if this link is between group members
+                const sourceNode = diagram
+                    .getNodes()
+                    .find((n) => n.getPorts().some((p) => p.id === link.sourcePortId));
+                const targetNode = diagram
+                    .getNodes()
+                    .find((n) => n.getPorts().some((p) => p.id === link.targetPortId));
+                if (sourceNode && targetNode &&
+                    memberIds.includes(sourceNode.id) &&
+                    memberIds.includes(targetNode.id)) {
+                    // This link is between group members
+                    const linkType = link.type || 'default';
+                    if (!typeDef.allowedLinkTypes.includes(linkType)) {
+                        errors.push({
+                            path: `group.${group.id}`,
+                            message: `Group type '${groupType}' does not allow link type '${linkType}' within group. Allowed: ${typeDef.allowedLinkTypes.join(', ')}`,
+                            code: 'INVALID_LINK_TYPE_IN_GROUP',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+        // 5. Custom group validator
+        if (typeDef.validator) {
+            const customResult = typeDef.validator(group);
+            errors.push(...customResult.errors);
+            warnings.push(...customResult.warnings);
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'group',
+                entityId: group.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'group',
+                entityId: group.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Validate layout configuration (Phase 3 - Layout validation)
+     */
+    validateLayout(group, diagram, options = {}) {
+        var _a, _b, _c;
+        // Emit validation started event
+        (_a = this.eventBus) === null || _a === void 0 ? void 0 : _a.emit(event_types_1.DiagramEventTypes.VALIDATION_STARTED, {
+            type: 'layout',
+            entityId: group.id,
+            timestamp: Date.now()
+        });
+        const errors = [];
+        const warnings = [];
+        // Get group type definition
+        const groupType = group.type || 'default';
+        const typeDef = this.typeRegistry.getGroupType(groupType);
+        // 1. Check if group type requires layout
+        if ((typeDef === null || typeDef === void 0 ? void 0 : typeDef.requireLayout) && group.layoutType === 'none') {
+            errors.push({
+                path: `group.${group.id}.layout`,
+                message: `Group type '${groupType}' requires a layout to be configured`,
+                code: 'LAYOUT_REQUIRED',
+                severity: 'error',
+            });
+        }
+        // 2. Check if layout type is allowed for this group type
+        if ((typeDef === null || typeDef === void 0 ? void 0 : typeDef.allowedLayoutTypes) && group.layoutType !== 'none') {
+            if (!typeDef.allowedLayoutTypes.includes(group.layoutType)) {
+                errors.push({
+                    path: `group.${group.id}.layout`,
+                    message: `Group type '${groupType}' does not allow layout type '${group.layoutType}'. Allowed: ${typeDef.allowedLayoutTypes.join(', ')}`,
+                    code: 'INVALID_LAYOUT_TYPE',
+                    severity: 'error',
+                });
+            }
+        }
+        // 3. Validate flexbox configuration
+        if (group.layoutType === 'flexbox' && group.layoutConfig) {
+            const flexConfig = group.layoutConfig;
+            // Validate direction
+            const validDirections = ['row', 'column', 'row-reverse', 'column-reverse'];
+            if (!validDirections.includes(flexConfig.direction)) {
+                errors.push({
+                    path: `group.${group.id}.layout.direction`,
+                    message: `Invalid flexbox direction '${flexConfig.direction}'. Must be one of: ${validDirections.join(', ')}`,
+                    code: 'INVALID_FLEX_DIRECTION',
+                    severity: 'error',
+                });
+            }
+            // Validate wrap
+            const validWraps = ['nowrap', 'wrap', 'wrap-reverse'];
+            if (!validWraps.includes(flexConfig.wrap)) {
+                errors.push({
+                    path: `group.${group.id}.layout.wrap`,
+                    message: `Invalid flexbox wrap '${flexConfig.wrap}'. Must be one of: ${validWraps.join(', ')}`,
+                    code: 'INVALID_FLEX_WRAP',
+                    severity: 'error',
+                });
+            }
+            // Validate justifyContent
+            const validJustify = ['start', 'center', 'end', 'space-between', 'space-around', 'space-evenly'];
+            if (!validJustify.includes(flexConfig.justifyContent)) {
+                errors.push({
+                    path: `group.${group.id}.layout.justifyContent`,
+                    message: `Invalid flexbox justifyContent '${flexConfig.justifyContent}'. Must be one of: ${validJustify.join(', ')}`,
+                    code: 'INVALID_FLEX_JUSTIFY',
+                    severity: 'error',
+                });
+            }
+            // Validate alignItems
+            const validAlignItems = ['start', 'center', 'end', 'stretch', 'baseline'];
+            if (!validAlignItems.includes(flexConfig.alignItems)) {
+                errors.push({
+                    path: `group.${group.id}.layout.alignItems`,
+                    message: `Invalid flexbox alignItems '${flexConfig.alignItems}'. Must be one of: ${validAlignItems.join(', ')}`,
+                    code: 'INVALID_FLEX_ALIGN_ITEMS',
+                    severity: 'error',
+                });
+            }
+            // Validate alignContent
+            const validAlignContent = ['start', 'center', 'end', 'space-between', 'space-around', 'stretch'];
+            if (!validAlignContent.includes(flexConfig.alignContent)) {
+                errors.push({
+                    path: `group.${group.id}.layout.alignContent`,
+                    message: `Invalid flexbox alignContent '${flexConfig.alignContent}'. Must be one of: ${validAlignContent.join(', ')}`,
+                    code: 'INVALID_FLEX_ALIGN_CONTENT',
+                    severity: 'error',
+                });
+            }
+            // Validate gap (must be non-negative)
+            if (typeof flexConfig.gap === 'number') {
+                if (flexConfig.gap < 0) {
+                    errors.push({
+                        path: `group.${group.id}.layout.gap`,
+                        message: `Flexbox gap must be non-negative, got ${flexConfig.gap}`,
+                        code: 'INVALID_FLEX_GAP',
+                        severity: 'error',
+                    });
+                }
+            }
+            else if (flexConfig.gap) {
+                if (flexConfig.gap.row < 0 || flexConfig.gap.column < 0) {
+                    errors.push({
+                        path: `group.${group.id}.layout.gap`,
+                        message: `Flexbox gap values must be non-negative`,
+                        code: 'INVALID_FLEX_GAP',
+                        severity: 'error',
+                    });
+                }
+            }
+            // Validate padding
+            if (flexConfig.padding !== undefined) {
+                if (typeof flexConfig.padding === 'number') {
+                    if (flexConfig.padding < 0) {
+                        errors.push({
+                            path: `group.${group.id}.layout.padding`,
+                            message: `Flexbox padding must be non-negative, got ${flexConfig.padding}`,
+                            code: 'INVALID_FLEX_PADDING',
+                            severity: 'error',
+                        });
+                    }
+                }
+                else {
+                    const p = flexConfig.padding;
+                    if (p.top < 0 || p.right < 0 || p.bottom < 0 || p.left < 0) {
+                        errors.push({
+                            path: `group.${group.id}.layout.padding`,
+                            message: `Flexbox padding values must be non-negative`,
+                            code: 'INVALID_FLEX_PADDING',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+        // 4. Validate grid configuration
+        if (group.layoutType === 'grid' && group.layoutConfig) {
+            const gridConfig = group.layoutConfig;
+            // Validate templateColumns (must be non-empty string)
+            if (!gridConfig.templateColumns || gridConfig.templateColumns.trim() === '') {
+                errors.push({
+                    path: `group.${group.id}.layout.templateColumns`,
+                    message: `Grid templateColumns must be a non-empty string`,
+                    code: 'INVALID_GRID_TEMPLATE_COLUMNS',
+                    severity: 'error',
+                });
+            }
+            // Validate templateRows (must be non-empty string)
+            if (!gridConfig.templateRows || gridConfig.templateRows.trim() === '') {
+                errors.push({
+                    path: `group.${group.id}.layout.templateRows`,
+                    message: `Grid templateRows must be a non-empty string`,
+                    code: 'INVALID_GRID_TEMPLATE_ROWS',
+                    severity: 'error',
+                });
+            }
+            // Validate gaps (must be non-negative)
+            if (gridConfig.columnGap < 0) {
+                errors.push({
+                    path: `group.${group.id}.layout.columnGap`,
+                    message: `Grid columnGap must be non-negative, got ${gridConfig.columnGap}`,
+                    code: 'INVALID_GRID_COLUMN_GAP',
+                    severity: 'error',
+                });
+            }
+            if (gridConfig.rowGap < 0) {
+                errors.push({
+                    path: `group.${group.id}.layout.rowGap`,
+                    message: `Grid rowGap must be non-negative, got ${gridConfig.rowGap}`,
+                    code: 'INVALID_GRID_ROW_GAP',
+                    severity: 'error',
+                });
+            }
+            // Validate autoFlow
+            const validAutoFlow = ['row', 'column', 'dense'];
+            if (!validAutoFlow.includes(gridConfig.autoFlow)) {
+                errors.push({
+                    path: `group.${group.id}.layout.autoFlow`,
+                    message: `Invalid grid autoFlow '${gridConfig.autoFlow}'. Must be one of: ${validAutoFlow.join(', ')}`,
+                    code: 'INVALID_GRID_AUTO_FLOW',
+                    severity: 'error',
+                });
+            }
+            // Validate alignment properties
+            if (gridConfig.justifyItems) {
+                const validJustifyItems = ['start', 'center', 'end', 'stretch'];
+                if (!validJustifyItems.includes(gridConfig.justifyItems)) {
+                    errors.push({
+                        path: `group.${group.id}.layout.justifyItems`,
+                        message: `Invalid grid justifyItems '${gridConfig.justifyItems}'. Must be one of: ${validJustifyItems.join(', ')}`,
+                        code: 'INVALID_GRID_JUSTIFY_ITEMS',
+                        severity: 'error',
+                    });
+                }
+            }
+            if (gridConfig.alignItems) {
+                const validAlignItems = ['start', 'center', 'end', 'stretch'];
+                if (!validAlignItems.includes(gridConfig.alignItems)) {
+                    errors.push({
+                        path: `group.${group.id}.layout.alignItems`,
+                        message: `Invalid grid alignItems '${gridConfig.alignItems}'. Must be one of: ${validAlignItems.join(', ')}`,
+                        code: 'INVALID_GRID_ALIGN_ITEMS',
+                        severity: 'error',
+                    });
+                }
+            }
+            if (gridConfig.justifyContent) {
+                const validJustifyContent = ['start', 'center', 'end', 'space-between', 'space-around', 'space-evenly'];
+                if (!validJustifyContent.includes(gridConfig.justifyContent)) {
+                    errors.push({
+                        path: `group.${group.id}.layout.justifyContent`,
+                        message: `Invalid grid justifyContent '${gridConfig.justifyContent}'. Must be one of: ${validJustifyContent.join(', ')}`,
+                        code: 'INVALID_GRID_JUSTIFY_CONTENT',
+                        severity: 'error',
+                    });
+                }
+            }
+            if (gridConfig.alignContent) {
+                const validAlignContent = ['start', 'center', 'end', 'space-between', 'space-around', 'space-evenly'];
+                if (!validAlignContent.includes(gridConfig.alignContent)) {
+                    errors.push({
+                        path: `group.${group.id}.layout.alignContent`,
+                        message: `Invalid grid alignContent '${gridConfig.alignContent}'. Must be one of: ${validAlignContent.join(', ')}`,
+                        code: 'INVALID_GRID_ALIGN_CONTENT',
+                        severity: 'error',
+                    });
+                }
+            }
+            // Validate padding
+            if (gridConfig.padding !== undefined) {
+                if (typeof gridConfig.padding === 'number') {
+                    if (gridConfig.padding < 0) {
+                        errors.push({
+                            path: `group.${group.id}.layout.padding`,
+                            message: `Grid padding must be non-negative, got ${gridConfig.padding}`,
+                            code: 'INVALID_GRID_PADDING',
+                            severity: 'error',
+                        });
+                    }
+                }
+                else {
+                    const p = gridConfig.padding;
+                    if (p.top < 0 || p.right < 0 || p.bottom < 0 || p.left < 0) {
+                        errors.push({
+                            path: `group.${group.id}.layout.padding`,
+                            message: `Grid padding values must be non-negative`,
+                            code: 'INVALID_GRID_PADDING',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+        // 5. Validate that member nodes have appropriate item configurations
+        if (group.layoutType !== 'none') {
+            for (const memberId of group.members) {
+                const node = diagram.getNode(memberId);
+                if (node) {
+                    if (group.layoutType === 'flexbox') {
+                        // Validate flex item config if present
+                        if (node.flexConfig) {
+                            const flexItem = node.flexConfig;
+                            // Validate flexGrow (must be non-negative)
+                            if (flexItem.flexGrow !== undefined && flexItem.flexGrow < 0) {
+                                errors.push({
+                                    path: `node.${node.id}.flexConfig.flexGrow`,
+                                    message: `Flex item flexGrow must be non-negative, got ${flexItem.flexGrow}`,
+                                    code: 'INVALID_FLEX_GROW',
+                                    severity: 'error',
+                                });
+                            }
+                            // Validate flexShrink (must be non-negative)
+                            if (flexItem.flexShrink !== undefined && flexItem.flexShrink < 0) {
+                                errors.push({
+                                    path: `node.${node.id}.flexConfig.flexShrink`,
+                                    message: `Flex item flexShrink must be non-negative, got ${flexItem.flexShrink}`,
+                                    code: 'INVALID_FLEX_SHRINK',
+                                    severity: 'error',
+                                });
+                            }
+                            // Validate flexBasis (must be non-negative if number)
+                            if (typeof flexItem.flexBasis === 'number' && flexItem.flexBasis < 0) {
+                                errors.push({
+                                    path: `node.${node.id}.flexConfig.flexBasis`,
+                                    message: `Flex item flexBasis must be non-negative, got ${flexItem.flexBasis}`,
+                                    code: 'INVALID_FLEX_BASIS',
+                                    severity: 'error',
+                                });
+                            }
+                            // Validate alignSelf
+                            if (flexItem.alignSelf) {
+                                const validAlignSelf = ['auto', 'start', 'center', 'end', 'stretch', 'baseline'];
+                                if (!validAlignSelf.includes(flexItem.alignSelf)) {
+                                    errors.push({
+                                        path: `node.${node.id}.flexConfig.alignSelf`,
+                                        message: `Invalid flex item alignSelf '${flexItem.alignSelf}'. Must be one of: ${validAlignSelf.join(', ')}`,
+                                        code: 'INVALID_FLEX_ALIGN_SELF',
+                                        severity: 'error',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else if (group.layoutType === 'grid') {
+                        // Validate grid item config if present
+                        if (node.gridConfig) {
+                            const gridItem = node.gridConfig;
+                            // Validate grid line numbers (must be positive if not 'auto')
+                            if (typeof gridItem.columnStart === 'number' && gridItem.columnStart < 1) {
+                                errors.push({
+                                    path: `node.${node.id}.gridConfig.columnStart`,
+                                    message: `Grid item columnStart must be positive (1-based), got ${gridItem.columnStart}`,
+                                    code: 'INVALID_GRID_COLUMN_START',
+                                    severity: 'error',
+                                });
+                            }
+                            if (typeof gridItem.columnEnd === 'number' && gridItem.columnEnd < 1) {
+                                errors.push({
+                                    path: `node.${node.id}.gridConfig.columnEnd`,
+                                    message: `Grid item columnEnd must be positive (1-based), got ${gridItem.columnEnd}`,
+                                    code: 'INVALID_GRID_COLUMN_END',
+                                    severity: 'error',
+                                });
+                            }
+                            if (typeof gridItem.rowStart === 'number' && gridItem.rowStart < 1) {
+                                errors.push({
+                                    path: `node.${node.id}.gridConfig.rowStart`,
+                                    message: `Grid item rowStart must be positive (1-based), got ${gridItem.rowStart}`,
+                                    code: 'INVALID_GRID_ROW_START',
+                                    severity: 'error',
+                                });
+                            }
+                            if (typeof gridItem.rowEnd === 'number' && gridItem.rowEnd < 1) {
+                                errors.push({
+                                    path: `node.${node.id}.gridConfig.rowEnd`,
+                                    message: `Grid item rowEnd must be positive (1-based), got ${gridItem.rowEnd}`,
+                                    code: 'INVALID_GRID_ROW_END',
+                                    severity: 'error',
+                                });
+                            }
+                            // Validate that end is greater than start
+                            if (typeof gridItem.columnStart === 'number' && typeof gridItem.columnEnd === 'number') {
+                                if (gridItem.columnEnd <= gridItem.columnStart) {
+                                    errors.push({
+                                        path: `node.${node.id}.gridConfig`,
+                                        message: `Grid item columnEnd (${gridItem.columnEnd}) must be greater than columnStart (${gridItem.columnStart})`,
+                                        code: 'INVALID_GRID_COLUMN_SPAN',
+                                        severity: 'error',
+                                    });
+                                }
+                            }
+                            if (typeof gridItem.rowStart === 'number' && typeof gridItem.rowEnd === 'number') {
+                                if (gridItem.rowEnd <= gridItem.rowStart) {
+                                    errors.push({
+                                        path: `node.${node.id}.gridConfig`,
+                                        message: `Grid item rowEnd (${gridItem.rowEnd}) must be greater than rowStart (${gridItem.rowStart})`,
+                                        code: 'INVALID_GRID_ROW_SPAN',
+                                        severity: 'error',
+                                    });
+                                }
+                            }
+                            // Validate alignment overrides
+                            if (gridItem.justifySelf) {
+                                const validJustifySelf = ['auto', 'start', 'center', 'end', 'stretch'];
+                                if (!validJustifySelf.includes(gridItem.justifySelf)) {
+                                    errors.push({
+                                        path: `node.${node.id}.gridConfig.justifySelf`,
+                                        message: `Invalid grid item justifySelf '${gridItem.justifySelf}'. Must be one of: ${validJustifySelf.join(', ')}`,
+                                        code: 'INVALID_GRID_JUSTIFY_SELF',
+                                        severity: 'error',
+                                    });
+                                }
+                            }
+                            if (gridItem.alignSelf) {
+                                const validAlignSelf = ['auto', 'start', 'center', 'end', 'stretch'];
+                                if (!validAlignSelf.includes(gridItem.alignSelf)) {
+                                    errors.push({
+                                        path: `node.${node.id}.gridConfig.alignSelf`,
+                                        message: `Invalid grid item alignSelf '${gridItem.alignSelf}'. Must be one of: ${validAlignSelf.join(', ')}`,
+                                        code: 'INVALID_GRID_ALIGN_SELF',
+                                        severity: 'error',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const result = {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+        // Emit validation events
+        if (result.valid) {
+            (_b = this.eventBus) === null || _b === void 0 ? void 0 : _b.emit(event_types_1.DiagramEventTypes.VALIDATION_COMPLETED, {
+                type: 'layout',
+                entityId: group.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        else {
+            (_c = this.eventBus) === null || _c === void 0 ? void 0 : _c.emit(event_types_1.DiagramEventTypes.VALIDATION_FAILED, {
+                type: 'layout',
+                entityId: group.id,
+                result,
+                timestamp: Date.now()
+            });
+        }
+        return result;
+    }
+    /**
+     * Add custom validation rule
+     */
+    addRule(entityType, rule) {
+        if (!this.customRules.has(entityType)) {
+            this.customRules.set(entityType, []);
+        }
+        this.customRules.get(entityType).push(rule);
+    }
+    /**
+     * Remove all custom rules for an entity type
+     */
+    clearRules(entityType) {
+        this.customRules.delete(entityType);
+    }
+    /**
+     * Clear all custom rules
+     */
+    clearAllRules() {
+        this.customRules.clear();
+    }
+    /**
+     * Get custom rules count
+     */
+    getRulesCount(entityType) {
+        var _a;
+        if (entityType) {
+            return ((_a = this.customRules.get(entityType)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        }
+        let total = 0;
+        for (const rules of this.customRules.values()) {
+            total += rules.length;
+        }
+        return total;
+    }
+}
+exports.ValidationEngine = ValidationEngine;
+//# sourceMappingURL=ValidationEngine.js.map