@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/plugins/PluginManager.js

@@ -0,0 +1,388 @@
+"use strict";
+// PluginManager - Manages plugin lifecycle and dependencies
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const tslib_1 = require("tslib");
+class PluginManager {
+    constructor(engine, eventBus, config = {}) {
+        this.plugins = new Map();
+        this.installationOrder = [];
+        this.config = Object.assign({ autoActivate: true, strict: false }, config);
+        this.context = {
+            engine,
+            eventBus,
+            config: {},
+        };
+    }
+    /**
+     * Register a plugin (without installing)
+     */
+    register(plugin, config = {}) {
+        var _a;
+        const name = plugin.metadata.name;
+        if (this.plugins.has(name)) {
+            throw new Error(`Plugin '${name}' is already registered`);
+        }
+        this.plugins.set(name, {
+            plugin,
+            installed: false,
+            active: false,
+            config,
+            error: undefined,
+        });
+        (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:registered', { name, metadata: plugin.metadata });
+    }
+    /**
+     * Install a plugin
+     */
+    install(pluginName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const state = this.plugins.get(pluginName);
+            if (!state) {
+                throw new Error(`Plugin '${pluginName}' is not registered`);
+            }
+            if (state.installed) {
+                throw new Error(`Plugin '${pluginName}' is already installed`);
+            }
+            try {
+                // Check dependencies
+                yield this.checkDependencies(state.plugin);
+                // Create plugin context with config
+                const pluginContext = Object.assign(Object.assign({}, this.context), { config: state.config });
+                // Call install hook
+                yield state.plugin.install(pluginContext);
+                // Update state
+                state.installed = true;
+                this.installationOrder.push(pluginName);
+                (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:installed', {
+                    name: pluginName,
+                    metadata: state.plugin.metadata,
+                });
+                // Auto-activate if configured
+                if (this.config.autoActivate) {
+                    yield this.activate(pluginName);
+                }
+            }
+            catch (error) {
+                state.error = error;
+                (_b = this.context.eventBus) === null || _b === void 0 ? void 0 : _b.emit('plugin:error', {
+                    name: pluginName,
+                    error: error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Uninstall a plugin
+     */
+    uninstall(pluginName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const state = this.plugins.get(pluginName);
+            if (!state) {
+                throw new Error(`Plugin '${pluginName}' is not registered`);
+            }
+            if (!state.installed) {
+                throw new Error(`Plugin '${pluginName}' is not installed`);
+            }
+            try {
+                // Deactivate if active
+                if (state.active) {
+                    yield this.deactivate(pluginName);
+                }
+                // Create plugin context
+                const pluginContext = Object.assign(Object.assign({}, this.context), { config: state.config });
+                // Call uninstall hook if exists
+                if (state.plugin.uninstall) {
+                    yield state.plugin.uninstall(pluginContext);
+                }
+                // Update state
+                state.installed = false;
+                state.error = undefined;
+                // Remove from installation order
+                const index = this.installationOrder.indexOf(pluginName);
+                if (index !== -1) {
+                    this.installationOrder.splice(index, 1);
+                }
+                (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:uninstalled', {
+                    name: pluginName,
+                    metadata: state.plugin.metadata,
+                });
+            }
+            catch (error) {
+                state.error = error;
+                (_b = this.context.eventBus) === null || _b === void 0 ? void 0 : _b.emit('plugin:error', {
+                    name: pluginName,
+                    error: error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Activate a plugin
+     */
+    activate(pluginName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const state = this.plugins.get(pluginName);
+            if (!state) {
+                throw new Error(`Plugin '${pluginName}' is not registered`);
+            }
+            if (!state.installed) {
+                throw new Error(`Plugin '${pluginName}' is not installed. Install it first.`);
+            }
+            if (state.active) {
+                return; // Already active
+            }
+            try {
+                // Create plugin context
+                const pluginContext = Object.assign(Object.assign({}, this.context), { config: state.config });
+                // Call activate hook if exists
+                if (state.plugin.onActivate) {
+                    state.plugin.onActivate(pluginContext);
+                }
+                // Update state
+                state.active = true;
+                (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:activated', {
+                    name: pluginName,
+                    metadata: state.plugin.metadata,
+                });
+            }
+            catch (error) {
+                state.error = error;
+                (_b = this.context.eventBus) === null || _b === void 0 ? void 0 : _b.emit('plugin:error', {
+                    name: pluginName,
+                    error: error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Deactivate a plugin
+     */
+    deactivate(pluginName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const state = this.plugins.get(pluginName);
+            if (!state) {
+                throw new Error(`Plugin '${pluginName}' is not registered`);
+            }
+            if (!state.active) {
+                return; // Already inactive
+            }
+            try {
+                // Create plugin context
+                const pluginContext = Object.assign(Object.assign({}, this.context), { config: state.config });
+                // Call deactivate hook if exists
+                if (state.plugin.onDeactivate) {
+                    state.plugin.onDeactivate(pluginContext);
+                }
+                // Update state
+                state.active = false;
+                (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:deactivated', {
+                    name: pluginName,
+                    metadata: state.plugin.metadata,
+                });
+            }
+            catch (error) {
+                state.error = error;
+                (_b = this.context.eventBus) === null || _b === void 0 ? void 0 : _b.emit('plugin:error', {
+                    name: pluginName,
+                    error: error,
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Get plugin by name
+     */
+    get(pluginName) {
+        var _a;
+        return (_a = this.plugins.get(pluginName)) === null || _a === void 0 ? void 0 : _a.plugin;
+    }
+    /**
+     * Check if plugin is registered
+     */
+    has(pluginName) {
+        return this.plugins.has(pluginName);
+    }
+    /**
+     * Check if plugin is installed
+     */
+    isInstalled(pluginName) {
+        var _a, _b;
+        return (_b = (_a = this.plugins.get(pluginName)) === null || _a === void 0 ? void 0 : _a.installed) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Check if plugin is active
+     */
+    isActive(pluginName) {
+        var _a, _b;
+        return (_b = (_a = this.plugins.get(pluginName)) === null || _a === void 0 ? void 0 : _a.active) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Get plugin state
+     */
+    getState(pluginName) {
+        return this.plugins.get(pluginName);
+    }
+    /**
+     * List all registered plugins
+     */
+    list() {
+        return Array.from(this.plugins.values()).map((state) => state.plugin.metadata);
+    }
+    /**
+     * List installed plugins
+     */
+    listInstalled() {
+        return Array.from(this.plugins.values())
+            .filter((state) => state.installed)
+            .map((state) => state.plugin.metadata);
+    }
+    /**
+     * List active plugins
+     */
+    listActive() {
+        return Array.from(this.plugins.values())
+            .filter((state) => state.active)
+            .map((state) => state.plugin.metadata);
+    }
+    /**
+     * Unregister a plugin (removes from registry)
+     */
+    unregister(pluginName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const state = this.plugins.get(pluginName);
+            if (!state) {
+                return; // Not registered
+            }
+            // Uninstall if installed
+            if (state.installed) {
+                yield this.uninstall(pluginName);
+            }
+            // Remove from registry
+            this.plugins.delete(pluginName);
+            (_a = this.context.eventBus) === null || _a === void 0 ? void 0 : _a.emit('plugin:unregistered', {
+                name: pluginName,
+                metadata: state.plugin.metadata,
+            });
+        });
+    }
+    /**
+     * Install all registered plugins
+     */
+    installAll() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const pluginNames = Array.from(this.plugins.keys());
+            // Sort by dependencies
+            const sorted = yield this.topologicalSort(pluginNames);
+            for (const name of sorted) {
+                const state = this.plugins.get(name);
+                if (state && !state.installed) {
+                    yield this.install(name);
+                }
+            }
+        });
+    }
+    /**
+     * Uninstall all plugins
+     */
+    uninstallAll() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Uninstall in reverse order
+            const reversed = [...this.installationOrder].reverse();
+            for (const name of reversed) {
+                const state = this.plugins.get(name);
+                if (state && state.installed) {
+                    yield this.uninstall(name);
+                }
+            }
+        });
+    }
+    /**
+     * Clear all plugins (uninstall and unregister)
+     */
+    clear() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.uninstallAll();
+            this.plugins.clear();
+            this.installationOrder = [];
+        });
+    }
+    /**
+     * Check plugin dependencies
+     */
+    checkDependencies(plugin) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!plugin.metadata.dependencies || plugin.metadata.dependencies.length === 0) {
+                return;
+            }
+            const missing = [];
+            const notInstalled = [];
+            for (const dep of plugin.metadata.dependencies) {
+                if (!this.has(dep)) {
+                    missing.push(dep);
+                }
+                else if (!this.isInstalled(dep)) {
+                    notInstalled.push(dep);
+                }
+            }
+            if (missing.length > 0) {
+                const error = `Missing dependencies for plugin '${plugin.metadata.name}': ${missing.join(', ')}`;
+                if (this.config.strict) {
+                    throw new Error(error);
+                }
+                else {
+                    console.warn(error);
+                }
+            }
+            if (notInstalled.length > 0) {
+                const error = `Uninstalled dependencies for plugin '${plugin.metadata.name}': ${notInstalled.join(', ')}`;
+                if (this.config.strict) {
+                    throw new Error(error);
+                }
+                else {
+                    console.warn(error);
+                }
+            }
+        });
+    }
+    /**
+     * Topological sort for dependency resolution
+     */
+    topologicalSort(pluginNames) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const visited = new Set();
+            const result = [];
+            const visit = (name) => {
+                var _a;
+                if (visited.has(name)) {
+                    return;
+                }
+                visited.add(name);
+                const plugin = (_a = this.plugins.get(name)) === null || _a === void 0 ? void 0 : _a.plugin;
+                if (plugin === null || plugin === void 0 ? void 0 : plugin.metadata.dependencies) {
+                    for (const dep of plugin.metadata.dependencies) {
+                        if (pluginNames.includes(dep)) {
+                            visit(dep);
+                        }
+                    }
+                }
+                result.push(name);
+            };
+            for (const name of pluginNames) {
+                visit(name);
+            }
+            return result;
+        });
+    }
+}
+exports.PluginManager = PluginManager;
+//# sourceMappingURL=PluginManager.js.map

