@grafloria/element 0.3.20 → 0.3.21

package/src/libs/renderer/src/ext/diagram-registry.d.ts

@@ -1,109 +0,0 @@
-/**
- * ============================================================================
- * `DiagramRegistry` — one diagram's contribution surface
- * ============================================================================
- *
- * Every method here exists as a module-level function already. What this adds is
- * an ANSWER TO "WHOSE?".
- *
- *   registerShape('badge', …)          // the process. Everyone's.
- *   diagram.registry.registerShape(…)  // this diagram. Nobody else's.
- *
- * The two layer: a diagram resolves a name against its own table first and falls
- * through to the process-global registry, so an app that registers its shape
- * library once at import time keeps working unchanged in every diagram, and a
- * single diagram can still override one name for itself without mutating what
- * the diagram beside it sees.
- *
- * ONE IMPLEMENTATION, TWO BINDINGS. `GLOBAL_DIAGRAM_REGISTRY` is this same class
- * with a null scope, so the process-wide path and the per-diagram path are the
- * same code with the same disposer semantics. That is deliberate: the previous
- * arrangement had the ExtensionHost's restore-on-dispose logic written once, for
- * the global registries only, and the whole bug was that it then ran on behalf
- * of a diagram that did not own what it was restoring.
- *
- * DISPOSERS RESTORE, they do not merely delete — the rule `ext/disposable.ts`
- * states. Scoped disposers restore the SCOPE's previous entry, which may be
- * "nothing", in which case the global definition becomes visible again. That
- * layering is the point: unloading a diagram's override reveals the built-in,
- * it does not punch a hole through to the fallback.
- */
-import type { Disposer } from './disposable';
-import { RegistryScope } from './registry-scope';
-import type { PathGeometry, PathShapeOptions, ShapeDefinition } from '../svg/shape-registry';
-import type { NamedStyle } from '../themes/style-registry';
-import type { LabelTemplate, LinkTemplate, MarkerDefinition } from '../svg/edge-templates';
-import type { AnchorFn, ConnectionPointFn, ConnectorFn } from './link-pipeline';
-import { CustomAnimationRegistry } from '../services/custom-animation-registry';
-/**
- * The contribution surface. Obtained from a diagram as `diagram.registry`, or as
- * {@link GLOBAL_DIAGRAM_REGISTRY} for the process-wide one.
- */
-export declare class DiagramRegistry {
-    private readonly scope;
-    /**
-     * @param scope this diagram's private tables, or `null` for the
-     *              process-global registries.
-     */
-    constructor(scope?: RegistryScope | null);
-    /** True when writes here are private to one diagram. */
-    get isScoped(): boolean;
-    registerShape(type: string, definition: Omit<ShapeDefinition, 'type'> & {
-        type?: string;
-    }): Disposer;
-    registerPathShape(type: string, path: PathGeometry, options?: PathShapeOptions): Disposer;
-    unregisterShape(type: string): boolean;
-    hasShape(type: string): boolean;
-    listShapes(): string[];
-    getShapeDefinition(type: string): ShapeDefinition | undefined;
-    defineStyle(name: string, style: NamedStyle): Disposer;
-    defineStyles(styles: Record<string, NamedStyle>): Disposer;
-    removeStyle(name: string): boolean;
-    /**
-     * Drop THIS diagram's named styles. The process-global ones are untouched and
-     * become visible again — which is what makes this safe to call from a teardown
-     * that has no idea what else is on the page.
-     */
-    clearStyles(): void;
-    getStyle(name: string): NamedStyle | undefined;
-    hasStyle(name: string): boolean;
-    listStyles(): string[];
-    registerLinkTemplate(name: string, template: LinkTemplate): Disposer;
-    registerLabelTemplate(name: string, template: LabelTemplate): Disposer;
-    registerMarker(name: string, definition: MarkerDefinition): Disposer;
-    getLinkTemplate(name: string): LinkTemplate | undefined;
-    getLabelTemplate(name: string): LabelTemplate | undefined;
-    getMarker(name: string): MarkerDefinition | undefined;
-    hasMarker(name: string): boolean;
-    listLinkTemplates(): string[];
-    listLabelTemplates(): string[];
-    listMarkers(): string[];
-    registerAnchor(name: string, anchor: AnchorFn): Disposer;
-    registerConnectionPoint(name: string, strategy: ConnectionPointFn): Disposer;
-    registerConnector(name: string, connector: ConnectorFn): Disposer;
-    listAnchors(): string[];
-    listConnectionPoints(): string[];
-    listConnectors(): string[];
-    /**
-     * This diagram's own {@link CustomAnimationRegistry}, or the process-global
-     * singleton when unscoped.
-     *
-     * Lazy: the constructor appends a `<style>` element to the document, so a
-     * diagram that never contributes an animation must not pay for one.
-     */
-    get animations(): CustomAnimationRegistry;
-    private ownAnimations;
-    /** Drop every contribution this diagram made. No-op on the global registry. */
-    dispose(): void;
-    /**
-     * Run a READ with this diagram's scope active.
-     *
-     * Every accessor above goes through here rather than reading the module maps,
-     * because the shadowing rule (mine first, then the process) must be identical
-     * whether a name is being resolved by a render pass or by a host asking
-     * `listShapes()`. Two implementations of that rule would drift.
-     */
-    private read;
-}
-/** The process-wide registry — what the module-level `register*` functions write to. */
-export declare const GLOBAL_DIAGRAM_REGISTRY: DiagramRegistry;

