@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/state/DiagramStore.js

@@ -1,372 +0,0 @@
-"use strict";
-// DiagramStore - State management for diagram application
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagramStore = void 0;
-class DiagramStore {
-    constructor(initialState) {
-        this.listeners = new Map();
-        this.globalListeners = new Set();
-        this.history = [];
-        this.maxHistorySize = 50;
-        this.computedCache = new Map();
-        this.batching = false;
-        this.batchedChanges = [];
-        this.state = this.createInitialState(initialState);
-    }
-    /**
-     * Get current state (immutable)
-     */
-    getState() {
-        return this.deepFreeze(this.deepClone(this.state));
-    }
-    /**
-     * Set state with change tracking
-     */
-    setState(updater) {
-        const prevState = this.deepClone(this.state);
-        // Apply update
-        updater(this.state);
-        // Find changes
-        const changes = this.diffState(prevState, this.state);
-        if (changes.length > 0) {
-            if (this.batching) {
-                // Accumulate changes during batch
-                this.batchedChanges.push(...changes);
-            }
-            else {
-                // Invalidate computed values
-                this.invalidateComputed(changes);
-                // Notify listeners
-                this.notifyListeners(changes);
-                // Add to history
-                this.addToHistory();
-            }
-        }
-    }
-    /**
-     * Get state value by path
-     */
-    select(path) {
-        const keys = path.split('.');
-        let value = this.state;
-        for (const key of keys) {
-            if (value == null)
-                return undefined;
-            value = value[key];
-        }
-        return value;
-    }
-    /**
-     * Get state value by path
-     */
-    get(path) {
-        const keys = path.split('.');
-        let target = this.state;
-        for (const key of keys) {
-            if (target === undefined || target === null) {
-                return undefined;
-            }
-            target = target[key];
-        }
-        return target;
-    }
-    /**
-     * Set state value by path
-     */
-    set(path, value) {
-        this.setState((state) => {
-            const keys = path.split('.');
-            const lastKey = keys.pop();
-            let target = state;
-            for (const key of keys) {
-                if (!(key in target)) {
-                    target[key] = {};
-                }
-                target = target[key];
-            }
-            target[lastKey] = value;
-        });
-    }
-    /**
-     * Subscribe to all state changes
-     */
-    subscribe(listener) {
-        this.globalListeners.add(listener);
-        return () => this.globalListeners.delete(listener);
-    }
-    /**
-     * Subscribe to path changes
-     */
-    watch(path, listener) {
-        if (!this.listeners.has(path)) {
-            this.listeners.set(path, new Set());
-        }
-        this.listeners.get(path).add(listener);
-        return () => {
-            const pathListeners = this.listeners.get(path);
-            if (pathListeners) {
-                pathListeners.delete(listener);
-                if (pathListeners.size === 0) {
-                    this.listeners.delete(path);
-                }
-            }
-        };
-    }
-    /**
-     * Computed value with memoization
-     */
-    computed(key, compute, deps) {
-        const cached = this.computedCache.get(key);
-        if (cached && cached.valid) {
-            return cached.value;
-        }
-        const value = compute(this.state);
-        this.computedCache.set(key, {
-            value,
-            deps: deps || [],
-            valid: true,
-        });
-        return value;
-    }
-    /**
-     * Batch multiple state updates
-     */
-    batch(fn) {
-        this.batching = true;
-        this.batchedChanges = [];
-        try {
-            fn();
-            // Process accumulated changes
-            if (this.batchedChanges.length > 0) {
-                // Remove duplicates
-                const uniqueChanges = Array.from(new Set(this.batchedChanges));
-                this.invalidateComputed(uniqueChanges);
-                this.notifyListeners(uniqueChanges);
-                this.addToHistory();
-            }
-        }
-        finally {
-            this.batching = false;
-            this.batchedChanges = [];
-        }
-    }
-    /**
-     * Reset to initial state
-     */
-    reset(initialState) {
-        this.state = this.createInitialState(initialState);
-        this.computedCache.clear();
-        this.notifyListeners(['*']);
-        this.history = [];
-    }
-    /**
-     * Time travel to history index
-     */
-    timeTravel(index) {
-        if (index >= 0 && index < this.history.length) {
-            const snapshot = this.history[index];
-            this.state = this.deepClone(snapshot.state);
-            this.computedCache.clear();
-            this.notifyListeners(['*']);
-        }
-    }
-    /**
-     * Get history
-     */
-    getHistory() {
-        return [...this.history];
-    }
-    /**
-     * Create snapshot
-     */
-    createSnapshot() {
-        return {
-            timestamp: Date.now(),
-            state: this.deepClone(this.state),
-            version: '1.0.0',
-        };
-    }
-    /**
-     * Restore snapshot
-     */
-    restoreSnapshot(snapshot) {
-        this.state = this.deepClone(snapshot.state);
-        this.computedCache.clear();
-        this.notifyListeners(['*']);
-    }
-    /**
-     * Create initial state
-     */
-    createInitialState(partial) {
-        return Object.assign({ diagram: null, selectedNodes: new Set(), selectedLinks: new Set(), hoveredElement: null, focusedElement: null, viewport: { x: 0, y: 0, zoom: 1, rotation: 0 }, zoom: 1, gridEnabled: true, snapEnabled: true, activeTool: 'select', toolOptions: {}, mode: 'design', locked: false, theme: 'light', showMinimap: false, showToolbar: true, showProperties: true, renderStats: {
-                fps: 60,
-                renderTime: 0,
-                nodeCount: 0,
-                linkCount: 0,
-                visibleNodes: 0,
-                visibleLinks: 0,
-            }, errors: [], warnings: [] }, partial);
-    }
-    /**
-     * Diff two states
-     */
-    diffState(prev, current, path = '', depth = 0) {
-        const changes = [];
-        const MAX_DEPTH = 10; // Prevent infinite recursion
-        // Prevent infinite recursion
-        if (depth > MAX_DEPTH) {
-            if (path && prev !== current)
-                changes.push(path);
-            return changes;
-        }
-        // Handle primitives
-        if (prev === current)
-            return changes;
-        if (typeof prev !== 'object' || typeof current !== 'object' || prev === null || current === null) {
-            if (path)
-                changes.push(path);
-            return changes;
-        }
-        // Handle Sets
-        if (prev instanceof Set || current instanceof Set) {
-            const prevSet = prev instanceof Set ? prev : new Set();
-            const currSet = current instanceof Set ? current : new Set();
-            if (prevSet.size !== currSet.size || ![...prevSet].every((v) => currSet.has(v))) {
-                if (path)
-                    changes.push(path);
-            }
-            return changes;
-        }
-        // Handle arrays
-        if (Array.isArray(prev) || Array.isArray(current)) {
-            if (JSON.stringify(prev) !== JSON.stringify(current)) {
-                if (path)
-                    changes.push(path);
-            }
-            return changes;
-        }
-        // Handle objects - skip class instances to avoid circular references
-        if (prev.constructor !== Object || current.constructor !== Object) {
-            if (path && prev !== current)
-                changes.push(path);
-            return changes;
-        }
-        // Handle plain objects only
-        const allKeys = new Set([...Object.keys(prev || {}), ...Object.keys(current || {})]);
-        for (const key of allKeys) {
-            const prevValue = prev === null || prev === void 0 ? void 0 : prev[key];
-            const currentValue = current === null || current === void 0 ? void 0 : current[key];
-            const keyPath = path ? `${path}.${key}` : key;
-            if (prevValue !== currentValue) {
-                if (typeof prevValue === 'object' &&
-                    typeof currentValue === 'object' &&
-                    prevValue !== null &&
-                    currentValue !== null) {
-                    changes.push(...this.diffState(prevValue, currentValue, keyPath, depth + 1));
-                }
-                else {
-                    changes.push(keyPath);
-                }
-            }
-        }
-        return changes;
-    }
-    /**
-     * Notify listeners of changes
-     */
-    notifyListeners(changes) {
-        // Notify path listeners
-        for (const change of changes) {
-            const listeners = this.listeners.get(change);
-            if (listeners) {
-                const value = this.select(change);
-                listeners.forEach((listener) => listener(value, undefined));
-            }
-            // Notify parent path listeners
-            const parts = change.split('.');
-            for (let i = parts.length - 1; i > 0; i--) {
-                const parentPath = parts.slice(0, i).join('.');
-                const parentListeners = this.listeners.get(parentPath);
-                if (parentListeners) {
-                    const value = this.select(parentPath);
-                    parentListeners.forEach((listener) => listener(value, undefined));
-                }
-            }
-        }
-        // Notify global listeners
-        this.globalListeners.forEach((listener) => {
-            listener(this.state, changes);
-        });
-    }
-    /**
-     * Invalidate computed values
-     */
-    invalidateComputed(changes) {
-        for (const [key, cached] of this.computedCache.entries()) {
-            for (const dep of cached.deps) {
-                if (changes.some((change) => change.startsWith(dep))) {
-                    cached.valid = false;
-                    break;
-                }
-            }
-        }
-    }
-    /**
-     * Add to history
-     */
-    addToHistory() {
-        this.history.push(this.createSnapshot());
-        if (this.history.length > this.maxHistorySize) {
-            this.history.shift();
-        }
-    }
-    /**
-     * Deep clone object (handles Sets, Maps, Arrays, Objects)
-     */
-    deepClone(obj) {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-        if (obj instanceof Set) {
-            return new Set(Array.from(obj));
-        }
-        if (obj instanceof Map) {
-            return new Map(Array.from(obj));
-        }
-        if (obj instanceof Date) {
-            return new Date(obj);
-        }
-        if (Array.isArray(obj)) {
-            return obj.map((item) => this.deepClone(item));
-        }
-        // For class instances (has a constructor other than Object), return as-is
-        // This prevents trying to clone DiagramModel, NodeModel, etc.
-        if (obj.constructor && obj.constructor !== Object) {
-            return obj;
-        }
-        const cloned = {};
-        for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                cloned[key] = this.deepClone(obj[key]);
-            }
-        }
-        return cloned;
-    }
-    /**
-     * Deep freeze object
-     */
-    deepFreeze(obj) {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-        Object.freeze(obj);
-        Object.getOwnPropertyNames(obj).forEach((prop) => {
-            if (obj[prop] !== null && typeof obj[prop] === 'object' && !Object.isFrozen(obj[prop])) {
-                this.deepFreeze(obj[prop]);
-            }
-        });
-        return obj;
-    }
-}
-exports.DiagramStore = DiagramStore;
-//# sourceMappingURL=DiagramStore.js.map

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