package/src/libs/engine/src/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from './PluginManager';

package/src/libs/engine/src/plugins/index.js

@@ -0,0 +1,6 @@
+"use strict";
+// Plugins index - exports plugin system components
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./PluginManager"), exports);
+//# sourceMappingURL=index.js.map

package/src/libs/engine/src/ports/connection-rules.d.ts

@@ -0,0 +1,32 @@
+import type { LinkModel } from '../models/LinkModel';
+import type { NodeModel } from '../models/NodeModel';
+import type { PortModel } from '../models/PortModel';
+export type ConnectionRejectionReason = 'self-port' | 'self-link' | 'not-connectable-start' | 'not-connectable-end' | 'node-not-connectable' | 'direction' | 'data-type' | 'allowed-types' | 'max-connections' | 'from-max-links' | 'to-max-links' | 'duplicate-link' | 'connection-group' | 'custom';
+export interface ConnectionVerdict {
+    ok: boolean;
+    reason?: ConnectionRejectionReason;
+    /** Human-readable, safe to surface in a tooltip / live region. */
+    message?: string;
+}
+export interface ConnectionRuleContext {
+    sourceNode?: NodeModel;
+    targetNode?: NodeModel;
+    /** The diagram's links — needed for the duplicate-link rule. */
+    links?: LinkModel[];
+    /**
+     * Reject a second link between the same ordered port pair EVEN when the ports
+     * allow duplicates. Proximity-connect passes this (auto-linking a duplicate on
+     * a drag-near is never what the user meant); the explicit connection drag does
+     * not, preserving its historical permissiveness.
+     */
+    rejectDuplicatesByDefault?: boolean;
+    /** Extra host rules (connection groups, ACLs…). Run last. */
+    validators?: Array<(source: PortModel, target: PortModel) => boolean>;
+}
+/**
+ * May a link be created FROM `source` TO `target`? Directional — swapping the
+ * arguments is a different question and may well get a different answer.
+ */
+export declare function evaluatePortConnection(source: PortModel, target: PortModel, context?: ConnectionRuleContext): ConnectionVerdict;
+/** Boolean facade for call sites that don't care WHY. */
+export declare function canConnectPortsWithRules(source: PortModel, target: PortModel, context?: ConnectionRuleContext): boolean;