package/src/libs/renderer/src/ext/diagram-registry.js

@@ -1,303 +0,0 @@
-"use strict";
-/**
- * ============================================================================
- * `DiagramRegistry` — one diagram's contribution surface
- * ============================================================================
- *
- * Every method here exists as a module-level function already. What this adds is
- * an ANSWER TO "WHOSE?".
- *
- *   registerShape('badge', …)          // the process. Everyone's.
- *   diagram.registry.registerShape(…)  // this diagram. Nobody else's.
- *
- * The two layer: a diagram resolves a name against its own table first and falls
- * through to the process-global registry, so an app that registers its shape
- * library once at import time keeps working unchanged in every diagram, and a
- * single diagram can still override one name for itself without mutating what
- * the diagram beside it sees.
- *
- * ONE IMPLEMENTATION, TWO BINDINGS. `GLOBAL_DIAGRAM_REGISTRY` is this same class
- * with a null scope, so the process-wide path and the per-diagram path are the
- * same code with the same disposer semantics. That is deliberate: the previous
- * arrangement had the ExtensionHost's restore-on-dispose logic written once, for
- * the global registries only, and the whole bug was that it then ran on behalf
- * of a diagram that did not own what it was restoring.
- *
- * DISPOSERS RESTORE, they do not merely delete — the rule `ext/disposable.ts`
- * states. Scoped disposers restore the SCOPE's previous entry, which may be
- * "nothing", in which case the global definition becomes visible again. That
- * layering is the point: unloading a diagram's override reveals the built-in,
- * it does not punch a hole through to the fallback.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLOBAL_DIAGRAM_REGISTRY = exports.DiagramRegistry = void 0;
-const disposable_1 = require("./disposable");
-const registry_scope_1 = require("./registry-scope");
-const shape_registry_1 = require("../svg/shape-registry");
-const style_registry_1 = require("../themes/style-registry");
-const edge_templates_1 = require("../svg/edge-templates");
-const link_pipeline_1 = require("./link-pipeline");
-const custom_animation_registry_1 = require("../services/custom-animation-registry");
-/**
- * Write `value` into one of THIS diagram's tables and hand back the undo.
- *
- * `had` is captured separately from `previous` because a registration whose
- * value is legitimately `undefined` must still restore as "present", and
- * `previous === undefined` cannot tell those apart.
- */
-function setScoped(scope, table, key, value, notify) {
-    const map = scope.table(table);
-    const had = map.has(key);
-    const previous = map.get(key);
-    map.set(key, value);
-    notify();
-    return (0, disposable_1.once)(() => {
-        if (had)
-            map.set(key, previous);
-        else
-            map.delete(key);
-        notify();
-    });
-}
-/** Read the process-global registry even if a scope happens to be active. */
-function global(read) {
-    return (0, registry_scope_1.runInRegistryScope)(null, read);
-}
-/**
- * The contribution surface. Obtained from a diagram as `diagram.registry`, or as
- * {@link GLOBAL_DIAGRAM_REGISTRY} for the process-wide one.
- */
-class DiagramRegistry {
-    /**
-     * @param scope this diagram's private tables, or `null` for the
-     *              process-global registries.
-     */
-    constructor(scope = null) {
-        this.scope = scope;
-    }
-    /** True when writes here are private to one diagram. */
-    get isScoped() {
-        return this.scope !== null;
-    }
-    // -- shapes ---------------------------------------------------------------
-    registerShape(type, definition) {
-        const value = Object.assign(Object.assign({}, definition), { type });
-        if (!this.scope) {
-            const previous = global(() => (0, shape_registry_1.getShapeDefinition)(type));
-            (0, shape_registry_1.registerShape)(type, definition);
-            return (0, disposable_1.once)(() => {
-                if (previous)
-                    (0, shape_registry_1.registerShape)(type, previous);
-                else
-                    (0, shape_registry_1.unregisterShape)(type);
-            });
-        }
-        return setScoped(this.scope, registry_scope_1.SHAPES, type, value, shape_registry_1.notifyShapeRegistered);
-    }
-    registerPathShape(type, path, options) {
-        // Built through the SAME builder the global path uses, so a scoped path
-        // shape cannot differ in geometry from a global one.
-        return this.registerShape(type, (0, shape_registry_1.buildPathShapeDefinition)(type, path, options));
-    }
-    unregisterShape(type) {
-        if (!this.scope)
-            return (0, shape_registry_1.unregisterShape)(type);
-        const map = this.scope.table(registry_scope_1.SHAPES);
-        const existed = map.delete(type);
-        if (existed)
-            (0, shape_registry_1.notifyShapeRegistered)();
-        return existed;
-    }
-    hasShape(type) {
-        return this.read(() => (0, shape_registry_1.hasShape)(type));
-    }
-    listShapes() {
-        return this.read(() => (0, shape_registry_1.listShapes)());
-    }
-    getShapeDefinition(type) {
-        return this.read(() => (0, shape_registry_1.getShapeDefinition)(type));
-    }
-    // -- named styles ---------------------------------------------------------
-    defineStyle(name, style) {
-        if (!this.scope) {
-            const previous = global(() => (0, style_registry_1.getStyle)(name));
-            (0, style_registry_1.defineStyle)(name, style);
-            return (0, disposable_1.once)(() => {
-                if (previous)
-                    (0, style_registry_1.defineStyle)(name, previous);
-                else
-                    (0, style_registry_1.removeStyle)(name);
-            });
-        }
-        // Copied, matching `defineStyle`: later mutation of the caller's object
-        // must not reach into the registry.
-        return setScoped(this.scope, registry_scope_1.STYLES, name, Object.assign({}, style), style_registry_1.notifyStyleRegistryChanged);
-    }
-    defineStyles(styles) {
-        if (!this.scope) {
-            const undo = Object.keys(styles).map((name) => {
-                const previous = global(() => (0, style_registry_1.getStyle)(name));
-                return () => (previous ? (0, style_registry_1.defineStyle)(name, previous) : (0, style_registry_1.removeStyle)(name));
-            });
-            (0, style_registry_1.defineStyles)(styles);
-            return (0, disposable_1.once)(() => undo.forEach((u) => u()));
-        }
-        const undo = Object.entries(styles).map(([name, style]) => setScoped(this.scope, registry_scope_1.STYLES, name, Object.assign({}, style), style_registry_1.notifyStyleRegistryChanged));
-        return (0, disposable_1.once)(() => undo.forEach((u) => u()));
-    }
-    removeStyle(name) {
-        if (!this.scope)
-            return (0, style_registry_1.removeStyle)(name);
-        const existed = this.scope.table(registry_scope_1.STYLES).delete(name);
-        if (existed)
-            (0, style_registry_1.notifyStyleRegistryChanged)();
-        return existed;
-    }
-    /**
-     * Drop THIS diagram's named styles. The process-global ones are untouched and
-     * become visible again — which is what makes this safe to call from a teardown
-     * that has no idea what else is on the page.
-     */
-    clearStyles() {
-        if (!this.scope) {
-            (0, style_registry_1.clearStyles)();
-            return;
-        }
-        const map = this.scope.table(registry_scope_1.STYLES);
-        if (map.size === 0)
-            return;
-        map.clear();
-        (0, style_registry_1.notifyStyleRegistryChanged)();
-    }
-    getStyle(name) {
-        return this.read(() => (0, style_registry_1.getStyle)(name));
-    }
-    hasStyle(name) {
-        return this.read(() => (0, style_registry_1.hasStyle)(name));
-    }
-    listStyles() {
-        return this.read(() => (0, style_registry_1.listStyles)());
-    }
-    // -- link visuals ---------------------------------------------------------
-    registerLinkTemplate(name, template) {
-        if (!this.scope) {
-            const previous = global(() => (0, edge_templates_1.getLinkTemplate)(name));
-            (0, edge_templates_1.registerLinkTemplate)(name, template);
-            return (0, disposable_1.once)(() => previous ? (0, edge_templates_1.registerLinkTemplate)(name, previous) : void (0, edge_templates_1.unregisterLinkTemplate)(name));
-        }
-        return setScoped(this.scope, registry_scope_1.LINK_TEMPLATES, name, template, edge_templates_1.notifyEdgeTemplatesChanged);
-    }
-    registerLabelTemplate(name, template) {
-        if (!this.scope) {
-            const previous = global(() => (0, edge_templates_1.getLabelTemplate)(name));
-            (0, edge_templates_1.registerLabelTemplate)(name, template);
-            return (0, disposable_1.once)(() => previous ? (0, edge_templates_1.registerLabelTemplate)(name, previous) : void (0, edge_templates_1.unregisterLabelTemplate)(name));
-        }
-        return setScoped(this.scope, registry_scope_1.LABEL_TEMPLATES, name, template, edge_templates_1.notifyEdgeTemplatesChanged);
-    }
-    registerMarker(name, definition) {
-        if (!this.scope) {
-            const previous = global(() => (0, edge_templates_1.getMarker)(name));
-            (0, edge_templates_1.registerMarker)(name, definition);
-            return (0, disposable_1.once)(() => (previous ? (0, edge_templates_1.registerMarker)(name, previous) : void (0, edge_templates_1.unregisterMarker)(name)));
-        }
-        return setScoped(this.scope, registry_scope_1.MARKERS, name, definition, edge_templates_1.notifyEdgeTemplatesChanged);
-    }
-    getLinkTemplate(name) {
-        return this.read(() => (0, edge_templates_1.getLinkTemplate)(name));
-    }
-    getLabelTemplate(name) {
-        return this.read(() => (0, edge_templates_1.getLabelTemplate)(name));
-    }
-    getMarker(name) {
-        return this.read(() => (0, edge_templates_1.getMarker)(name));
-    }
-    hasMarker(name) {
-        return this.read(() => (0, edge_templates_1.hasMarker)(name));
-    }
-    listLinkTemplates() {
-        return this.read(() => (0, edge_templates_1.listLinkTemplates)());
-    }
-    listLabelTemplates() {
-        return this.read(() => (0, edge_templates_1.listLabelTemplates)());
-    }
-    listMarkers() {
-        return this.read(() => (0, edge_templates_1.listMarkers)());
-    }
-    // -- link pipeline --------------------------------------------------------
-    //
-    // The three global `register*` functions already return restore-on-dispose
-    // disposers, so the unscoped branch delegates rather than re-deriving them.
-    registerAnchor(name, anchor) {
-        if (!this.scope)
-            return (0, link_pipeline_1.registerAnchor)(name, anchor);
-        return setScoped(this.scope, registry_scope_1.ANCHORS, name, anchor, link_pipeline_1.notifyLinkPipelineChanged);
-    }
-    registerConnectionPoint(name, strategy) {
-        if (!this.scope)
-            return (0, link_pipeline_1.registerConnectionPoint)(name, strategy);
-        return setScoped(this.scope, registry_scope_1.CONNECTION_POINTS, name, strategy, link_pipeline_1.notifyLinkPipelineChanged);
-    }
-    registerConnector(name, connector) {
-        if (!this.scope)
-            return (0, link_pipeline_1.registerConnector)(name, connector);
-        return setScoped(this.scope, registry_scope_1.CONNECTORS, name, connector, link_pipeline_1.notifyLinkPipelineChanged);
-    }
-    listAnchors() {
-        return this.read(() => (0, link_pipeline_1.listAnchors)());
-    }
-    listConnectionPoints() {
-        return this.read(() => (0, link_pipeline_1.listConnectionPoints)());
-    }
-    listConnectors() {
-        return this.read(() => (0, link_pipeline_1.listConnectors)());
-    }
-    // -- animations -----------------------------------------------------------
-    /**
-     * This diagram's own {@link CustomAnimationRegistry}, or the process-global
-     * singleton when unscoped.
-     *
-     * Lazy: the constructor appends a `<style>` element to the document, so a
-     * diagram that never contributes an animation must not pay for one.
-     */
-    get animations() {
-        if (!this.scope)
-            return (0, custom_animation_registry_1.getGlobalCustomAnimationRegistry)();
-        if (!this.ownAnimations)
-            this.ownAnimations = new custom_animation_registry_1.CustomAnimationRegistry();
-        return this.ownAnimations;
-    }
-    // -- lifecycle ------------------------------------------------------------
-    /** Drop every contribution this diagram made. No-op on the global registry. */
-    dispose() {
-        var _a;
-        if (!this.scope)
-            return;
-        const wasEmpty = this.scope.isEmpty();
-        this.scope.clear();
-        (_a = this.ownAnimations) === null || _a === void 0 ? void 0 : _a.destroy();
-        this.ownAnimations = undefined;
-        // Anything cached against a definition that no longer exists must go.
-        if (!wasEmpty) {
-            (0, shape_registry_1.notifyShapeRegistered)();
-            (0, style_registry_1.notifyStyleRegistryChanged)();
-            (0, edge_templates_1.notifyEdgeTemplatesChanged)();
-            (0, link_pipeline_1.notifyLinkPipelineChanged)();
-        }
-    }
-    /**
-     * Run a READ with this diagram's scope active.
-     *
-     * Every accessor above goes through here rather than reading the module maps,
-     * because the shadowing rule (mine first, then the process) must be identical
-     * whether a name is being resolved by a render pass or by a host asking
-     * `listShapes()`. Two implementations of that rule would drift.
-     */
-    read(fn) {
-        return (0, registry_scope_1.runInRegistryScope)(this.scope, fn);
-    }
-}
-exports.DiagramRegistry = DiagramRegistry;
-/** The process-wide registry — what the module-level `register*` functions write to. */
-exports.GLOBAL_DIAGRAM_REGISTRY = new DiagramRegistry(null);
-//# sourceMappingURL=diagram-registry.js.map

