208 lines
15 KiB
JavaScript
208 lines
15 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createDocument, createEditor, createRegistry, builtinComponents, defineComponent, defineFeature, editable, movable, resizable, rotatable, migrateElement, commonCanvas } from '../../src/lib/canvas-core/index.ts';
|
|
|
|
const geometry = { x: 10, y: 20, width: 100, height: 80, rotation: 0 };
|
|
const node = (id, ownerCanvasId = 'root', componentId = 'text') => ({ id, incarnation: 1, ownerCanvasId, componentId, dataVersion: 1, structure: 'node', geometry, data: { title: id, text: '' } });
|
|
const target = id => ({ id, incarnation: 1 });
|
|
function setup(elements = [node('a'), node('b')], options = {}) {
|
|
let next = 0;
|
|
return createEditor({ document: createDocument('p', [{ id: 'root', parent: null }], elements), registry: createRegistry(builtinComponents()), createId: () => `op-${++next}`, ...options });
|
|
}
|
|
|
|
test('runtime preparation shares the document publication boundary; metadata has a separate root revision', () => {
|
|
const editor = setup(undefined, { runtime: Object.freeze({ ids: [] }), reduceRuntime(previous, next, commit) {
|
|
if (next.document.elements.get('a').data.title === 'reject-ledger') throw new Error('ledger_failed');
|
|
return Object.freeze({ ids: Object.freeze([...previous.ids, ...commit.operationIds]) });
|
|
} });
|
|
const initial = editor.getSnapshot();
|
|
assert.equal(editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'reject-ledger' } }).status, 'rejected');
|
|
assert.strictEqual(editor.getSnapshot(), initial);
|
|
const result = editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'committed' } });
|
|
assert.deepEqual(editor.getSnapshot().runtime.ids, result.operationIds);
|
|
assert.equal(editor.getSnapshot().rootRevision, 1); assert.equal(editor.getSnapshot().revision, 1);
|
|
const old = editor.getSnapshot();
|
|
assert.equal(editor.updateRuntime(value => ({ ...value, ready: true }), old.rootRevision).status, 'applied');
|
|
assert.equal(editor.getSnapshot().rootRevision, 2); assert.equal(editor.getSnapshot().revision, 1);
|
|
assert.equal(editor.updateRuntime(value => value, old.rootRevision).code, 'stale_plan');
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'canonical' } }, { origin: 'ack' });
|
|
assert.equal(editor.getSnapshot().operations.size, 1); assert.equal(editor.getSnapshot().history.undo.length, 1);
|
|
});
|
|
|
|
test('a rejected second command publishes no document, history, operation or notification', () => {
|
|
const editor = setup(), before = editor.getSnapshot(); let notifications = 0;
|
|
editor.subscribe(() => notifications++);
|
|
const result = editor.transaction(tx => {
|
|
tx.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'changed' } });
|
|
tx.dispatch({ type: 'element.geometry', target: target('missing'), patch: { x: 42 } });
|
|
});
|
|
assert.equal(result.status, 'rejected'); assert.strictEqual(editor.getSnapshot(), before); assert.equal(notifications, 0);
|
|
});
|
|
|
|
test('can is pure and command handlers come from the component capability table', () => {
|
|
let ids = 0;
|
|
const frame = node('a', 'root', 'frame'), editor = setup([frame], { createId: () => String(++ids) });
|
|
const before = editor.getSnapshot();
|
|
assert.equal(editor.can({ type: 'element.geometry', target: target('a'), patch: { rotation: 30 } }).enabled, false);
|
|
assert.equal(editor.can({ type: 'element.geometry', target: target('a'), patch: { x: 30 } }).enabled, true);
|
|
assert.equal(ids, 0); assert.strictEqual(editor.getSnapshot(), before);
|
|
});
|
|
|
|
test('absent and explicit null are distinct history values; view selection follows element deletion', async () => {
|
|
const editor = setup();
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { optional: null } });
|
|
assert.equal(Object.hasOwn(editor.getSnapshot().document.elements.get('a').data, 'optional'), true);
|
|
editor.history.undo(); assert.equal(Object.hasOwn(editor.getSnapshot().document.elements.get('a').data, 'optional'), false);
|
|
editor.history.redo(); assert.equal(editor.getSnapshot().document.elements.get('a').data.optional, null);
|
|
const { createSessions } = await import('../../src/lib/canvas-core/gestures.ts');
|
|
const sessions = createSessions(editor); sessions.attach('view'); sessions.select('view', ['a']);
|
|
editor.dispatch({ type: 'element.remove', target: target('a') });
|
|
assert.equal(sessions.getSnapshot().views.get('view').selection.size, 0); sessions.dispose();
|
|
assert.equal(sessions.getSnapshot().views.size, 0);
|
|
});
|
|
|
|
test('permission changes cancel geometry previews and prevent new gestures', async () => {
|
|
let permitted = true;
|
|
const editor = setup(undefined, { policy: () => permitted ? { enabled: true } : { enabled: false, code: 'forbidden', targets: ['a'] } });
|
|
const { createSessions } = await import('../../src/lib/canvas-core/gestures.ts');
|
|
const sessions = createSessions(editor); sessions.attach('view');
|
|
assert.equal(sessions.begin('view', [target('a')]).enabled, true);
|
|
sessions.update('view', target('a'), { x: 100 }); permitted = false;
|
|
editor.updateRuntime(() => ({ permissionEpoch: 2 }));
|
|
assert.equal(sessions.getSnapshot().gesture, null); assert.equal(sessions.getSnapshot().lastCancelReason, 'permission_changed');
|
|
assert.equal(sessions.begin('view', [target('a')]).code, 'forbidden'); sessions.dispose();
|
|
});
|
|
|
|
test('several commands are one history unit; data undo preserves a later resource acknowledgment', () => {
|
|
const editor = setup();
|
|
editor.transaction(tx => {
|
|
tx.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'changed' } });
|
|
tx.dispatch({ type: 'element.geometry', target: target('a'), patch: { x: 30 } });
|
|
});
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { asset: 'stored-asset' } }, { history: false, origin: 'asset-resolution' });
|
|
assert.equal(editor.getSnapshot().history.undo.length, 1);
|
|
assert.equal(editor.history.undo().status, 'applied');
|
|
const value = editor.getSnapshot().document.elements.get('a');
|
|
assert.equal(value.data.title, 'a'); assert.equal(value.geometry.x, 10); assert.equal(value.data.asset, 'stored-asset');
|
|
assert.equal(editor.history.redo().status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').data.asset, 'stored-asset');
|
|
});
|
|
|
|
test('same-field conflict does not pop history or overwrite remote edits', () => {
|
|
const editor = setup();
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'local' } });
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'remote' } }, { history: false, origin: 'remote' });
|
|
const before = editor.getSnapshot();
|
|
assert.equal(editor.history.undo().status, 'rejected'); assert.strictEqual(editor.getSnapshot(), before);
|
|
});
|
|
|
|
test('delete undo restores a new incarnation and the original connections; stale targets remain invalid', () => {
|
|
const edge = { id: 'e', incarnation: 1, ownerCanvasId: 'root', componentId: 'connection', dataVersion: 1, data: {}, structure: 'connection', source: { elementId: 'a' }, target: { elementId: 'b' }, path: null };
|
|
const editor = setup([node('a'), node('b'), edge]);
|
|
assert.equal(editor.dispatch({ type: 'element.remove', target: target('a') }).status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.has('e'), false);
|
|
assert.equal(editor.history.undo().status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').incarnation, 2);
|
|
assert.equal(editor.getSnapshot().document.elements.has('e'), true);
|
|
assert.equal(editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'late result' } }).status, 'rejected');
|
|
assert.equal(editor.history.redo().status, 'applied');
|
|
assert.equal(editor.history.undo().status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').incarnation, 3);
|
|
});
|
|
|
|
test('new user edit clears redo, bounded history evicts old entries, no-op creates no operation', () => {
|
|
const editor = setup(undefined, { historyLimit: 2 });
|
|
for (const title of ['one', 'two', 'three']) editor.dispatch({ type: 'element.data', target: target('a'), patch: { title } });
|
|
assert.equal(editor.getSnapshot().history.undo.length, 2); assert.equal(editor.getSnapshot().history.entries.size, 2);
|
|
editor.history.undo();
|
|
editor.dispatch({ type: 'element.data', target: target('b'), patch: { title: 'new branch' } });
|
|
assert.equal(editor.getSnapshot().history.redo.length, 0);
|
|
const before = editor.getSnapshot();
|
|
editor.dispatch({ type: 'element.data', target: target('b'), patch: { title: 'new branch' } });
|
|
assert.strictEqual(editor.getSnapshot(), before);
|
|
});
|
|
|
|
test('async transactions reject, close their draft, and never publish the asynchronous tail', async () => {
|
|
const editor = setup(), before = editor.getSnapshot(); let captured;
|
|
const result = editor.transaction(async tx => {
|
|
captured = tx;
|
|
tx.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'before await' } });
|
|
await Promise.resolve();
|
|
tx.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'after await' } });
|
|
});
|
|
assert.equal(result.status, 'rejected'); await Promise.resolve(); await Promise.resolve();
|
|
assert.strictEqual(editor.getSnapshot(), before);
|
|
assert.throws(() => captured.dispatch({ type: 'element.remove', target: target('a') }), /transaction_closed/);
|
|
});
|
|
|
|
test('unknown and future components survive known-object editing but cannot use uninstalled behavior', () => {
|
|
const unknown = { ...node('future', 'root', 'future/audio'), dataVersion: 99, data: { novel: ['keep', { every: 'field' }] } };
|
|
const editor = setup([node('a'), unknown]);
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'edited' } });
|
|
assert.deepEqual(editor.getSnapshot().document.elements.get('future'), unknown);
|
|
assert.equal(editor.dispatch({ type: 'element.data', target: target('future'), patch: { title: 'overwrite' } }).status, 'rejected');
|
|
});
|
|
|
|
test('capability conflicts are configuration errors; custom resize handlers can use a different constraint', () => {
|
|
assert.throws(() => createRegistry([defineComponent({ id: 'bad', dataVersion: 1, structure: 'node', validate: () => true, features: [movable(), movable()] })]), /duplicate_feature/);
|
|
const registry = createRegistry([defineComponent({ id: 'ratio', dataVersion: 1, structure: 'node', validate: () => true, features: [resizable({ aspect: true })] })]);
|
|
const editor = setup([{ ...node('a', 'root', 'ratio'), geometry: { ...geometry, width: 200, height: 100 } }], { registry });
|
|
assert.equal(editor.dispatch({ type: 'element.geometry', target: target('a'), patch: { width: 400 } }).status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').geometry.height, 200);
|
|
});
|
|
|
|
test('migration validates a staged copy and retains stable identity and ownership', () => {
|
|
const registry = createRegistry([defineComponent({ id: 'text', dataVersion: 2, structure: 'node', features: [editable()], validate: data => typeof data.heading === 'string', migrations: { 1: data => ({ heading: data.title }) } })]);
|
|
const original = node('a');
|
|
const upgraded = migrateElement(original, registry);
|
|
assert.equal(upgraded.id, original.id); assert.equal(upgraded.ownerCanvasId, original.ownerCanvasId); assert.equal(upgraded.dataVersion, 2);
|
|
assert.equal(original.dataVersion, 1);
|
|
});
|
|
|
|
test('cross-child connection belongs to the common ancestor; cyclic canvas ownership rejects atomically', () => {
|
|
const elements = [node('f'), node('g'), node('a', 'child'), node('b', 'sibling')];
|
|
const canvases = [{ id: 'root', parent: null }, { id: 'child', parent: { canvasId: 'root', entryElementId: 'f' } }, { id: 'sibling', parent: { canvasId: 'root', entryElementId: 'g' } }];
|
|
const registry = createRegistry(builtinComponents());
|
|
const document = createDocument('p', canvases, elements);
|
|
assert.equal(commonCanvas(document, 'child', 'sibling'), 'root');
|
|
const editor = setup(elements, { registry, document }); const before = editor.getSnapshot();
|
|
assert.equal(editor.dispatch({ type: 'canvas.reparent', canvasId: 'root', parent: { canvasId: 'child', entryElementId: 'a' } }).status, 'rejected');
|
|
assert.strictEqual(editor.getSnapshot(), before);
|
|
});
|
|
|
|
test('snapshot collections expose no mutation methods and observer failures do not roll back commits', () => {
|
|
const editor = setup();
|
|
assert.equal(editor.getSnapshot().document.elements.set, undefined);
|
|
editor.subscribe(() => { throw new Error('observer'); });
|
|
assert.equal(editor.dispatch({ type: 'element.data', target: target('a'), patch: { title: 'committed' } }).status, 'applied');
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').data.title, 'committed');
|
|
});
|
|
|
|
test('gesture preview is transient, cancel preserves an upload ACK, commit creates one history entry', async () => {
|
|
const { createSessions } = await import('../../src/lib/canvas-core/gestures.ts');
|
|
const editor = setup(), sessions = createSessions(editor), detach = sessions.attach('view');
|
|
const initial = editor.getSnapshot();
|
|
assert.equal(sessions.begin('view', [target('a')]).enabled, true);
|
|
sessions.update('view', target('a'), { x: 30 }); sessions.update('view', target('a'), { x: 60 });
|
|
assert.strictEqual(editor.getSnapshot(), initial); assert.equal(sessions.effectiveGeometry('a').x, 60);
|
|
editor.dispatch({ type: 'element.data', target: target('a'), patch: { asset: 'stored' } }, { origin: 'asset-resolution', history: false });
|
|
assert.equal(sessions.getSnapshot().gesture.phase, 'active');
|
|
sessions.cancel('escape'); assert.equal(sessions.effectiveGeometry('a').x, 10);
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').data.asset, 'stored');
|
|
sessions.begin('view', [target('a')]); sessions.update('view', target('a'), { x: 90 });
|
|
assert.equal(sessions.commit('view').status, 'applied'); assert.equal(editor.getSnapshot().history.undo.length, 1);
|
|
assert.equal(editor.getSnapshot().document.elements.get('a').geometry.x, 90);
|
|
detach(); sessions.dispose();
|
|
});
|
|
|
|
test('geometry conflict and view detach cancel only that gesture, without deleting model content', async () => {
|
|
const { createSessions } = await import('../../src/lib/canvas-core/gestures.ts');
|
|
const editor = setup(), sessions = createSessions(editor), detach = sessions.attach('view');
|
|
sessions.begin('view', [target('a')]); sessions.update('view', target('a'), { x: 30 });
|
|
editor.dispatch({ type: 'element.geometry', target: target('a'), patch: { x: 70 } }, { origin: 'remote', history: false });
|
|
assert.equal(sessions.getSnapshot().gesture, null); assert.equal(sessions.effectiveGeometry('a').x, 70);
|
|
sessions.begin('view', [target('a')]); sessions.update('view', target('a'), { x: 100 }); detach();
|
|
assert.equal(sessions.getSnapshot().gesture, null); assert.equal(editor.getSnapshot().document.elements.get('a').geometry.x, 70);
|
|
sessions.dispose();
|
|
});
|