package/src/libs/engine/src/ports/connection-rules.js

@@ -0,0 +1,131 @@
+"use strict";
+// connection-rules.ts — Wave 6 (Ports & connections), Card 2.
+//
+// THE connection validator. One function, one answer, one reason.
+//
+// Before wave 6 the "can these two ports connect?" question had THREE separate
+// implementations that did not agree with each other:
+//
+//   1. `PortModel.canConnectTo`            — capacity + input/output rules
+//   2. `ConnectionStateManager.isValidConnection` — capacity NOT checked, plus
+//                                            same-node and same-port rules
+//   3. `canConnectPorts` (renderer/snapping) — node.behavior, connection groups
+//                                            and a no-duplicates rule the other
+//                                            two had never heard of
+//
+// So the interactive drag would happily create a link the proximity-connect
+// magnet considered illegal, and vice versa. Everything now funnels through
+// `evaluatePortConnection`, which returns a REASON as well as a verdict — the
+// renderer needs the reason to draw the "why not" cue on a rejected target
+// (Card 6).
+//
+// Every wave-6 gate is opt-in and every default reproduces pre-wave-6 behaviour.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluatePortConnection = evaluatePortConnection;
+exports.canConnectPortsWithRules = canConnectPortsWithRules;
+const port_groups_1 = require("./port-groups");
+const port_type_registry_1 = require("./port-type-registry");
+const OK = { ok: true };
+function no(reason, message) {
+    return { ok: false, reason, message };
+}
+/**
+ * May a link be created FROM `source` TO `target`? Directional — swapping the
+ * arguments is a different question and may well get a different answer.
+ */
+function evaluatePortConnection(source, target, context = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const sourceNode = context.sourceNode;
+    const targetNode = context.targetNode;
+    const sourceConfig = (0, port_groups_1.resolvePortConfig)(source, sourceNode);
+    const targetConfig = (0, port_groups_1.resolvePortConfig)(target, targetNode);
+    const sourceGating = sourceConfig.gating;
+    const targetGating = targetConfig.gating;
+    // --- identity ------------------------------------------------------------
+    const sameNode = (sourceNode && targetNode && sourceNode.id === targetNode.id) ||
+        (!!source.nodeId && source.nodeId === target.nodeId);
+    if (source.id === target.id) {
+        // A port linked to ITSELF needs self-links allowed on that one port.
+        if (!sourceGating.allowSelfLink) {
+            return no('self-port', 'A port cannot connect to itself.');
+        }
+    }
+    else if (sameNode && !(sourceGating.allowSelfLink && targetGating.allowSelfLink)) {
+        return no('self-link', 'This node does not allow links to itself.');
+    }
+    // --- node-level opt-out (was only ever enforced in the snapping path) -----
+    if (((_a = sourceNode === null || sourceNode === void 0 ? void 0 : sourceNode.behavior) === null || _a === void 0 ? void 0 : _a.connectable) === false || ((_b = targetNode === null || targetNode === void 0 ? void 0 : targetNode.behavior) === null || _b === void 0 ? void 0 : _b.connectable) === false) {
+        return no('node-not-connectable', 'This node cannot be connected.');
+    }
+    // --- drag handles are CHROME, not anatomy ---------------------------------
+    // A node that declares itself a drag handle exists to move its parent. To the
+    // user it IS part of the parent — wiring a window's title bar to the window's
+    // body reads as "I connected the node to itself" (a live report). Handles
+    // neither start nor receive links.
+    if (((_d = (_c = sourceNode === null || sourceNode === void 0 ? void 0 : sourceNode.behavior) === null || _c === void 0 ? void 0 : _c.dragHandler) === null || _d === void 0 ? void 0 : _d.isDragHandler) === true ||
+        ((_f = (_e = targetNode === null || targetNode === void 0 ? void 0 : targetNode.behavior) === null || _e === void 0 ? void 0 : _e.dragHandler) === null || _f === void 0 ? void 0 : _f.isDragHandler) === true) {
+        return no('node-not-connectable', 'A drag handle cannot be wired.');
+    }
+    // --- directional connectability (Card 2) ---------------------------------
+    if (!sourceGating.isConnectableStart) {
+        return no('not-connectable-start', 'A link cannot start at this port.');
+    }
+    if (!targetGating.isConnectableEnd) {
+        return no('not-connectable-end', 'A link cannot end at this port.');
+    }
+    // --- input/output direction ----------------------------------------------
+    const isBi = (port) => port.type === 'bi';
+    if (!isBi(source) && !isBi(target) && source.type === target.type) {
+        return no('direction', `A ${source.type} port cannot connect to another ${target.type} port.`);
+    }
+    // --- typed data flow (Card 7) --------------------------------------------
+    if (!(0, port_type_registry_1.arePortDataTypesCompatible)(sourceConfig.dataType, targetConfig.dataType)) {
+        return no('data-type', `Incompatible types: ${sourceConfig.dataType} cannot flow into ${targetConfig.dataType}.`);
+    }
+    // --- allowedTypes whitelist (dead config until wave 6) --------------------
+    if (sourceGating.allowedTypes.length && !sourceGating.allowedTypes.includes(target.typeIdentity())) {
+        return no('allowed-types', `This port does not accept "${target.typeIdentity()}".`);
+    }
+    if (targetGating.allowedTypes.length && !targetGating.allowedTypes.includes(source.typeIdentity())) {
+        return no('allowed-types', `That port does not accept "${source.typeIdentity()}".`);
+    }
+    // --- capacity ------------------------------------------------------------
+    // The TOTAL cap. `null` is the explicit "unlimited" sentinel — never coerce it
+    // to 0, which is the exact bug that once made every port with an Infinity cap
+    // permanently unconnectable after a JSON round-trip.
+    if (sourceGating.maxConnections !== null && source.getConnectionCount() >= sourceGating.maxConnections) {
+        return no('max-connections', 'This port has reached its connection limit.');
+    }
+    if (targetGating.maxConnections !== null && target.getConnectionCount() >= targetGating.maxConnections) {
+        return no('max-connections', 'That port has reached its connection limit.');
+    }
+    if (sourceGating.fromMaxLinks !== null && source.getFromLinkCount() >= sourceGating.fromMaxLinks) {
+        return no('from-max-links', 'This port has reached its outgoing-link limit.');
+    }
+    if (targetGating.toMaxLinks !== null && target.getToLinkCount() >= targetGating.toMaxLinks) {
+        return no('to-max-links', 'That port has reached its incoming-link limit.');
+    }
+    // --- duplicates ----------------------------------------------------------
+    const rejectDuplicates = !sourceGating.allowDuplicateLinks ||
+        !targetGating.allowDuplicateLinks ||
+        context.rejectDuplicatesByDefault === true;
+    if (rejectDuplicates && ((_g = context.links) === null || _g === void 0 ? void 0 : _g.length)) {
+        const already = context.links.some((link) => (link.sourcePortId === source.id && link.targetPortId === target.id) ||
+            (link.sourcePortId === target.id && link.targetPortId === source.id));
+        if (already) {
+            return no('duplicate-link', 'These ports are already connected.');
+        }
+    }
+    // --- host rules (connection groups, ACLs…) -------------------------------
+    for (const validator of (_h = context.validators) !== null && _h !== void 0 ? _h : []) {
+        if (!validator(source, target)) {
+            return no('custom', 'This connection is not allowed.');
+        }
+    }
+    return OK;
+}
+/** Boolean facade for call sites that don't care WHY. */
+function canConnectPortsWithRules(source, target, context = {}) {
+    return evaluatePortConnection(source, target, context).ok;
+}
+//# sourceMappingURL=connection-rules.js.map

