Add renderer-independent canvas model, transactions and view sessions
This commit is contained in:
@@ -0,0 +1,103 @@
|
||||
import type { CanvasRecord, Change, Document, ElementRecord, Geometry, Id, Registry, Target } from './types.ts';
|
||||
import { clone, equal, fault, freeze, readMap, validJson } from './values.ts';
|
||||
|
||||
export function createDocument(projectId: Id, canvases: readonly CanvasRecord[], elements: readonly ElementRecord[] = [], tombstones: ReadonlyMap<Id, number> = new Map()): Document {
|
||||
for (const element of elements) if (!validJson(element.data)) throw fault('invalid_element', [element.id]);
|
||||
if (!projectId || new Set(canvases.map(item => item.id)).size !== canvases.length || new Set(elements.map(item => item.id)).size !== elements.length) throw fault('duplicate_identity');
|
||||
return Object.freeze({ projectId, canvases: readMap(new Map(canvases.map(item => [item.id, freeze(clone(item))]))), elements: readMap(new Map(elements.map(item => [item.id, freeze(clone(item))]))), tombstones: readMap(tombstones) });
|
||||
}
|
||||
export function geometryValid(value: Geometry): boolean {
|
||||
return [value.x, value.y, value.width, value.height, value.rotation].every(Number.isFinite) && value.width > 0 && value.height > 0 && value.rotation >= 0 && value.rotation < 360;
|
||||
}
|
||||
export function targetElement(document: Document, target: Target): ElementRecord {
|
||||
const element = document.elements.get(target.id);
|
||||
if (!element) throw fault('element_missing', [target.id]);
|
||||
if (element.incarnation !== target.incarnation) throw fault('stale_incarnation', [target.id]);
|
||||
return element;
|
||||
}
|
||||
export function ancestors(document: Document, canvasId: Id): Id[] {
|
||||
const result: Id[] = [], visited = new Set<Id>();
|
||||
let next: Id | undefined = canvasId;
|
||||
while (next) {
|
||||
if (visited.has(next)) throw fault('canvas_cycle', [next]);
|
||||
visited.add(next); result.push(next);
|
||||
const canvas: CanvasRecord | undefined = document.canvases.get(next);
|
||||
if (!canvas) throw fault('canvas_not_loaded', [next]);
|
||||
next = canvas.parent?.canvasId;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
export function commonCanvas(document: Document, left: Id, right: Id): Id {
|
||||
const parents = new Set(ancestors(document, left));
|
||||
const result = ancestors(document, right).find(id => parents.has(id));
|
||||
if (!result) throw fault('no_common_canvas', [left, right]);
|
||||
return result;
|
||||
}
|
||||
export function validateDocument(document: Document, registry: Registry): void {
|
||||
if (!document.canvases.size) throw fault('missing_root');
|
||||
for (const [id, incarnation] of document.tombstones) if (!id || !Number.isSafeInteger(incarnation) || incarnation < 1) throw fault('invalid_tombstone', [id]);
|
||||
const entries = new Set<Id>();
|
||||
let roots = 0;
|
||||
for (const canvas of document.canvases.values()) {
|
||||
if (!canvas.id) throw fault('invalid_canvas');
|
||||
ancestors(document, canvas.id);
|
||||
if (!canvas.parent) { roots++; continue; }
|
||||
const entry = document.elements.get(canvas.parent.entryElementId);
|
||||
if (!entry || entry.structure !== 'node' || entry.ownerCanvasId !== canvas.parent.canvasId || entries.has(entry.id)) throw fault('invalid_canvas_entry', [canvas.id]);
|
||||
entries.add(entry.id);
|
||||
}
|
||||
if (roots !== 1) throw fault('invalid_roots');
|
||||
for (const element of document.elements.values()) {
|
||||
if (!element.id || !document.canvases.has(element.ownerCanvasId) || !Number.isSafeInteger(element.incarnation) || element.incarnation < 1 || !Number.isSafeInteger(element.dataVersion) || element.dataVersion < 1 || !validJson(element.data)) throw fault('invalid_element', [element.id]);
|
||||
const dead = document.tombstones.get(element.id);
|
||||
if (dead !== undefined && element.incarnation <= dead) throw fault('stale_incarnation', [element.id]);
|
||||
const definition = registry.components.get(element.componentId);
|
||||
if (registry.resolve(element) === 'known' && (!definition || definition.structure !== element.structure || !definition.validate(element.data))) throw fault('invalid_component_data', [element.id]);
|
||||
if (element.structure === 'node') {
|
||||
if (!geometryValid(element.geometry)) throw fault('invalid_geometry', [element.id]);
|
||||
} else {
|
||||
const source = document.elements.get(element.source.elementId), target = document.elements.get(element.target.elementId);
|
||||
if (!source || !target || source.structure !== 'node' || target.structure !== 'node' || !validJson(element.path)) throw fault('invalid_endpoint', [element.id]);
|
||||
if (commonCanvas(document, source.ownerCanvasId, target.ownerCanvasId) !== element.ownerCanvasId) throw fault('invalid_connection_owner', [element.id]);
|
||||
}
|
||||
}
|
||||
}
|
||||
export function applyChanges(document: Document, changes: readonly Change[], conditional = true): Document {
|
||||
const elements = new Map(document.elements), canvases = new Map(document.canvases), tombstones = new Map(document.tombstones);
|
||||
for (const change of changes) {
|
||||
if (change.kind === 'field') {
|
||||
if (!change.field.startsWith('data.') && !['geometry', 'ownerCanvasId', 'source', 'target', 'path'].includes(change.field)) throw fault('invalid_field');
|
||||
const element = elements.get(change.target.id);
|
||||
if (!element || element.incarnation !== change.target.incarnation) throw fault('stale_incarnation', [change.target.id]);
|
||||
const dataKey = change.field.startsWith('data.') ? change.field.slice(5) : null;
|
||||
const prior = dataKey !== null ? element.data[dataKey] ?? null : (element as unknown as Record<string, unknown>)[change.field];
|
||||
if (conditional && (dataKey !== null && Object.hasOwn(element.data, dataKey) !== (change.beforePresent ?? true) || !equal(prior, change.before))) throw fault('field_conflict', [element.id]);
|
||||
if (dataKey !== null) {
|
||||
if (!dataKey || ['__proto__', 'prototype', 'constructor'].includes(dataKey)) throw fault('invalid_field');
|
||||
const data = { ...element.data };
|
||||
if (change.afterPresent === false) delete data[dataKey]; else data[dataKey] = clone(change.after);
|
||||
elements.set(element.id, freeze({ ...element, data }));
|
||||
} else elements.set(element.id, freeze({ ...element, [change.field]: clone(change.after) }) as ElementRecord);
|
||||
} else if (change.kind === 'element') {
|
||||
if (conditional && !equal(elements.get(change.id) || null, change.before)) throw fault('element_conflict', [change.id]);
|
||||
if (change.after) {
|
||||
if (change.after.id !== change.id) throw fault('identity_mismatch', [change.id]);
|
||||
elements.set(change.id, freeze(clone(change.after)));
|
||||
} else {
|
||||
const old = elements.get(change.id);
|
||||
if (old) tombstones.set(change.id, Math.max(tombstones.get(change.id) || 0, old.incarnation));
|
||||
elements.delete(change.id);
|
||||
}
|
||||
} else if (change.kind === 'canvas') {
|
||||
if (conditional && !equal(canvases.get(change.id) || null, change.before)) throw fault('canvas_conflict', [change.id]);
|
||||
if (change.after) {
|
||||
if (change.after.id !== change.id) throw fault('identity_mismatch', [change.id]);
|
||||
canvases.set(change.id, freeze(clone(change.after)));
|
||||
} else canvases.delete(change.id);
|
||||
} else throw fault('invalid_change');
|
||||
}
|
||||
return Object.freeze({ projectId: document.projectId, elements: readMap(elements), canvases: readMap(canvases), tombstones: readMap(tombstones) });
|
||||
}
|
||||
export function invert(changes: readonly Change[]): readonly Change[] {
|
||||
return changes.slice().reverse().map(change => freeze({ ...change, before: change.after, after: change.before, ...(change.kind === 'field' ? { beforePresent: change.afterPresent, afterPresent: change.beforePresent } : {}) }) as Change);
|
||||
}
|
||||
Reference in New Issue
Block a user