package/src/libs/renderer/src/ext/disposable.d.ts

@@ -1,51 +0,0 @@
-/**
- * Disposables — the one rule every extension seam in Wave 6 obeys.
- *
- * NON-NEGOTIABLE (learned from a real bug): every `register()` returns a
- * disposer, and disposing an extension must leave the registries byte-identical
- * to what they were before it loaded. The past failure was subscriptions that
- * were never unsubscribed, so swapping the engine left handlers live on the old
- * one. A registry that can only ADD is structurally incapable of honouring that,
- * which is why Wave 6 added `unregisterShape` / `unregisterLinkTemplate` / … as
- * additive removal paths on the existing registries.
- *
- * RESTORE-ON-DISPOSE. A disposer does not merely delete the key it wrote — it
- * restores whatever was there BEFORE. An extension that overrides the built-in
- * `rect` shape and is then disposed must give `rect` back, not leave a hole that
- * silently falls through to the default. `snapshotRestore()` is that helper.
- */
-/** The universal teardown handle. Idempotent by contract. */
-export type Disposer = () => void;
-/** Something that can be torn down. */
-export interface Disposable {
-    dispose(): void;
-}
-/** Wrap a function so it can only ever run once. */
-export declare function once(fn: Disposer): Disposer;
-/**
- * Build a disposer that puts a registry key back the way it was.
- *
- * @param previous the value read out of the registry BEFORE the write (or
- *                 `undefined` when the key did not exist)
- * @param restore  re-register the previous value
- * @param remove   delete the key (used when there was no previous value)
- */
-export declare function snapshotRestore<T>(previous: T | undefined, restore: (value: T) => void, remove: () => void): Disposer;
-/**
- * A bag of disposers with a single `dispose()`. Extensions accumulate their
- * registrations here so the host can tear the whole extension down atomically.
- *
- * Disposal runs in REVERSE registration order (like a stack unwind) and is
- * failure-tolerant: one throwing disposer must not strand the rest, or a single
- * bad extension would leak every registry behind it.
- */
-export declare class DisposableStore implements Disposable {
-    private readonly disposers;
-    private disposed;
-    /** Track a disposer. If the store is ALREADY disposed, run it immediately. */
-    add(disposer: Disposer): Disposer;
-    /** How many live registrations this store holds (tests assert on this). */
-    get size(): number;
-    get isDisposed(): boolean;
-    dispose(): void;
-}