package/src/libs/engine/src/ports/dynamic-ports.d.ts

@@ -0,0 +1,27 @@
+import type { Command } from '../commands/Command';
+import type { DiagramModel } from '../models/DiagramModel';
+import type { LinkModel } from '../models/LinkModel';
+import type { NodeModel } from '../models/NodeModel';
+import { PortModel } from '../models/PortModel';
+export interface DynamicPortPlan {
+    /** Ports to create, in order. */
+    add: PortModel[];
+    /** Ids of surplus free ports to retire. */
+    remove: string[];
+}
+/**
+ * What must change so every dynamic group on `node` offers exactly `spare` free
+ * ports? Idempotent: run it on a settled node and it returns an empty plan.
+ *
+ * A port is "free" when it carries no links. Only ports the allocator itself
+ * spawned (`dynamic: true`) are ever REMOVED — an authored port the user simply
+ * hasn't wired yet is not surplus, it is the design.
+ */
+export declare function planDynamicPorts(node: NodeModel, links?: LinkModel[]): DynamicPortPlan;
+/**
+ * The plan, as undoable commands. Empty array when nothing is due — so a caller
+ * can drive this on every link change without polluting the undo stack.
+ */
+export declare function buildDynamicPortCommands(node: NodeModel, links?: LinkModel[]): Command[];
+/** Every node in the diagram that owes the allocator work. */
+export declare function buildDynamicPortCommandsForDiagram(diagram: DiagramModel): Command[];