@neta-art/cohub 9.0.1 → 11.0.0

package/dist/board/editor/document.js

@@ -0,0 +1,302 @@
+import { IDENTITY_MATRIX, arrowBindings } from "../../protocol/dist/board-layout.js";
+import { applyBoardPatchToDocument } from "../../protocol/dist/board-patch.js";
+import { compileBoardAnimations, evaluateBoardAnimations } from "../model/animation.js";
+import { buildBoardScene, placeItem, refreshBoardScene } from "../model/scene.js";
+import { diffBoardEdits, isEmptyBoardPatch, routeBoardEdits, sameJson } from "./document-edits.js";
+//#region src/board/editor/document.ts
+function createDocumentModule(ctx) {
+	const { state, options } = ctx;
+	const draft = /* @__PURE__ */ new Map();
+	const draftOrigins = /* @__PURE__ */ new Map();
+	const recentlyAdded = /* @__PURE__ */ new Set();
+	let evaluated = /* @__PURE__ */ new Map();
+	let played = /* @__PURE__ */ new Map();
+	let scripted = /* @__PURE__ */ new Map();
+	let compiled = null;
+	function markAdded(ids) {
+		if (ids.length === 0) return;
+		recentlyAdded.clear();
+		for (const id of ids) recentlyAdded.add(id);
+	}
+	function consumeRecentlyAdded() {
+		const ids = [...recentlyAdded];
+		recentlyAdded.clear();
+		return ids;
+	}
+	function displayItem(id) {
+		if (draft.has(id)) return draft.get(id) ?? void 0;
+		return scripted.get(id) ?? evaluated.get(id) ?? played.get(id) ?? state.base.items[id];
+	}
+	function displayDocument(includeScripts = true) {
+		const base = state.base;
+		if (draft.size === 0 && evaluated.size === 0 && played.size === 0 && (!includeScripts || scripted.size === 0)) return base;
+		const items = { ...base.items };
+		for (const [id, item] of played) items[id] = item;
+		for (const [id, item] of evaluated) items[id] = item;
+		if (includeScripts) for (const [id, item] of scripted) items[id] = item;
+		for (const [id, item] of draft) if (item) items[id] = item;
+		else delete items[id];
+		return {
+			...base,
+			items
+		};
+	}
+	function reevaluate() {
+		const { base, playhead } = state;
+		if (!playhead || !base.animations[playhead.animationId]) {
+			evaluated = /* @__PURE__ */ new Map();
+			return;
+		}
+		if (!compiled || compiled.animations !== base.animations || compiled.items !== base.items) compiled = {
+			animations: base.animations,
+			items: base.items,
+			value: compileBoardAnimations(base)
+		};
+		evaluated = evaluateBoardAnimations(compiled.value, { [playhead.animationId]: playhead.time }).items;
+	}
+	function setPlayedItems(items) {
+		const previous = played;
+		played = new Map([...items].filter(([id]) => state.base.items[id]));
+		const changed = /* @__PURE__ */ new Set([...previous.keys(), ...played.keys()]);
+		for (const id of changed) if (draft.has(id) || evaluated.has(id) || sameJson(previous.get(id), played.get(id))) changed.delete(id);
+		if (changed.size) rescene(changed);
+	}
+	function setScriptItems(items) {
+		const previous = scripted;
+		scripted = items;
+		const changed = [.../* @__PURE__ */ new Set([...previous.keys(), ...items.keys()])].filter((id) => !sameJson(previous.get(id), items.get(id)));
+		if (!changed.length) return;
+		rescene(changed.some((id) => {
+			const before = previous.get(id) ?? state.base.items[id];
+			const after = items.get(id) ?? state.base.items[id];
+			return !before || !after || before.parent !== after.parent || before.z !== after.z || !sameJson(arrowBindings(before), arrowBindings(after));
+		}) ? void 0 : changed);
+	}
+	function rescene(ids) {
+		if (ids) {
+			const changed = [...ids];
+			state.scene = refreshBoardScene(state.scene, displayItem, changed);
+			ctx.query.invalidate(changed);
+		} else {
+			state.scene = buildBoardScene(displayDocument(), state.scene);
+			ctx.query.invalidate();
+			state.structureVersion += 1;
+		}
+		state.geometryVersion += 1;
+	}
+	function reset(next) {
+		state.base = next;
+		draft.clear();
+		draftOrigins.clear();
+		played = /* @__PURE__ */ new Map();
+		scripted = /* @__PURE__ */ new Map();
+		reevaluate();
+		state.scene = buildBoardScene(next);
+		ctx.query.invalidate();
+		state.structureVersion += 1;
+		state.geometryVersion += 1;
+	}
+	function setDraftItem(id, item) {
+		if (!draft.has(id)) {
+			const shown = displayItem(id);
+			if (shown) draftOrigins.set(id, shown);
+		}
+		draft.set(id, item);
+	}
+	function draftItem(id) {
+		return draft.get(id);
+	}
+	function dropDraftItem(id) {
+		draft.delete(id);
+	}
+	function writeDraft(changes, structural = false) {
+		if (changes.size === 0) return;
+		for (const [id, item] of changes) setDraftItem(id, item);
+		if (!structural) for (const [id, item] of changes) {
+			const before = state.scene.get(id);
+			if (!item || !before || before.parent !== item.parent || before.z !== item.z || !sameJson(arrowBindings(before), arrowBindings(item))) {
+				structural = true;
+				break;
+			}
+		}
+		rescene(structural ? void 0 : changes.keys());
+	}
+	function discardDraft() {
+		draft.clear();
+		draftOrigins.clear();
+		reevaluate();
+		rescene();
+	}
+	function send(patch) {
+		if (options.readonly || isEmptyBoardPatch(patch)) return Promise.resolve(null);
+		state.pendingCommits += 1;
+		let completion;
+		try {
+			completion = Promise.resolve(options.onCommit(patch));
+		} catch (error) {
+			completion = Promise.reject(error);
+		}
+		return completion.then(() => {
+			state.saveError = null;
+			return null;
+		}).catch((error) => {
+			state.saveError = error instanceof Error ? error.message : "Failed to sync board";
+			return error instanceof Error ? error : new Error(state.saveError);
+		}).finally(() => {
+			state.pendingCommits -= 1;
+		});
+	}
+	function adopt(next, changedIds) {
+		const base = state.base;
+		const structural = played.size > 0 || !changedIds || next.animations !== base.animations || next.board !== base.board;
+		state.base = next;
+		played = /* @__PURE__ */ new Map();
+		draft.clear();
+		draftOrigins.clear();
+		reevaluate();
+		if (structural || state.playhead) {
+			rescene();
+			return;
+		}
+		const ids = [...changedIds];
+		rescene(ids.some((id) => {
+			const before = state.scene.get(id);
+			const after = next.items[id];
+			return !before || !after || before.parent !== after.parent || before.z !== after.z || !sameJson(arrowBindings(before), arrowBindings(after));
+		}) ? void 0 : ids);
+	}
+	function commit(extra = {}, record = true) {
+		const ids = [...draft.keys()];
+		const base = state.base;
+		let target = routeBoardEdits({
+			base,
+			evaluated,
+			draft,
+			playhead: state.playhead,
+			recording: state.recording,
+			displayed: draftOrigins
+		});
+		if (extra.board) target = {
+			...target,
+			board: extra.board
+		};
+		if (extra.animations) target = {
+			...target,
+			animations: extra.animations
+		};
+		const redo = diffBoardEdits(base, target, ids);
+		if (isEmptyBoardPatch(redo)) {
+			adopt(base);
+			return;
+		}
+		if (record) {
+			const undo = diffBoardEdits(target, base, ids);
+			state.undoStack = [...state.undoStack.slice(-199), {
+				undo,
+				redo
+			}];
+			state.redoStack = [];
+		}
+		adopt(target, ids);
+		send(redo);
+	}
+	function commitItems(changes, record = true) {
+		if (changes.size === 0) return;
+		for (const [id, item] of changes) setDraftItem(id, item);
+		commit({}, record);
+	}
+	function commitPatch(patch) {
+		if (options.readonly) throw new Error("Board is read-only.");
+		const before = state.base;
+		const result = applyBoardPatchToDocument(before, patch);
+		if (!result.ok) throw new Error(result.diagnostics[0]?.message ?? "Invalid board patch.");
+		const ids = Object.keys(patch.items ?? {});
+		const redo = diffBoardEdits(before, result.document, ids);
+		if (isEmptyBoardPatch(redo)) return;
+		state.undoStack = [...state.undoStack.slice(-199), {
+			undo: diffBoardEdits(result.document, before, ids),
+			redo
+		}];
+		state.redoStack = [];
+		adopt(result.document, ids);
+		return send(redo).then((error) => {
+			if (error) throw error;
+		});
+	}
+	function applyPatch(patch) {
+		const result = applyBoardPatchToDocument(state.base, patch);
+		if (!result.ok) {
+			state.saveError = result.diagnostics[0]?.message ?? "Could not apply the change";
+			return false;
+		}
+		adopt(result.document, Object.keys(patch.items ?? {}));
+		send(patch);
+		return true;
+	}
+	function undo() {
+		const entry = state.undoStack.at(-1);
+		if (!entry) return;
+		state.undoStack = state.undoStack.slice(0, -1);
+		if (applyPatch(entry.undo)) state.redoStack = [...state.redoStack, entry];
+	}
+	function redo() {
+		const entry = state.redoStack.at(-1);
+		if (!entry) return;
+		state.redoStack = state.redoStack.slice(0, -1);
+		if (applyPatch(entry.redo)) state.undoStack = [...state.undoStack, entry];
+	}
+	function previewSettings(settings) {
+		state.settingsPreview = settings;
+	}
+	function setSettings(settings) {
+		state.settingsPreview = null;
+		if (!sameJson(settings, state.base.board)) commit({ board: settings });
+	}
+	function reparent(item, frame, parent, box) {
+		const { parent: _previous, ...root } = item;
+		const orphan = root;
+		const next = parent ? {
+			...orphan,
+			parent
+		} : orphan;
+		const matrix = parent ? state.scene.layout.matrix(parent) : IDENTITY_MATRIX;
+		return placeItem(next, frame, matrix, box);
+	}
+	function topZ(parent, scene = state.scene) {
+		let z = 0;
+		for (const id of scene.children(parent)) z = Math.max(z, scene.get(id)?.z ?? 0);
+		return z + 1;
+	}
+	return {
+		markAdded,
+		consumeRecentlyAdded,
+		displayItem,
+		copyScene: () => scripted.size ? buildBoardScene(displayDocument(false)) : state.scene,
+		reevaluate,
+		setPlayedItems,
+		get hasScriptItems() {
+			return scripted.size > 0;
+		},
+		setScriptItems,
+		animationItems: () => new Map([...played, ...evaluated]),
+		commitPatch,
+		rescene,
+		reset,
+		setDraftItem,
+		draftItem,
+		dropDraftItem,
+		writeDraft,
+		discardDraft,
+		adopt,
+		commit,
+		commitItems,
+		undo,
+		redo,
+		previewSettings,
+		setSettings,
+		reparent,
+		topZ
+	};
+}
+//#endregion
+export { createDocumentModule };

