@grafloria/element 0.3.20 → 0.3.22

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

@@ -1,388 +0,0 @@
-"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

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

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

@@ -1,6 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-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

@@ -1,131 +0,0 @@
-"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

@@ -1,27 +0,0 @@
-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[];