@@ -1,2 +0,0 @@
-export * from './DiagramStore';
-export * from './ConnectionStateManager';

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

@@ -1,7 +0,0 @@
-"use strict";
-// State index - exports state management components
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./DiagramStore"), exports);
-tslib_1.__exportStar(require("./ConnectionStateManager"), exports);
-//# sourceMappingURL=index.js.map

package/src/libs/engine/src/sync/awareness.d.ts

@@ -1,91 +0,0 @@
-import type { ActorId } from '../collab/op';
-import type { AwarenessState } from './protocol';
-export type { AwarenessState };
-/** Another peer, as far as we know. */
-export interface PeerPresence {
-    actor: ActorId;
-    state: AwarenessState;
-    /** Wall-clock ms of the last message from them. NOT a Lamport clock — see below. */
-    lastSeen: number;
-    /** Their sequence number for `state`. Guards against a reordered cursor sample. */
-    seq: number;
-}
-export interface AwarenessChange {
-    added: ActorId[];
-    updated: ActorId[];
-    removed: ActorId[];
-}
-export interface AwarenessOptions {
-    actor: ActorId;
-    /** Drop a peer we have not heard from in this long. */
-    timeoutMs?: number;
-    /** Wall clock — injectable so the expiry tests are not a race against real time. */
-    now?: () => number;
-}
-/**
- * The presence store for one peer: our own state, and everyone else's.
- *
- * Deliberately transport-free. `SyncAdapter` wires it to a channel; a test wires it to
- * nothing and drives it directly. It never sees an Op, a Replica or an OpLog, and that
- * is not an accident — it is the containment.
- *
- * ---------------------------------------------------------------------------
- * WHY `lastSeen` IS A WALL CLOCK WHEN THE LOG WENT TO SUCH LENGTHS TO AVOID ONE
- * ---------------------------------------------------------------------------
- * Because the question is different. The log asks "did A happen before B?", which a wall
- * clock cannot answer across machines (they disagree, and they run backwards). Expiry
- * asks "has it been 15 seconds since I last heard from Bob?" — measured entirely on MY
- * clock, about MY receipts, comparing my own `now()` to my own earlier `now()`. Bob's
- * clock is never consulted, so its wrongness cannot infect anything. Using a Lamport
- * clock for a TIMEOUT would be the actual mistake: it has no relationship to seconds.
- */
-export declare class Awareness {
-    private readonly options;
-    private readonly peers;
-    private local;
-    private seq;
-    private readonly listeners;
-    private readonly timeoutMs;
-    private readonly nowFn;
-    constructor(options: AwarenessOptions);
-    get actor(): ActorId;
-    /** Our own published state, and the sequence a peer will LWW it by. */
-    getLocalState(): AwarenessState;
-    get localSeq(): number;
-    /**
-     * Merge a patch into our own state and bump the sequence.
-     *
-     * Returns false when nothing actually changed — a mouse that has not moved must not
-     * burn a sequence number, wake the throttle, or send a message. (A `mousemove` fires
-     * on sub-pixel jitter and on scroll; without this guard an idle user with a resting
-     * hand is a 60Hz broadcaster.)
-     */
-    setLocalState(patch: Partial<AwarenessState>): boolean;
-    /**
-     * Take a peer's published state.
-     *
-     * `seq` is the whole reason a reordered transport does not make a cursor jump
-     * backwards: a sample older than the one we already hold is REFUSED, exactly as the LWW
-     * gate refuses a superseded op. Same idea, one scope down, and no shared machinery
-     * because the lifecycles have nothing in common.
-     */
-    applyRemote(actor: ActorId, state: AwarenessState | null, seq: number): AwarenessChange | null;
-    /** An explicit `bye`, or a transport that told us the peer is gone. */
-    remove(actor: ActorId): AwarenessChange | null;
-    /**
-     * Drop peers we have not heard from inside the timeout.
-     *
-     * THE GUARANTEE, as opposed to `bye`, which is merely the optimisation. A crashed tab,
-     * a closed laptop, a killed process and a severed cable all send no `bye` whatsoever,
-     * and every one of them must eventually stop showing a cursor.
-     */
-    prune(): AwarenessChange | null;
-    /** Everyone but us. */
-    getPeers(): PeerPresence[];
-    getPeer(actor: ActorId): PeerPresence | undefined;
-    get peerCount(): number;
-    /** Everyone is gone (we disconnected — we can no longer vouch for anyone). */
-    clearPeers(): AwarenessChange | null;
-    onChange(listener: (change: AwarenessChange) => void): () => void;
-    private emit;
-}

