@konitif/workbench-runtime 0.284.1

package/dist/workbench/workspaceHistoryController.js

@@ -0,0 +1,126 @@
+const DEFAULT_MAX_HISTORY_ENTRIES = 100;
+export function createWorkspaceHistoryController(options) {
+    const maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_MAX_HISTORY_ENTRIES));
+    const buckets = {
+        app: createBucket(),
+        core: createBucket()
+    };
+    function getStatus() {
+        return {
+            app: {
+                canUndo: buckets.app.past.length > 0,
+                canRedo: buckets.app.future.length > 0
+            },
+            core: {
+                canUndo: buckets.core.past.length > 0,
+                canRedo: buckets.core.future.length > 0
+            }
+        };
+    }
+    function reset() {
+        resetBucket(buckets.app);
+        resetBucket(buckets.core);
+    }
+    function recordTransition(previousSnapshot, nextSnapshot, scope) {
+        if (scope === 'none' || !options.isChanged(previousSnapshot, nextSnapshot)) {
+            return;
+        }
+        for (const channel of resolveChannels(scope)) {
+            const bucket = buckets[channel];
+            if (!bucket.shouldRecord) {
+                continue;
+            }
+            bucket.past = pushHistoryEntry(bucket.past, previousSnapshot);
+            bucket.future = [];
+        }
+    }
+    function beginTransaction(channel, snapshot) {
+        const bucket = buckets[channel];
+        if (bucket.transaction) {
+            return;
+        }
+        bucket.transaction = snapshot;
+        bucket.shouldRecord = false;
+    }
+    function commitTransaction(channel, currentSnapshot) {
+        const bucket = buckets[channel];
+        if (!bucket.transaction) {
+            return;
+        }
+        if (options.isChanged(bucket.transaction, currentSnapshot)) {
+            bucket.past = pushHistoryEntry(bucket.past, bucket.transaction);
+            bucket.future = [];
+        }
+        bucket.transaction = null;
+        bucket.shouldRecord = true;
+    }
+    function cancelTransaction(channel) {
+        const bucket = buckets[channel];
+        const snapshot = bucket.transaction;
+        if (!snapshot) {
+            return null;
+        }
+        bucket.transaction = null;
+        bucket.shouldRecord = true;
+        return snapshot;
+    }
+    function undo(channel, currentSnapshot) {
+        const bucket = buckets[channel];
+        const snapshot = bucket.past.length > 0 ? bucket.past[bucket.past.length - 1] : null;
+        if (!snapshot) {
+            return null;
+        }
+        bucket.past = bucket.past.slice(0, -1);
+        bucket.future = pushHistoryEntry(bucket.future, currentSnapshot);
+        return snapshot;
+    }
+    function redo(channel, currentSnapshot) {
+        const bucket = buckets[channel];
+        const snapshot = bucket.future.length > 0 ? bucket.future[bucket.future.length - 1] : null;
+        if (!snapshot) {
+            return null;
+        }
+        bucket.future = bucket.future.slice(0, -1);
+        bucket.past = pushHistoryEntry(bucket.past, currentSnapshot);
+        return snapshot;
+    }
+    function pushHistoryEntry(entries, entry) {
+        return [...entries, entry].slice(-maxEntries);
+    }
+    return {
+        getStatus,
+        reset,
+        recordTransition,
+        beginTransaction,
+        commitTransaction,
+        cancelTransaction,
+        undo,
+        redo
+    };
+}
+function createBucket() {
+    return {
+        past: [],
+        future: [],
+        transaction: null,
+        shouldRecord: true
+    };
+}
+function resetBucket(bucket) {
+    bucket.past = [];
+    bucket.future = [];
+    bucket.transaction = null;
+    bucket.shouldRecord = true;
+}
+function resolveChannels(scope) {
+    switch (scope) {
+        case 'app':
+            return ['app'];
+        case 'core':
+            return ['core'];
+        case 'both':
+            return ['app', 'core'];
+        case 'none':
+            return [];
+    }
+}

package/dist/workbench/workspaceSyncController.d.ts

