@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/utils/transform.js

@@ -1,200 +0,0 @@
-"use strict";
-// transform.ts - Transform Matrix Utilities (Phase 1.6a)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IDENTITY_MATRIX = void 0;
-exports.multiplyMatrices = multiplyMatrices;
-exports.composeMatrices = composeMatrices;
-exports.createTranslateMatrix = createTranslateMatrix;
-exports.createRotateMatrix = createRotateMatrix;
-exports.createScaleMatrix = createScaleMatrix;
-exports.createSkewMatrix = createSkewMatrix;
-exports.transformPoint = transformPoint;
-exports.invertMatrix = invertMatrix;
-exports.matrixToCSS = matrixToCSS;
-const geometry_types_1 = require("../types/geometry.types");
-Object.defineProperty(exports, "IDENTITY_MATRIX", { enumerable: true, get: function () { return geometry_types_1.IDENTITY_MATRIX; } });
-/**
- * Multiply two transform matrices: A * B
- * Matrix multiplication order matters: A * B ≠ B * A
- *
- * @param a - Left matrix
- * @param b - Right matrix
- * @returns Product matrix
- */
-function multiplyMatrices(a, b) {
-    return {
-        a: a.a * b.a + a.c * b.b,
-        b: a.b * b.a + a.d * b.b,
-        c: a.a * b.c + a.c * b.d,
-        d: a.b * b.c + a.d * b.d,
-        e: a.a * b.e + a.c * b.f + a.e,
-        f: a.b * b.e + a.d * b.f + a.f,
-    };
-}
-/**
- * Compose multiple transform matrices
- * Applied right-to-left: compose(A, B, C) = A * B * C
- * Example: compose(translate, rotate, scale) applies scale first, then rotate, then translate
- *
- * @param matrices - Matrices to compose (applied right-to-left)
- * @returns Composed matrix
- */
-function composeMatrices(...matrices) {
-    if (matrices.length === 0) {
-        return Object.assign({}, geometry_types_1.IDENTITY_MATRIX);
-    }
-    if (matrices.length === 1) {
-        return Object.assign({}, matrices[0]);
-    }
-    // Multiply matrices left to right (applies right to left)
-    let result = matrices[0];
-    for (let i = 1; i < matrices.length; i++) {
-        result = multiplyMatrices(result, matrices[i]);
-    }
-    return result;
-}
-/**
- * Create translation matrix
- *
- * @param x - X translation
- * @param y - Y translation
- * @returns Translation matrix
- */
-function createTranslateMatrix(x, y) {
-    return {
-        a: 1,
-        b: 0,
-        c: 0,
-        d: 1,
-        e: x,
-        f: y,
-    };
-}
-/**
- * Create rotation matrix
- * Rotates around origin (0, 0) or specified origin point
- *
- * @param degrees - Rotation angle in degrees (clockwise)
- * @param origin - Optional rotation origin (default: 0, 0)
- * @returns Rotation matrix
- */
-function createRotateMatrix(degrees, origin) {
-    const rad = (degrees * Math.PI) / 180;
-    const cos = Math.cos(rad);
-    const sin = Math.sin(rad);
-    // Rotate around origin (0, 0)
-    if (!origin || (origin.x === 0 && origin.y === 0)) {
-        return {
-            a: cos,
-            b: sin,
-            c: -sin,
-            d: cos,
-            e: 0,
-            f: 0,
-        };
-    }
-    // Rotate around custom origin:
-    // Operations applied right-to-left:
-    // 3. Translate back (+origin)
-    // 2. Rotate
-    // 1. Translate to origin (-origin)
-    return composeMatrices(createTranslateMatrix(origin.x, origin.y), { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 }, createTranslateMatrix(-origin.x, -origin.y));
-}
-/**
- * Create scale matrix
- * Scales around origin (0, 0) or specified origin point
- *
- * @param x - X scale factor
- * @param y - Y scale factor
- * @param origin - Optional scale origin (default: 0, 0)
- * @returns Scale matrix
- */
-function createScaleMatrix(x, y, origin) {
-    // Scale around origin (0, 0)
-    if (!origin || (origin.x === 0 && origin.y === 0)) {
-        return {
-            a: x,
-            b: 0,
-            c: 0,
-            d: y,
-            e: 0,
-            f: 0,
-        };
-    }
-    // Scale around custom origin:
-    // Operations applied right-to-left:
-    // 3. Translate back (+origin)
-    // 2. Scale
-    // 1. Translate to origin (-origin)
-    return composeMatrices(createTranslateMatrix(origin.x, origin.y), { a: x, b: 0, c: 0, d: y, e: 0, f: 0 }, createTranslateMatrix(-origin.x, -origin.y));
-}
-/**
- * Create skew matrix
- * Skews (shears) along X and Y axes
- *
- * @param x - X skew angle in degrees
- * @param y - Y skew angle in degrees
- * @returns Skew matrix
- */
-function createSkewMatrix(x, y) {
-    const radX = (x * Math.PI) / 180;
-    const radY = (y * Math.PI) / 180;
-    return {
-        a: 1,
-        b: Math.tan(radY),
-        c: Math.tan(radX),
-        d: 1,
-        e: 0,
-        f: 0,
-    };
-}
-/**
- * Transform a point using a matrix
- *
- * @param point - Point to transform
- * @param matrix - Transform matrix
- * @returns Transformed point
- */
-function transformPoint(point, matrix) {
-    return {
-        x: matrix.a * point.x + matrix.c * point.y + matrix.e,
-        y: matrix.b * point.x + matrix.d * point.y + matrix.f,
-        z: point.z,
-    };
-}
-/**
- * Invert a transform matrix
- * Useful for converting global coordinates to local and vice versa
- *
- * @param m - Matrix to invert
- * @returns Inverted matrix
- * @throws Error if matrix is not invertible (determinant is zero)
- */
-function invertMatrix(m) {
-    // Calculate determinant
-    const det = m.a * m.d - m.b * m.c;
-    // Check if matrix is invertible
-    if (Math.abs(det) < 1e-10) {
-        throw new Error('Matrix is not invertible (determinant near zero)');
-    }
-    // Calculate inverse using determinant
-    return {
-        a: m.d / det,
-        b: -m.b / det,
-        c: -m.c / det,
-        d: m.a / det,
-        e: (m.c * m.f - m.d * m.e) / det,
-        f: (m.b * m.e - m.a * m.f) / det,
-    };
-}
-/**
- * Convert transform matrix to CSS matrix() string
- * Format: matrix(a, b, c, d, e, f)
- *
- * @param m - Transform matrix
- * @returns CSS matrix string
- */
-function matrixToCSS(m) {
-    return `matrix(${m.a}, ${m.b}, ${m.c}, ${m.d}, ${m.e}, ${m.f})`;
-}
-//# sourceMappingURL=transform.js.map

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