package/dist/board/editor/editor.d.ts

@@ -0,0 +1,225 @@
+import { BoardDocument, BoardItem, BoardMediaSnapshot, BoardPatch, BoardSettings, BoardTaskSnapshot } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
+import { BoardViewport, Rect, ScreenPoint, WorldPoint } from "../model/geometry.js";
+import { BoardScene, BoardSceneItem } from "../model/scene.js";
+import { BoardChapter } from "../model/authoring.js";
+import { BoardFileSnapshotFacts } from "../model/file-snapshot.js";
+import { ShapeKind } from "../model/shape-types.js";
+import { BoardItemEntry, BoardMediaItemKind } from "../model/items/create.js";
+import { BoardItemInput, BoardRegistry } from "../model/items/registry.js";
+import "../model/index.js";
+import { AlignMode, DistributeAxis } from "./align.js";
+import { BoardFocusOptions } from "./camera.js";
+import { BoardSelectionTransform, BoardTransformControl } from "./selection-transform.js";
+import { BoardInteraction, BoardPointerEvent } from "./interaction.js";
+import { BoardAppMetadata, BoardTaskSource } from "./creation.js";
+import { BoardClipboardPayload } from "./clipboard.js";
+import { BoardNaturalSize } from "./snapshots.js";
+import { SnapGuide } from "./snapping.js";
+import { BoardEditorChannel, BoardEditorListener } from "./state.js";
+import { BoardToolId } from "./tool.js";
+import { BoardCameraPolicy, BoardEditorOptions, BoardPlayhead } from "./context.js";
+//#region src/board/editor/editor.d.ts
+declare function createBoardEditor(options: BoardEditorOptions): {
+  registry: BoardRegistry;
+  readonly: boolean;
+  subscribe: (channels: BoardEditorChannel | readonly BoardEditorChannel[], listener: BoardEditorListener) => () => void;
+  readonly hasScripts: boolean;
+  readonly document: BoardDocument;
+  readonly settings: {
+    title?: string | undefined;
+    background: {
+      kind: "dots" | "grid" | "image" | "solid";
+      color?: string | {
+        light: string;
+        dark: string;
+      } | undefined;
+      imageUrl?: string | undefined;
+      fit?: "contain" | "cover" | "repeat" | undefined;
+      opacity?: number | undefined;
+    };
+    grid?: {
+      visible: boolean;
+      size: number;
+    } | undefined;
+    enter?: {
+      preset: "deal" | "drop" | "fade-in" | "pop" | "rise";
+      duration?: number | undefined;
+    } | undefined;
+  };
+  readonly animations: Record<string, {
+    name?: string | undefined;
+    duration: number;
+    play: "always" | "auto" | "manual";
+    delay: number;
+    loop: boolean;
+    end: "hold" | "reset";
+    markers: {
+      at: number;
+      label?: string | undefined;
+      pause?: boolean | undefined;
+    }[];
+    tracks: Record<string, {
+      target: string;
+      property: string;
+      keyframes: {
+        at: number;
+        value: unknown;
+        ease?: string | undefined;
+      }[];
+      composite: "add" | "replace";
+      interpolation: "auto" | "spline" | "step";
+      orient?: boolean | undefined;
+    }>;
+  }>;
+  readonly scene: BoardScene;
+  readonly items: readonly BoardSceneItem[];
+  readonly hasContent: boolean;
+  readonly structureVersion: number;
+  readonly geometryVersion: number;
+  readonly selection: string[];
+  readonly selectedItems: BoardSceneItem[];
+  readonly hasFocusableSelection: boolean;
+  readonly selectionLocked: boolean;
+  readonly bounds: Rect | null;
+  readonly selectionTransform: BoardSelectionTransform | null;
+  readonly camera: BoardViewport;
+  readonly cameraPolicy: BoardCameraPolicy;
+  readonly playhead: BoardPlayhead | null;
+  readonly recording: boolean;
+  tool: BoardToolId;
+  activeColor: string;
+  activeShape: string;
+  activeStrokeSize: number;
+  readonly interaction: BoardInteraction;
+  readonly gestureActive: boolean;
+  readonly marquee: Rect | null;
+  readonly snapGuides: SnapGuide[];
+  spaceHeld: boolean;
+  readonly arrowDraft: {
+    from: WorldPoint;
+    to: WorldPoint;
+    size: number;
+    color: string;
+    targetFrame: BoardFrame | null;
+  } | null;
+  readonly bindTargetFrame: BoardFrame | null;
+  readonly hoverId: string | null;
+  readonly pointerType: string;
+  readonly hoveredTransformControl: BoardTransformControl | null;
+  readonly connectionPorts: {
+    itemId: string;
+    x: number;
+    y: number;
+    radius: number;
+  }[];
+  readonly hoveredConnectionPort: {
+    x: number;
+    y: number;
+  } | null;
+  editingId: string | null;
+  readonly canUndo: boolean;
+  readonly canRedo: boolean;
+  readonly saveError: string | null;
+  readonly saving: boolean;
+  surfaceSize: {
+    width: number;
+    height: number;
+  };
+  loadDocument: (next: BoardDocument, key?: string) => void;
+  undo: () => void;
+  redo: () => void;
+  retrySave: () => void;
+  setSettings: (settings: BoardSettings) => void;
+  previewSettings: (settings: BoardSettings) => void;
+  setPlayedItems: (items: ReadonlyMap<string, BoardItem>) => void;
+  setScriptItems: (items: ReadonlyMap<string, BoardItem>) => void;
+  animationItems: () => Map<string, BoardItem>;
+  commitPatch: (patch: BoardPatch) => Promise<void> | undefined;
+  consumeRecentlyAdded: () => string[];
+  itemAt: (point: WorldPoint, exclude?: ReadonlySet<string> | undefined, includeTemporary?: boolean | undefined) => BoardSceneItem | null;
+  itemById: (id: string) => BoardSceneItem | null;
+  labelItemAt: (point: WorldPoint) => BoardSceneItem | null;
+  idsInRect: (rect: Rect, includeTemporary?: boolean | undefined) => string[];
+  setCamera: (viewport: BoardViewport) => void;
+  setCameraPolicy: (policy: BoardCameraPolicy) => void;
+  takeCameraControl: () => void;
+  viewCenter: () => WorldPoint;
+  zoomAt: (point: ScreenPoint, factor: number, animate?: boolean) => void;
+  zoomIn: () => void;
+  zoomOut: () => void;
+  resetZoom: () => void;
+  fitView: (focus?: BoardFocusOptions) => void;
+  focusRect: (rect: Rect, focus?: BoardFocusOptions) => void;
+  focusItems: (ids: Iterable<string>, focus?: BoardFocusOptions) => void;
+  focusNode: (id: string, focus?: BoardFocusOptions) => void;
+  focusSelection: (focus?: BoardFocusOptions) => void;
+  wheel: (point: ScreenPoint, deltaX: number, deltaY: number, zoomKey: boolean, deltaMode?: number) => void;
+  setSelection: (ids: string[]) => void;
+  clearSelection: () => void;
+  selectAll: () => void;
+  nudgeSelection: (dx: number, dy: number, large: boolean) => void;
+  alignSelection: (mode: AlignMode) => void;
+  distributeSelection: (axis: DistributeAxis) => void;
+  toggleSelectionLock: () => void;
+  setSelectionColor: (color: string) => void;
+  setSelectionStyle: (style: Partial<BoardItem["style"]>) => void;
+  setSelectionProps: (type: string, props: Record<string, unknown>) => void;
+  bringToFront: () => void;
+  sendToBack: () => void;
+  addItem: (type: string, input: BoardItemInput) => string | null;
+  addItems: (entries: BoardItemEntry[], { select, enter }?: {
+    select?: boolean;
+    enter?: boolean;
+  }) => void;
+  addApp: (app: BoardAppMetadata, at: WorldPoint) => string;
+  addFile: (path: string, at: WorldPoint, snapshot?: BoardMediaSnapshot & BoardFileSnapshotFacts) => string;
+  addMedia: (src: string, at: WorldPoint, options?: {
+    kind?: BoardMediaItemKind;
+    snapshot?: BoardMediaSnapshot;
+  }) => string;
+  addTask: (taskRunId: string, snapshot: BoardTaskSnapshot, at: WorldPoint, metadata?: Record<string, unknown>) => string;
+  addTaskWithSources: (taskRunId: string, snapshot: BoardTaskSnapshot, at: WorldPoint, sources: BoardTaskSource[], metadata?: Record<string, unknown>) => string | null;
+  addText: (text: string, at: WorldPoint) => void;
+  addShape: (at: WorldPoint, geometry?: ShapeKind) => void;
+  addFrame: (at: WorldPoint) => void;
+  beginTextDraft: (at: WorldPoint) => void;
+  commitTextEdit: (id: string, text: string) => void;
+  updateText: (id: string, text: string, created?: boolean) => void;
+  previewTextLayout: (id: string, text: string) => void;
+  deleteSelection: () => void;
+  deleteItem: (id: string) => void;
+  duplicateSelection: () => void;
+  copySelection: () => BoardClipboardPayload | null;
+  cutSelection: () => BoardClipboardPayload | null;
+  pasteClipboard: (raw?: unknown, at?: WorldPoint) => void;
+  applyMediaFileChange: (path: string, change: {
+    size?: number;
+    mtimeMs?: number;
+    removed?: boolean;
+  }) => void;
+  adoptMediaNaturalSizes: (sizes: BoardNaturalSize[]) => void;
+  applyFileSnapshots: (snapshots: Array<{
+    id: string;
+    snapshot: BoardFileSnapshotFacts;
+    replace?: boolean;
+  }>) => void;
+  applyTaskSnapshots: (snapshots: ReadonlyMap<string, BoardTaskSnapshot>) => void;
+  setPlayhead: (next: BoardPlayhead | null) => void;
+  setRecording: (value: boolean) => void;
+  keyframeState: (property: string) => "animated" | "keyframe" | "none";
+  toggleKeyframe: (property: string) => void;
+  removeKeyframe: (trackId: string, at: number) => void;
+  setKeyframeEase: (trackId: string, at: number, ease: string | null) => void;
+  createAnimation: (name: string, duration?: number) => string;
+  createSequence: (name: string, chapters: BoardChapter[]) => string | null;
+  pointerDown: (event: BoardPointerEvent) => void;
+  pointerMove: (event: BoardPointerEvent) => void;
+  pointerUp: (event: BoardPointerEvent) => void;
+  pointerLeave: () => void;
+  cancelPointerInteraction: () => void;
+  destroy(): void;
+};
+type BoardEditor = ReturnType<typeof createBoardEditor>;
+//#endregion
+export { BoardEditor, createBoardEditor };