package/src/libs/engine/src/sync/awareness.js

@@ -1,221 +0,0 @@
-"use strict";
-// Wave 9 — Card 5, part B: AWARENESS. Who else is here, where are they looking, what
-// have they got selected.
-//
-// ---------------------------------------------------------------------------
-// AWARENESS IS NOT A DOCUMENT EDIT, AND THE DAY IT BECOMES ONE IS THE DAY THE
-// DOCUMENT IS RUINED
-// ---------------------------------------------------------------------------
-//
-// It is genuinely tempting to reuse the op log. It is right there; it already has
-// ordering, delivery, de-duplication and catch-up; a cursor is "just" a property of a
-// peer. Do it and here is what you have built:
-//
-//   • A 60Hz write stream into an APPEND-ONLY, PERSISTED, REPLAYABLE log. Ten minutes of
-//     four people moving their mice is ~150,000 permanent entries in a document whose
-//     actual content is forty nodes.
-//   • A Lamport clock in the millions, because every mouse sample ticks it — so every
-//     real edit now sorts against a clock dominated by mouse jitter.
-//   • "Replay the document" now literally re-enacts someone's mouse movements from last
-//     March, and the byte-identical-replay contract has to reproduce them exactly.
-//   • And a cursor that has to be UNDONE, because it is in the undo stack.
-//
-// None of that is recoverable later: the log is append-only, so a bad decision here is
-// permanent by construction. Hence: separate message kind, separate store, separate
-// lifecycle. This class cannot reach the op log — it holds no Replica and is handed no
-// log — and there is a test that drives a thousand cursor moves through a live adapter
-// and asserts the log is still EMPTY.
-//
-// ---------------------------------------------------------------------------
-// THE LIFECYCLE, WHICH IS THE OPPOSITE OF THE LOG'S IN EVERY RESPECT
-// ---------------------------------------------------------------------------
-//
-//   log:        durable · causally ordered · de-duplicated · every op matters · forever
-//   awareness:  ephemeral · LWW per peer · lossy on purpose · only the LATEST matters ·
-//               expires
-//
-// LOSSY ON PURPOSE is the load-bearing one. Dropping a cursor sample costs nothing — the
-// next is 16ms behind it. So awareness needs no retransmission, no acknowledgement, no
-// catch-up and no buffering, and building any of those would be pure waste.
-//
-// EXPIRES is the other. A tab that crashes sends no `bye`, and a peer whose ghost cursor
-// hovers over the canvas forever is worse than no cursor at all. So every peer's state
-// carries a `lastSeen`, a heartbeat refreshes it, and anything stale is dropped. The
-// explicit `bye` is a fast path, never the guarantee.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Awareness = void 0;
-/**
- * The presence store for one peer: our own state, and everyone else's.
- *
- * Deliberately transport-free. `SyncAdapter` wires it to a channel; a test wires it to
- * nothing and drives it directly. It never sees an Op, a Replica or an OpLog, and that
- * is not an accident — it is the containment.
- *
- * ---------------------------------------------------------------------------
- * WHY `lastSeen` IS A WALL CLOCK WHEN THE LOG WENT TO SUCH LENGTHS TO AVOID ONE
- * ---------------------------------------------------------------------------
- * Because the question is different. The log asks "did A happen before B?", which a wall
- * clock cannot answer across machines (they disagree, and they run backwards). Expiry
- * asks "has it been 15 seconds since I last heard from Bob?" — measured entirely on MY
- * clock, about MY receipts, comparing my own `now()` to my own earlier `now()`. Bob's
- * clock is never consulted, so its wrongness cannot infect anything. Using a Lamport
- * clock for a TIMEOUT would be the actual mistake: it has no relationship to seconds.
- */
-class Awareness {
-    constructor(options) {
-        var _a, _b;
-        this.options = options;
-        this.peers = new Map();
-        this.local = {};
-        this.seq = 0;
-        this.listeners = new Set();
-        this.timeoutMs = (_a = options.timeoutMs) !== null && _a !== void 0 ? _a : 15000;
-        this.nowFn = (_b = options.now) !== null && _b !== void 0 ? _b : Date.now;
-    }
-    get actor() {
-        return this.options.actor;
-    }
-    /** Our own published state, and the sequence a peer will LWW it by. */
-    getLocalState() {
-        return this.local;
-    }
-    get localSeq() {
-        return this.seq;
-    }
-    /**
-     * Merge a patch into our own state and bump the sequence.
-     *
-     * Returns false when nothing actually changed — a mouse that has not moved must not
-     * burn a sequence number, wake the throttle, or send a message. (A `mousemove` fires
-     * on sub-pixel jitter and on scroll; without this guard an idle user with a resting
-     * hand is a 60Hz broadcaster.)
-     */
-    setLocalState(patch) {
-        let changed = false;
-        const next = Object.assign({}, this.local);
-        for (const [k, v] of Object.entries(patch)) {
-            if (!shallowEqual(next[k], v)) {
-                next[k] = v;
-                changed = true;
-            }
-        }
-        if (!changed)
-            return false;
-        this.local = next;
-        this.seq++;
-        return true;
-    }
-    /**
-     * Take a peer's published state.
-     *
-     * `seq` is the whole reason a reordered transport does not make a cursor jump
-     * backwards: a sample older than the one we already hold is REFUSED, exactly as the LWW
-     * gate refuses a superseded op. Same idea, one scope down, and no shared machinery
-     * because the lifecycles have nothing in common.
-     */
-    applyRemote(actor, state, seq) {
-        if (actor === this.options.actor)
-            return null; // our own echo; ignore
-        if (state === null) {
-            return this.remove(actor);
-        }
-        const existing = this.peers.get(actor);
-        if (existing && seq < existing.seq)
-            return null; // a stale sample overtook a fresh one
-        const now = this.nowFn();
-        if (existing) {
-            // Even a same-seq message refreshes lastSeen: that is what a HEARTBEAT is — "still
-            // here, nothing new". Without this an idle-but-present peer times out and their
-            // cursor vanishes while they are staring at it.
-            existing.lastSeen = now;
-            if (seq === existing.seq)
-                return null;
-            existing.seq = seq;
-            existing.state = state;
-            this.emit({ added: [], updated: [actor], removed: [] });
-            return { added: [], updated: [actor], removed: [] };
-        }
-        this.peers.set(actor, { actor, state, lastSeen: now, seq });
-        const change = { added: [actor], updated: [], removed: [] };
-        this.emit(change);
-        return change;
-    }
-    /** An explicit `bye`, or a transport that told us the peer is gone. */
-    remove(actor) {
-        if (!this.peers.delete(actor))
-            return null;
-        const change = { added: [], updated: [], removed: [actor] };
-        this.emit(change);
-        return change;
-    }
-    /**
-     * Drop peers we have not heard from inside the timeout.
-     *
-     * THE GUARANTEE, as opposed to `bye`, which is merely the optimisation. A crashed tab,
-     * a closed laptop, a killed process and a severed cable all send no `bye` whatsoever,
-     * and every one of them must eventually stop showing a cursor.
-     */
-    prune() {
-        const cutoff = this.nowFn() - this.timeoutMs;
-        const removed = [];
-        for (const [actor, p] of this.peers) {
-            if (p.lastSeen < cutoff) {
-                this.peers.delete(actor);
-                removed.push(actor);
-            }
-        }
-        if (removed.length === 0)
-            return null;
-        const change = { added: [], updated: [], removed };
-        this.emit(change);
-        return change;
-    }
-    /** Everyone but us. */
-    getPeers() {
-        return [...this.peers.values()];
-    }
-    getPeer(actor) {
-        return this.peers.get(actor);
-    }
-    get peerCount() {
-        return this.peers.size;
-    }
-    /** Everyone is gone (we disconnected — we can no longer vouch for anyone). */
-    clearPeers() {
-        if (this.peers.size === 0)
-            return null;
-        const removed = [...this.peers.keys()];
-        this.peers.clear();
-        const change = { added: [], updated: [], removed };
-        this.emit(change);
-        return change;
-    }
-    onChange(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    emit(change) {
-        for (const l of [...this.listeners])
-            l(change);
-    }
-}
-exports.Awareness = Awareness;
-/** Enough to tell "the cursor moved" from "the cursor did not". Selections are arrays. */
-function shallowEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null || a === undefined || b === undefined)
-        return false;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every((v, i) => v === b[i]);
-    }
-    if (typeof a === 'object' && typeof b === 'object') {
-        const ka = Object.keys(a);
-        const kb = Object.keys(b);
-        if (ka.length !== kb.length)
-            return false;
-        return ka.every((k) => a[k] === b[k]);
-    }
-    return false;
-}
-//# sourceMappingURL=awareness.js.map