package/src/libs/renderer/src/ext/disposable.js

@@ -1,104 +0,0 @@
-"use strict";
-/**
- * Disposables — the one rule every extension seam in Wave 6 obeys.
- *
- * NON-NEGOTIABLE (learned from a real bug): every `register()` returns a
- * disposer, and disposing an extension must leave the registries byte-identical
- * to what they were before it loaded. The past failure was subscriptions that
- * were never unsubscribed, so swapping the engine left handlers live on the old
- * one. A registry that can only ADD is structurally incapable of honouring that,
- * which is why Wave 6 added `unregisterShape` / `unregisterLinkTemplate` / … as
- * additive removal paths on the existing registries.
- *
- * RESTORE-ON-DISPOSE. A disposer does not merely delete the key it wrote — it
- * restores whatever was there BEFORE. An extension that overrides the built-in
- * `rect` shape and is then disposed must give `rect` back, not leave a hole that
- * silently falls through to the default. `snapshotRestore()` is that helper.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisposableStore = void 0;
-exports.once = once;
-exports.snapshotRestore = snapshotRestore;
-/** Wrap a function so it can only ever run once. */
-function once(fn) {
-    let done = false;
-    return () => {
-        if (done)
-            return;
-        done = true;
-        fn();
-    };
-}
-/**
- * Build a disposer that puts a registry key back the way it was.
- *
- * @param previous the value read out of the registry BEFORE the write (or
- *                 `undefined` when the key did not exist)
- * @param restore  re-register the previous value
- * @param remove   delete the key (used when there was no previous value)
- */
-function snapshotRestore(previous, restore, remove) {
-    return once(() => {
-        if (previous === undefined)
-            remove();
-        else
-            restore(previous);
-    });
-}
-/**
- * A bag of disposers with a single `dispose()`. Extensions accumulate their
- * registrations here so the host can tear the whole extension down atomically.
- *
- * Disposal runs in REVERSE registration order (like a stack unwind) and is
- * failure-tolerant: one throwing disposer must not strand the rest, or a single
- * bad extension would leak every registry behind it.
- */
-class DisposableStore {
-    constructor() {
-        this.disposers = [];
-        this.disposed = false;
-    }
-    /** Track a disposer. If the store is ALREADY disposed, run it immediately. */
-    add(disposer) {
-        if (this.disposed) {
-            disposer();
-            return () => undefined;
-        }
-        const wrapped = once(disposer);
-        this.disposers.push(wrapped);
-        return wrapped;
-    }
-    /** How many live registrations this store holds (tests assert on this). */
-    get size() {
-        return this.disposers.length;
-    }
-    get isDisposed() {
-        return this.disposed;
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        const errors = [];
-        // Reverse order: the last registration is the first undone.
-        for (let i = this.disposers.length - 1; i >= 0; i--) {
-            try {
-                this.disposers[i]();
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        this.disposers.length = 0;
-        if (errors.length > 0) {
-            // Surface the failures, but only AFTER every other disposer has run.
-            // (Not `AggregateError` — this library's TS lib target predates it.)
-            const error = new Error(`${errors.length} disposer(s) threw during dispose(): ` +
-                errors.map((e) => (e instanceof Error ? e.message : String(e))).join('; '));
-            error.errors = errors;
-            throw error;
-        }
-    }
-}
-exports.DisposableStore = DisposableStore;
-//# sourceMappingURL=disposable.js.map