@neta-art/cohub 10.0.0 → 11.1.0

package/dist/board/model/script-scene.js

@@ -0,0 +1,294 @@
+import { parseBoardItem as parseBoardItem$1 } from "../../protocol/dist/board-model.js";
+import { applyMatrix, createBoardLayout } from "../../protocol/dist/board-layout.js";
+import { applyBoardPatchToDocument, mergePatch } from "../../protocol/dist/board-patch.js";
+//#region src/board/model/script-scene.ts
+function parseBoardItem(value) {
+	const parsed = parseBoardItem$1(value);
+	if (!parsed.ok) throw new Error(parsed.diagnostics[0]?.message ?? "Invalid script item.");
+	return parsed.item;
+}
+const DISPLAY_FIELDS = /* @__PURE__ */ new Set([
+	"position",
+	"size",
+	"rotation",
+	"scale",
+	"opacity",
+	"style",
+	"props"
+]);
+function boardScriptScope(document, id) {
+	const scope = /* @__PURE__ */ new Set([id, ...Object.values(document.items[id]?.script?.targets ?? {}).filter((target) => Boolean(document.items[target]))]);
+	if (document.items[id]?.type !== "frame") return scope;
+	for (const candidate of Object.keys(document.items)) {
+		let parent = document.items[candidate]?.parent;
+		for (let depth = 0; parent && depth < 64; depth++) {
+			if (parent === id) {
+				scope.add(candidate);
+				break;
+			}
+			parent = document.items[parent]?.parent;
+		}
+	}
+	return scope;
+}
+function validateBoardScriptOutput(output, scope) {
+	if (!output || typeof output !== "object" || !output.patches || !output.items || !output.hits || !Array.isArray(output.listens)) throw new Error("Invalid script output.");
+	if (JSON.stringify(output).length > 1e6) throw new Error("Script output exceeds the 1 MB limit.");
+	if (output.space !== void 0 && output.space !== "world" && output.space !== "screen") throw new Error("Invalid script scene space.");
+	if (output.anchor) {
+		const { item, point } = output.anchor;
+		if (output.space !== "screen" || typeof item !== "string" || !item || point && ![point.x, point.y].every((n) => Number.isFinite(n) && n >= 0 && n <= 1)) throw new Error("Invalid screen scene anchor.");
+	}
+	if (output.parameters) {
+		if (Object.keys(output.parameters).length > 64) throw new Error("A script may declare at most 64 parameters.");
+		for (const spec of Object.values(output.parameters)) {
+			if (!spec || ![
+				"number",
+				"boolean",
+				"string",
+				"color"
+			].includes(spec.type)) throw new Error("Invalid script parameter type.");
+			if (spec.label !== void 0 && typeof spec.label !== "string") throw new Error("Invalid script parameter label.");
+			if ([
+				spec.min,
+				spec.max,
+				spec.step
+			].some((value) => value !== void 0 && !Number.isFinite(value))) throw new Error("Invalid script parameter range.");
+		}
+	}
+	if (Object.keys(output.items).length > 1e3 || Object.keys(output.hits).length > 1e3) throw new Error("A script may create at most 1000 temporary items or hit regions.");
+	for (const [id, patch] of Object.entries(output.patches)) {
+		if (!scope.has(id)) throw new Error(`Item is outside the script scope: ${id}`);
+		if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => !DISPLAY_FIELDS.has(key))) throw new Error("Scripts may only present display properties.");
+	}
+	for (const hit of Object.values(output.hits)) {
+		if (!hit || typeof hit !== "object") throw new Error("Invalid script hit region.");
+		if (hit.cursor && ![
+			"default",
+			"pointer",
+			"grab",
+			"grabbing",
+			"crosshair",
+			"text",
+			"move",
+			"ew-resize",
+			"ns-resize",
+			"not-allowed"
+		].includes(hit.cursor)) throw new Error("Invalid script cursor.");
+		if ("target" in hit) {
+			if (hit.target !== "self" || "item" in hit || "x" in hit) throw new Error("Invalid script hit target.");
+		} else if ("item" in hit) {
+			if (typeof hit.item !== "string" || !Object.hasOwn(output.items, hit.item) || "x" in hit) throw new Error("Hit items must belong to the temporary scene.");
+		} else if (![
+			hit.x,
+			hit.y,
+			hit.width,
+			hit.height
+		].every(Number.isFinite) || hit.width < 0 || hit.height < 0) throw new Error("Invalid script hit region.");
+	}
+}
+function validateBoardScriptCommit(document, id, patch) {
+	if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => key !== "items")) throw new Error("Scripts may only commit items in their scope.");
+	const scope = boardScriptScope(document, id);
+	for (const [target, value] of Object.entries(patch.items ?? {})) {
+		if (!scope.has(target)) {
+			if (document.items[target]) throw new Error(`Item is outside the script scope: ${target}`);
+			if (!value || typeof value !== "object" || !("parent" in value) || typeof value.parent !== "string" || !scope.has(value.parent) || document.items[value.parent]?.type !== "frame") throw new Error("New items must belong to a frame in the script scope.");
+			if ("script" in value) throw new Error("Scripts cannot start other scripts.");
+			continue;
+		}
+		if (value && typeof value === "object" && ("script" in value || "parent" in value || "type" in value)) throw new Error("A script cannot replace scripts, types, or parent relationships.");
+	}
+	const result = applyBoardPatchToDocument(document, patch);
+	if (!result.ok) throw new Error(result.diagnostics[0]?.message ?? "Invalid script commit.");
+}
+function scriptTemporaryPrefix(owner) {
+	let hash = 2166136261;
+	for (const char of owner) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619) >>> 0;
+	return `~script-${hash.toString(36)}-`;
+}
+const preparedOutputs = /* @__PURE__ */ new WeakMap();
+const preparedScopes = /* @__PURE__ */ new WeakMap();
+const itemOrders = /* @__PURE__ */ new WeakMap();
+function orderedScriptOwners(document, outputs) {
+	let order = itemOrders.get(document.items);
+	if (!order) {
+		order = new Map(Object.keys(document.items).map((id, index) => [id, index]));
+		itemOrders.set(document.items, order);
+	}
+	return [...outputs.keys()].filter((id) => order.has(id)).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+}
+function prepareBoardScriptOutput(document, owner, output) {
+	const previous = preparedOutputs.get(output);
+	if (previous?.document === document && previous.owner === owner) return previous;
+	let scopes = preparedScopes.get(document);
+	if (!scopes) {
+		scopes = /* @__PURE__ */ new Map();
+		preparedScopes.set(document, scopes);
+	}
+	let scope = scopes.get(owner);
+	if (!scope) {
+		scope = boardScriptScope(document, owner);
+		scopes.set(owner, scope);
+	}
+	if (output.anchor && document.items[output.anchor.item] && !scope.has(output.anchor.item)) throw new Error("Scene anchor is outside the script scope.");
+	validateBoardScriptOutput(output, scope);
+	const presented = /* @__PURE__ */ new Map();
+	for (const [id, patch] of Object.entries(output.patches)) {
+		const base = document.items[id];
+		if (base) presented.set(id, {
+			base,
+			item: parseBoardItem(mergePatch(base, patch))
+		});
+	}
+	const prefix = scriptTemporaryPrefix(owner);
+	const rootId = `${prefix}root`;
+	if (document.items[rootId]) throw new Error("Temporary item ID conflicts with the document.");
+	const items = /* @__PURE__ */ new Map();
+	const parsed = new Map(Object.entries(output.items).map(([id, value]) => [id, parseBoardItem(value)]));
+	for (const [local, value] of parsed) {
+		if (!/^[a-zA-Z0-9_-]{1,80}$/.test(local) || local === "root") throw new Error("Temporary IDs must be 1–80 letters, digits, underscores or hyphens; root is reserved.");
+		if (value.script) throw new Error("Temporary items cannot start scripts.");
+		if (value.parent && !(value.parent in output.items)) throw new Error("Temporary parents must belong to the same instance.");
+		let cursor = value.parent;
+		const visited = /* @__PURE__ */ new Set([local]);
+		while (cursor) {
+			if (visited.has(cursor)) throw new Error("Temporary parents must not form a cycle.");
+			visited.add(cursor);
+			const parentItem = parsed.get(cursor);
+			if (!parentItem) throw new Error("Temporary parent is missing.");
+			if (parentItem.type !== "frame") throw new Error("Only frames can contain temporary items.");
+			cursor = parentItem.parent;
+		}
+		const id = `${prefix}${local}`;
+		if (document.items[id]) throw new Error("Temporary item ID conflicts with the document.");
+		const parent = value.parent ? `${prefix}${value.parent}` : rootId;
+		if (value.type === "arrow") {
+			const remap = (endpoint) => {
+				if (!("item" in endpoint)) return endpoint;
+				if (!(endpoint.item in output.items) && !scope.has(endpoint.item)) throw new Error("Arrow target is outside the script scope.");
+				return endpoint.item in output.items ? {
+					...endpoint,
+					item: `${prefix}${endpoint.item}`
+				} : endpoint;
+			};
+			items.set(id, {
+				...value,
+				parent,
+				props: {
+					...value.props,
+					start: remap(value.props.start),
+					end: remap(value.props.end)
+				}
+			});
+		} else items.set(id, {
+			...value,
+			parent
+		});
+	}
+	const prepared = {
+		document,
+		owner,
+		rootId,
+		items,
+		presented
+	};
+	preparedOutputs.set(output, prepared);
+	return prepared;
+}
+function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE__ */ new Map(), screen, onError, gestureLayout) {
+	const result = new Map(incoming);
+	const screenAnchors = /* @__PURE__ */ new Map();
+	if (outputs.size === 0) return result;
+	for (const owner of orderedScriptOwners(document, outputs)) {
+		const output = outputs.get(owner);
+		if (!output) continue;
+		try {
+			const changes = /* @__PURE__ */ new Map();
+			const prepared = prepareBoardScriptOutput(document, owner, output);
+			for (const [id, patch] of Object.entries(output.patches)) {
+				const base = result.get(id) ?? document.items[id];
+				if (!base) continue;
+				let cached = prepared.presented.get(id);
+				if (cached?.base !== base) {
+					cached = {
+						base,
+						item: parseBoardItem(mergePatch(base, patch))
+					};
+					prepared.presented.set(id, cached);
+				}
+				changes.set(id, cached.item);
+			}
+			if (!prepared.items.size || output.space === "screen" && !screen) {
+				for (const [id, item] of changes) result.set(id, item);
+				continue;
+			}
+			const rootId = prepared.rootId;
+			const item = changes.get(owner) ?? result.get(owner) ?? document.items[owner];
+			if (!item) continue;
+			const box = scene.layout.box(owner);
+			const overlay = output.space === "screen" && screen ? {
+				parent: void 0,
+				position: {
+					x: 0,
+					y: 0
+				},
+				scale: 1 / screen.zoom,
+				rotation: 0,
+				origin: {
+					x: 0,
+					y: 0
+				}
+			} : {};
+			changes.set(rootId, parseBoardItem({
+				type: "frame",
+				parent: item.parent,
+				position: item.position,
+				rotation: item.rotation,
+				scale: item.scale,
+				origin: item.origin,
+				opacity: item.opacity,
+				size: {
+					width: Math.max(1, box.width),
+					height: Math.max(1, box.height)
+				},
+				z: (item.z ?? 0) + .001,
+				props: {
+					decoration: "none",
+					clip: false
+				},
+				...overlay
+			}));
+			for (const [id, value] of prepared.items) changes.set(id, value);
+			for (const [id, item] of changes) result.set(id, item);
+			if (output.space === "screen") screenAnchors.set(owner, rootId);
+		} catch (error) {
+			if (!onError) throw error;
+			onError(owner, error);
+		}
+	}
+	if (screenAnchors.size) {
+		const layout = gestureLayout ?? createBoardLayout((id) => result.get(id) ?? document.items[id]);
+		for (const [owner, rootId] of screenAnchors) {
+			const root = result.get(rootId);
+			const anchor = outputs.get(owner)?.anchor;
+			const target = anchor?.item ?? owner;
+			const exists = Boolean(document.items[target]);
+			const box = exists ? layout.box(target) : {
+				width: 0,
+				height: 0
+			};
+			if (root) result.set(rootId, {
+				...root,
+				opacity: exists ? root.opacity : 0,
+				position: exists ? applyMatrix(layout.matrix(target), {
+					x: (anchor?.point?.x ?? 0) * box.width,
+					y: (anchor?.point?.y ?? 0) * box.height
+				}) : root.position
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };

package/dist/board/model/script.d.ts

@@ -0,0 +1,149 @@
+import { BoardItem, BoardPatch, BoardScript, BoardVec2 } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/script.d.ts
+type BoardScriptView = {
+  camera: {
+    x: number;
+    y: number;
+    zoom: number;
+  };
+  width: number;
+  height: number;
+  safeRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+};
+type BoardScriptAnchor = {
+  item: string;
+  point?: BoardVec2;
+};
+type BoardScriptSceneOptions = {
+  space?: "world" | "screen";
+  anchor?: BoardScriptAnchor;
+};
+type BoardScriptEvent = {
+  type: string;
+  target?: string;
+  relatedTarget?: string;
+  relatedOwner?: string;
+  point?: BoardVec2;
+  pointerId?: number;
+  pointerType?: string;
+  buttons?: number;
+  key?: string;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  data?: unknown;
+};
+type BoardScriptHostEvents = {
+  viewchange: BoardScriptView;
+  selectionchange: {
+    ids: string[];
+  };
+  transformend: {
+    ids: string[];
+    operation: "move" | "resize" | "rotate" | "arrow";
+    cancelled: boolean;
+  };
+};
+type BoardScriptEventOf<Type extends string> = BoardScriptEvent & {
+  type: Type;
+} & (Type extends keyof BoardScriptHostEvents ? {
+  data: BoardScriptHostEvents[Type];
+} : unknown);
+type BoardScriptFrame = {
+  t: number;
+  dt: number;
+  width: number;
+  height: number;
+  seed: string;
+  params: BoardScript["params"];
+  state: Record<string, unknown>;
+};
+type BoardScriptItemPatch = Partial<Pick<BoardItem, "position" | "scale" | "rotation" | "opacity" | "style">> & {
+  size?: {
+    width?: number;
+    height?: number;
+  };
+  props?: Record<string, unknown>;
+};
+type BoardScriptHit = ({
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+} | {
+  target: "self";
+} | {
+  item: string;
+}) & {
+  label?: string;
+  cursor?: string;
+};
+type BoardScriptSnapshot = {
+  state: Record<string, unknown>;
+  time: number;
+  random: number;
+  configuration?: string;
+  effects?: Pick<BoardScriptOutput, "patches" | "items" | "hits" | "space" | "anchor">;
+};
+type BoardScriptParameter = {
+  type: "number" | "boolean" | "string" | "color";
+  label?: string;
+  default?: string | number | boolean;
+  min?: number;
+  max?: number;
+  step?: number;
+};
+type BoardScriptOutput = {
+  parameters?: Record<string, BoardScriptParameter>;
+  space?: "world" | "screen";
+  anchor?: BoardScriptAnchor;
+  patches: Record<string, Record<string, unknown>>;
+  items: Record<string, unknown>;
+  hits: Record<string, BoardScriptHit>;
+  listens: string[];
+  animated: boolean;
+  updating?: boolean;
+  version: number;
+};
+type BoardScriptContext = {
+  readonly self: {
+    readonly id: string;
+    readonly base: BoardItem;
+    present(patch: BoardScriptItemPatch | null): void;
+  };
+  readonly params: BoardScript["params"];
+  readonly targets: Readonly<Record<string, string>>;
+  emit(target: string, type: string, data?: unknown): Promise<void>;
+  readonly state: Record<string, unknown>;
+  readonly frame: BoardScriptFrame;
+  readonly view: BoardScriptView | null;
+  random(): number;
+  on<Type extends string>(type: Type, handler: (event: BoardScriptEventOf<Type>) => void): () => void;
+  onFrame(handler: (frame: BoardScriptFrame) => void): () => void;
+  onDispose(handler: () => void): void;
+  invalidate(): void;
+  get(id: string): BoardItem | undefined;
+  present(id: string, patch: BoardScriptItemPatch | null): void;
+  scene(items: Record<string, unknown>, options?: BoardScriptSceneOptions): void;
+  hitRegions(hits: Record<string, BoardScriptHit>): void;
+  commit(patch: BoardPatch): Promise<void>;
+  capabilities: {
+    has(name: string): boolean;
+    call(name: string, input?: unknown): Promise<unknown>;
+  };
+};
+type BoardScriptModule = {
+  parameters?: Record<string, BoardScriptParameter>;
+  default?: ((context: BoardScriptContext) => void) | ((context: BoardScriptContext) => () => void);
+  draw?: (context: CanvasRenderingContext2D, frame: BoardScriptFrame) => void;
+  animated?: boolean;
+};
+//#endregion
+export { BoardScriptAnchor, BoardScriptContext, BoardScriptEvent, BoardScriptEventOf, BoardScriptFrame, BoardScriptHit, BoardScriptHostEvents, BoardScriptItemPatch, BoardScriptModule, BoardScriptOutput, BoardScriptParameter, BoardScriptSceneOptions, BoardScriptSnapshot, BoardScriptView };

package/dist/board/model/script.js

@@ -0,0 +1 @@
+export {};

package/dist/board/render/board-background.js

@@ -12,7 +12,7 @@ function buildGridTexture(context, size, color, opacity, kind) {
 		width: 1,
 		alpha: opacity
 	});
-	else graphics.circle(.5, .5, .9).fill({
+	else graphics.circle(size / 2, size / 2, 1.1).fill({
 		color,
 		alpha: opacity
 	});
@@ -49,8 +49,9 @@ function sync(parts, context) {
 	const kind = settings.background.kind === "grid" ? "grid" : "dots";
 	const visible = settings.grid?.visible === true;
 	const size = Math.max(4, settings.grid?.size ?? 24);
-	const opacity = .12;
-	const key = `${kind}|${size}|${palette.border}|${opacity}`;
+	const color = kind === "grid" ? palette.border : palette.muted;
+	const opacity = kind === "grid" ? .9 : .4;
+	const key = `${kind}|${size}|${color}|${opacity}`;
 	if (!visible) {
 		if (parts.sprite) parts.sprite.visible = false;
 		return;
@@ -61,7 +62,7 @@ function sync(parts, context) {
 			parts.sprite.destroy();
 			previousTexture.destroy(true);
 		}
-		const texture = buildGridTexture(context, size, palette.border, opacity, kind);
+		const texture = buildGridTexture(context, size, color, opacity, kind);
 		parts.sprite = new TilingSprite({
 			texture,
 			width,

package/dist/board/render/css-color.d.ts

@@ -1,4 +1,9 @@
 //#region src/board/render/css-color.d.ts
+type BoardCssPaint = {
+  color: number;
+  alpha: number;
+};
+declare function parseBoardCssPaint(value: string): BoardCssPaint | null;
 declare function parseBoardCssColor(value: string): number | null;
 //#endregion
-export { parseBoardCssColor };
+export { BoardCssPaint, parseBoardCssColor, parseBoardCssPaint };

package/dist/board/render/css-color.js

@@ -1,36 +1,50 @@
 import { DOMAdapter } from "pixi.js";
 //#region src/board/render/css-color.ts
-const CACHE_LIMIT = 256;
 const cache = /* @__PURE__ */ new Map();
 let canvas = null;
-function parseBoardCssColor(value) {
+function parseBoardCssPaint(value) {
 	const key = value.trim();
 	if (!key) return null;
-	const cached = cache.get(key);
-	if (cached !== void 0 || cache.has(key)) return cached ?? null;
+	if (key.toLowerCase() === "transparent") return {
+		color: 0,
+		alpha: 0
+	};
+	const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(key)?.[1];
+	if (hex) {
+		const digits = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
+		return {
+			color: Number.parseInt(digits.slice(0, 6), 16),
+			alpha: digits.length === 8 ? Number.parseInt(digits.slice(6), 16) / 255 : 1
+		};
+	}
+	if (cache.has(key)) return cache.get(key) ?? null;
 	let result = null;
 	try {
-		const direct = /^#([0-9a-f]{6})$/i.exec(key);
-		if (direct?.[1]) result = Number.parseInt(direct[1], 16);
-		else {
-			canvas ??= DOMAdapter.get().createCanvas(1, 1);
-			const context = canvas.getContext("2d");
-			if (context) {
-				context.fillStyle = "#010203";
-				context.fillStyle = key;
-				const first = String(context.fillStyle);
-				context.fillStyle = "#040506";
-				context.fillStyle = key;
-				const match = first === String(context.fillStyle) ? /^#([0-9a-f]{6})$/i.exec(first) : null;
-				if (match?.[1]) result = Number.parseInt(match[1], 16);
-			}
+		canvas ??= DOMAdapter.get().createCanvas(1, 1);
+		const context = canvas.getContext("2d");
+		context.fillStyle = "#010203";
+		context.fillStyle = key;
+		const first = context.fillStyle;
+		context.fillStyle = "#040506";
+		context.fillStyle = key;
+		if (first === context.fillStyle) {
+			context.clearRect(0, 0, 1, 1);
+			context.fillRect(0, 0, 1, 1);
+			const [r = 0, g = 0, b = 0, a = 0] = context.getImageData(0, 0, 1, 1).data;
+			result = {
+				color: r << 16 | g << 8 | b,
+				alpha: a / 255
+			};
 		}
 	} catch {
 		result = null;
 	}
-	if (cache.size >= CACHE_LIMIT) cache.clear();
+	if (cache.size >= 256) cache.clear();
 	cache.set(key, result);
 	return result;
 }
+function parseBoardCssColor(value) {
+	return parseBoardCssPaint(value)?.color ?? null;
+}
 //#endregion
-export { parseBoardCssColor };
+export { parseBoardCssColor, parseBoardCssPaint };

package/dist/board/render/diagnostics.d.ts

@@ -0,0 +1,20 @@
+import { BoardTextItem } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardScene } from "../model/scene.js";
+//#region src/board/render/diagnostics.d.ts
+type BoardRenderDiagnostic = {
+  code: "text-clipped" | "text-overlap" | "glyph-unavailable" | "effect-follow-unused";
+  item: string;
+  related?: string;
+  characters?: string;
+};
+declare function measureBoardText(props: BoardTextItem["props"]): {
+  width: number;
+  height: number;
+  lines: string[];
+  lineHeight: number;
+  missingCharacters: string;
+};
+declare function inspectBoardScene(scene: BoardScene, limit?: number): BoardRenderDiagnostic[];
+//#endregion
+export { BoardRenderDiagnostic, inspectBoardScene, measureBoardText };