@@ -1,22 +0,0 @@
-import type { PortModel } from '../models/PortModel';
-import type { DiagramEngine } from '../engine/DiagramEngine';
-/**
- * Creates a connection validator that enforces connection group restrictions
- *
- * Rules:
- * - Nodes in the same connection group can connect to each other
- * - Nodes with no connection group can connect to any node
- * - Nodes in different connection groups cannot connect
- *
- * Usage:
- * ```typescript
- * const validator = createConnectionGroupValidator(engine);
- * connectionStateManager.addValidator(validator);
- * ```
- */
-export declare function createConnectionGroupValidator(engine: DiagramEngine): (sourcePort: PortModel, targetPort: PortModel) => boolean;
-/**
- * Check if a connection between two ports is allowed based on connection groups
- * This is a standalone function that doesn't require a validator to be registered
- */
-export declare function isConnectionAllowedByGroup(sourcePort: PortModel, targetPort: PortModel, engine: DiagramEngine): boolean;

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

@@ -1,56 +0,0 @@
-"use strict";
-// ConnectionGroupValidator - Validates connections based on node connection groups (Phase 3)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConnectionGroupValidator = createConnectionGroupValidator;
-exports.isConnectionAllowedByGroup = isConnectionAllowedByGroup;
-/**
- * Creates a connection validator that enforces connection group restrictions
- *
- * Rules:
- * - Nodes in the same connection group can connect to each other
- * - Nodes with no connection group can connect to any node
- * - Nodes in different connection groups cannot connect
- *
- * Usage:
- * ```typescript
- * const validator = createConnectionGroupValidator(engine);
- * connectionStateManager.addValidator(validator);
- * ```
- */
-function createConnectionGroupValidator(engine) {
-    return (sourcePort, targetPort) => {
-        var _a, _b;
-        const diagram = engine.getDiagram();
-        if (!diagram) {
-            return false; // No diagram, reject connection
-        }
-        // Find nodes for the ports
-        const sourceNode = diagram.getNodeByPortId(sourcePort.id);
-        const targetNode = diagram.getNodeByPortId(targetPort.id);
-        if (!sourceNode || !targetNode) {
-            return false; // Can't find nodes, reject connection
-        }
-        // Get connection groups
-        const sourceGroup = (_a = sourceNode.getConnectionGroup) === null || _a === void 0 ? void 0 : _a.call(sourceNode);
-        const targetGroup = (_b = targetNode.getConnectionGroup) === null || _b === void 0 ? void 0 : _b.call(targetNode);
-        // If neither has a group, allow connection (unrestricted)
-        if (!sourceGroup && !targetGroup) {
-            return true;
-        }
-        // If only one has a group, allow connection (unrestricted node can connect to any group)
-        if (!sourceGroup || !targetGroup) {
-            return true;
-        }
-        // Both have groups - must match
-        return sourceGroup === targetGroup;
-    };
-}
-/**
- * Check if a connection between two ports is allowed based on connection groups
- * This is a standalone function that doesn't require a validator to be registered
- */
-function isConnectionAllowedByGroup(sourcePort, targetPort, engine) {
-    const validator = createConnectionGroupValidator(engine);
-    return validator(sourcePort, targetPort);
-}
-//# sourceMappingURL=ConnectionGroupValidator.js.map

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