@@ -0,0 +1,20 @@
+import type { ShellState, Workspace, WorkspaceFocus } from '@konitif/workbench';
+export interface WorkspaceSyncSnapshot {
+    workspace: Workspace;
+    shell?: ShellState;
+    focus?: WorkspaceFocus;
+}
+export interface WorkspaceSyncController {
+    publish(snapshot: WorkspaceSyncSnapshot): void;
+    subscribe(handler: (snapshot: WorkspaceSyncSnapshot) => void): void | (() => void);
+    /** Only the owner of this provider may close it. */
+    dispose?(): void;
+}
+interface BrowserWorkspaceSyncControllerOptions {
+    persistenceKey: string;
+    isEnabled?: () => boolean;
+}
+export declare function createBrowserWorkspaceSyncController(options: BrowserWorkspaceSyncControllerOptions): WorkspaceSyncController & {
+    dispose(): void;
+};
+export {};

package/dist/workbench/workspaceSyncController.js

@@ -0,0 +1,105 @@
+export function createBrowserWorkspaceSyncController(options) {
+    const clientId = createWorkspaceSyncClientId(options.persistenceKey);
+    const channel = createWorkspaceSyncChannel(options.persistenceKey);
+    let lastPublishedSignature = '';
+    let localRevision = 0;
+    let acceptedAuthorityStamp = '';
+    let disposed = false;
+    return {
+        publish(snapshot) {
+            if (disposed || !isEnabled(options) || !channel) {
+                return;
+            }
+            const signature = JSON.stringify(snapshot);
+            if (signature === lastPublishedSignature) {
+                return;
+            }
+            lastPublishedSignature = signature;
+            localRevision += 1;
+            acceptedAuthorityStamp = createAuthorityStamp(localRevision, clientId);
+            channel.postMessage({
+                type: 'workbench.workspace.snapshot',
+                persistenceKey: options.persistenceKey,
+                clientId,
+                revision: localRevision,
+                workspace: snapshot.workspace,
+                shell: snapshot.shell,
+                focus: snapshot.focus
+            });
+        },
+        subscribe(handler) {
+            if (disposed || !channel) {
+                return;
+            }
+            let active = true;
+            const receive = (event) => {
+                if (disposed || !active || channel.onmessage !== receive || !isEnabled(options)) {
+                    return;
+                }
+                const message = normalizeWorkspaceSyncMessage(event.data);
+                if (!message ||
+                    message.persistenceKey !== options.persistenceKey ||
+                    message.clientId === clientId) {
+                    return;
+                }
+                localRevision = Math.max(localRevision, message.revision);
+                const messageAuthorityStamp = createAuthorityStamp(message.revision, message.clientId);
+                if (messageAuthorityStamp <= acceptedAuthorityStamp) {
+                    return;
+                }
+                acceptedAuthorityStamp = messageAuthorityStamp;
+                handler({
+                    workspace: message.workspace,
+                    shell: message.shell,
+                    focus: message.focus
+                });
+            };
+            channel.onmessage = receive;
+            return () => {
+                active = false;
+                if (channel.onmessage === receive)
+                    channel.onmessage = null;
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (channel) {
+                channel.onmessage = null;
+                channel.close();
+            }
+        }
+    };
+}
+function createWorkspaceSyncClientId(persistenceKey) {
+    const token = globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2);
+    return `${persistenceKey}:${token}`.replace(/[^a-zA-Z0-9._:-]/g, '_');
+}
+function createWorkspaceSyncChannel(persistenceKey) {
+    if (typeof window === 'undefined' || typeof BroadcastChannel === 'undefined') {
+        return null;
+    }
+    return new BroadcastChannel(`workbench.workspace:${persistenceKey}`);
+}
+function normalizeWorkspaceSyncMessage(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return null;
+    }
+    const record = input;
+    return record.type === 'workbench.workspace.snapshot' &&
+        typeof record.persistenceKey === 'string' &&
+        typeof record.clientId === 'string' &&
+        typeof record.revision === 'number' &&
+        Number.isSafeInteger(record.revision) &&
+        record.revision > 0 &&
+        !!record.workspace
+        ? record
+        : null;
+}
+function createAuthorityStamp(revision, clientId) {
+    return `${revision.toString().padStart(16, '0')}:${clientId}`;
+}
+function isEnabled(options) {
+    return options.isEnabled?.() ?? true;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@konitif/workbench-runtime",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "version": "0.284.1",
+  "description": "Reactive Svelte host adapter for KONITIF Workbench contracts with explicit runtime ports.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LeMouf/konitif-workbench-runtime.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "svelte": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test tests/*.test.mjs",
+    "verify:package": "node scripts/verify-package.mjs"
+  },
+  "dependencies": {
+    "@konitif/workbench": "0.284.1",
+    "svelte": "^4.2.18"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3"
+  }
+}