@@ -1,179 +0,0 @@
-import type { ValidationResult, NodeBehavior, NodeStyle, Size } from '../types';
-export interface NodeTypeDefinition {
-    type: string;
-    label?: string;
-    description?: string;
-    defaultData?: Record<string, any>;
-    allowedPortTypes?: string[];
-    minPorts?: number;
-    maxPorts?: number;
-    validator?: (node: any) => ValidationResult;
-    extends?: string;
-    category?: string;
-    family?: string;
-    tags?: string[];
-    defaultBehavior?: Partial<NodeBehavior>;
-    defaultStyle?: Partial<NodeStyle>;
-    defaultSize?: Partial<Size>;
-    allowedChildTypes?: string[];
-    allowedParentTypes?: string[];
-    maxChildren?: number;
-    maxDepth?: number;
-    canBeRoot?: boolean;
-    templateId?: string;
-    defaultPortRendering?: any;
-}
-export interface PortTypeDefinition {
-    type: string;
-    label: string;
-    description?: string;
-    direction: 'input' | 'output' | 'bi';
-    maxConnections?: number;
-    allowedLinkTypes?: string[];
-    validator?: (port: any) => ValidationResult;
-}
-export interface LinkTypeDefinition {
-    type: string;
-    label: string;
-    description?: string;
-    allowedSourcePortTypes?: string[];
-    allowedTargetPortTypes?: string[];
-    validator?: (link: any) => ValidationResult;
-}
-export interface GroupTypeDefinition {
-    type: string;
-    label: string;
-    description?: string;
-    allowedMemberTypes?: string[];
-    allowedLinkTypes?: string[];
-    minMembers?: number;
-    maxMembers?: number;
-    canNest?: boolean;
-    allowedLayoutTypes?: ('flexbox' | 'grid')[];
-    requireLayout?: boolean;
-    validator?: (group: any) => ValidationResult;
-}
-export declare class TypeRegistry {
-    private nodeTypes;
-    private portTypes;
-    private linkTypes;
-    private groupTypes;
-    /**
-     * Register a node type
-     */
-    registerNodeType(definition: NodeTypeDefinition): void;
-    /**
-     * Detect circular inheritance in type chain
-     */
-    private detectCircularInheritance;
-    /**
-     * Register a port type
-     */
-    registerPortType(definition: PortTypeDefinition): void;
-    /**
-     * Register a link type
-     */
-    registerLinkType(definition: LinkTypeDefinition): void;
-    /**
-     * Register a group type (Phase 2)
-     */
-    registerGroupType(definition: GroupTypeDefinition): void;
-    /**
-     * Unregister a node type
-     */
-    unregisterNodeType(type: string): boolean;
-    /**
-     * Unregister a port type
-     */
-    unregisterPortType(type: string): boolean;
-    /**
-     * Unregister a link type
-     */
-    unregisterLinkType(type: string): boolean;
-    /**
-     * Unregister a group type (Phase 2)
-     */
-    unregisterGroupType(type: string): boolean;
-    /**
-     * Get node type definition
-     */
-    getNodeType(type: string): NodeTypeDefinition | undefined;
-    /**
-     * Get port type definition
-     */
-    getPortType(type: string): PortTypeDefinition | undefined;
-    /**
-     * Get link type definition
-     */
-    getLinkType(type: string): LinkTypeDefinition | undefined;
-    /**
-     * Get group type definition (Phase 2)
-     */
-    getGroupType(type: string): GroupTypeDefinition | undefined;
-    /**
-     * Check if node type exists
-     */
-    hasNodeType(type: string): boolean;
-    /**
-     * Check if port type exists
-     */
-    hasPortType(type: string): boolean;
-    /**
-     * Check if link type exists
-     */
-    hasLinkType(type: string): boolean;
-    /**
-     * Check if group type exists (Phase 2)
-     */
-    hasGroupType(type: string): boolean;
-    /**
-     * List all node types
-     */
-    listNodeTypes(): NodeTypeDefinition[];
-    /**
-     * List all port types
-     */
-    listPortTypes(): PortTypeDefinition[];
-    /**
-     * List all link types
-     */
-    listLinkTypes(): LinkTypeDefinition[];
-    /**
-     * List all group types (Phase 2)
-     */
-    listGroupTypes(): GroupTypeDefinition[];
-    /**
-     * Clear all registered types
-     */
-    clear(): void;
-    /**
-     * Get type statistics
-     */
-    getStats(): {
-        nodeTypes: number;
-        portTypes: number;
-        linkTypes: number;
-        groupTypes: number;
-    };
-    /**
-     * Resolve a node type with all inherited properties
-     */
-    resolveNodeType(type: string): NodeTypeDefinition;
-    /**
-     * Get all node types in a category
-     */
-    getNodeTypesByCategory(category: string): NodeTypeDefinition[];
-    /**
-     * Get all node types in a family
-     */
-    getNodeTypesByFamily(family: string): NodeTypeDefinition[];
-    /**
-     * Get all node types with a specific tag
-     */
-    getNodeTypesByTag(tag: string): NodeTypeDefinition[];
-    /**
-     * Get all node types using a specific template (Phase 2)
-     * Includes types that inherit template ID from parent
-     */
-    getNodeTypesByTemplate(templateId: string): NodeTypeDefinition[];
-}