@neta-art/cohub 8.24.0 → 9.0.0

package/dist/protocol/dist/board-geometry.js

@@ -1,137 +0,0 @@
-//#region ../protocol/dist/board-geometry.js
-/**
-* Renderer-independent Board geometry contracts.
-*
-* Renderers build their own primitives from these results, but validation and
-* item factories use the same coordinate and bounds rules.
-*/
-/** Radius of a draw sample in world units given stroke size and pressure. */
-function boardDrawSampleRadius(size, pressure) {
-	const clamped = Math.min(1, Math.max(0, pressure));
-	return Math.max(.5, size / 2 * (.5 + clamped));
-}
-/** Convert persisted frame-local draw points to world-space authoring points. */
-function boardDrawPointsToWorld(points, x, y) {
-	return points.map((point) => ({
-		x: point.x + x,
-		y: point.y + y,
-		p: point.p
-	}));
-}
-/** Convert world-space authoring points to persisted frame-local points. */
-function boardDrawPointsToLocal(points, x, y) {
-	return points.map((point) => ({
-		x: point.x - x,
-		y: point.y - y,
-		p: point.p
-	}));
-}
-/** Exact local bounds required by the draw node contract. */
-function boardDrawBounds(points, size) {
-	if (points.length === 0) return {
-		x: 0,
-		y: 0,
-		width: 1,
-		height: 1
-	};
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of points) {
-		const radius = boardDrawSampleRadius(size, point.p);
-		minX = Math.min(minX, point.x - radius);
-		minY = Math.min(minY, point.y - radius);
-		maxX = Math.max(maxX, point.x + radius);
-		maxY = Math.max(maxY, point.y + radius);
-	}
-	return {
-		x: minX,
-		y: minY,
-		width: Math.max(1, maxX - minX),
-		height: Math.max(1, maxY - minY)
-	};
-}
-/** Resolve the world-space quadratic curve represented by a free arrow. */
-function boardResolveArrow(input) {
-	const start = input.start;
-	const end = input.end;
-	const mid = {
-		x: (start.x + end.x) / 2,
-		y: (start.y + end.y) / 2
-	};
-	if (!input.bend) return {
-		start,
-		end,
-		control: mid
-	};
-	const dx = end.x - start.x;
-	const dy = end.y - start.y;
-	const length = Math.hypot(dx, dy) || 1;
-	const offset = input.bend * length;
-	return {
-		start,
-		end,
-		control: {
-			x: mid.x + -dy / length * offset,
-			y: mid.y + dx / length * offset
-		}
-	};
-}
-/** Sample an already resolved arrow curve. */
-function boardSampleResolvedArrow(resolved, segments) {
-	const { start, control, end } = resolved;
-	const count = Math.max(1, Math.floor(segments));
-	const points = [];
-	for (let index = 0; index <= count; index += 1) {
-		const t = index / count;
-		const mt = 1 - t;
-		points.push({
-			x: mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x,
-			y: mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y
-		});
-	}
-	return points;
-}
-/** World bounds of the curve, padded for the stroke. */
-function boardArrowBounds(input) {
-	const { start, control, end } = boardResolveArrow(input);
-	const points = [start, end];
-	for (const axis of ["x", "y"]) {
-		const denominator = start[axis] - 2 * control[axis] + end[axis];
-		if (Math.abs(denominator) < 1e-12) continue;
-		const t = (start[axis] - control[axis]) / denominator;
-		if (t > 0 && t < 1) {
-			const mt = 1 - t;
-			points.push({
-				x: mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x,
-				y: mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y
-			});
-		}
-	}
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of points) {
-		minX = Math.min(minX, point.x);
-		minY = Math.min(minY, point.y);
-		maxX = Math.max(maxX, point.x);
-		maxY = Math.max(maxY, point.y);
-	}
-	const pad = Math.max(8, input.size * 2);
-	return {
-		x: minX - pad,
-		y: minY - pad,
-		width: Math.max(1, maxX - minX + pad * 2),
-		height: Math.max(1, maxY - minY + pad * 2)
-	};
-}
-function boardArrowFrame(input) {
-	return {
-		...boardArrowBounds(input),
-		rotation: 0
-	};
-}
-//#endregion
-export { boardArrowBounds, boardArrowFrame, boardDrawBounds, boardDrawPointsToLocal, boardDrawPointsToWorld, boardDrawSampleRadius, boardResolveArrow, boardSampleResolvedArrow };

package/dist/protocol/dist/board-node.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-//#region ../protocol/dist/board-node.d.ts
-declare const BOARD_COLOR_IDS: readonly ["brand", "neutral", "black", "white", "blue", "green", "amber", "violet", "rose"];
-type BoardColorId = (typeof BOARD_COLOR_IDS)[number];
-declare const BOARD_GEO_KINDS: readonly ["rectangle", "rounded", "ellipse", "diamond", "triangle"];
-type BoardGeoKind = (typeof BOARD_GEO_KINDS)[number];
-//#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BoardColorId, BoardGeoKind };

package/dist/protocol/dist/board-node.js

@@ -1,252 +0,0 @@
-import { BOARD_ARROW_STROKE_SIZE } from "./board-constants.js";
-import { BoardTaskSnapshotSchema } from "./board-document.js";
-import { boardArrowFrame, boardDrawBounds } from "./board-geometry.js";
-import { z } from "zod";
-//#region ../protocol/dist/board-node.js
-const BOARD_COLOR_IDS = [
-	"brand",
-	"neutral",
-	"black",
-	"white",
-	"blue",
-	"green",
-	"amber",
-	"violet",
-	"rose"
-];
-const BoardColorIdSchema = z.enum(BOARD_COLOR_IDS);
-const BOARD_GEO_KINDS = [
-	"rectangle",
-	"rounded",
-	"ellipse",
-	"diamond",
-	"triangle"
-];
-const BoardGeoKindSchema = z.enum(BOARD_GEO_KINDS);
-const BOARD_NATIVE_NODE_TYPES = [
-	"image",
-	"video",
-	"audio",
-	"file",
-	"task",
-	"text",
-	"geo",
-	"draw",
-	"arrow",
-	"frame"
-];
-const metadataSchema = z.record(z.string(), z.unknown());
-const commonData = {
-	locked: z.boolean().optional(),
-	metadata: metadataSchema.optional()
-};
-const pointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite(),
-	p: z.number().finite().min(0).max(1).default(.5)
-}).strict();
-const worldPointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
-}).strict();
-const strokeSizeSchema = z.number().finite().min(1).max(64);
-const mediaViewSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	naturalWidth: z.number().finite().positive().optional(),
-	naturalHeight: z.number().finite().positive().optional()
-}).strict();
-const audioViewSchema = mediaViewSchema.extend({ durationMs: z.number().finite().nonnegative().optional() });
-const dataSchemas = {
-	text: z.object({
-		...commonData,
-		text: z.string().default(""),
-		color: BoardColorIdSchema.default("neutral"),
-		fontSize: z.number().finite().min(2).max(512).default(24)
-	}).strict(),
-	geo: z.object({
-		...commonData,
-		geo: BoardGeoKindSchema.default("rectangle"),
-		text: z.string().default(""),
-		color: BoardColorIdSchema.default("brand"),
-		fillOpacity: z.number().finite().min(0).max(1).default(0)
-	}).strict(),
-	draw: z.object({
-		...commonData,
-		points: z.array(pointSchema).min(1),
-		color: BoardColorIdSchema.default("brand"),
-		size: strokeSizeSchema.default(4)
-	}).strict(),
-	arrow: z.object({
-		...commonData,
-		start: worldPointSchema,
-		end: worldPointSchema,
-		bend: z.number().finite().min(-.85).max(.85).default(0),
-		color: BoardColorIdSchema.default("brand"),
-		size: strokeSizeSchema.default(BOARD_ARROW_STROKE_SIZE),
-		arrowStart: z.boolean().default(false),
-		arrowEnd: z.boolean().default(true),
-		label: z.string().default("")
-	}).strict(),
-	frame: z.object({
-		...commonData,
-		label: z.string().default("Frame"),
-		color: BoardColorIdSchema.default("neutral")
-	}).strict(),
-	image: z.object({
-		...commonData,
-		crop: z.object({
-			x: z.number().finite().min(0).max(1),
-			y: z.number().finite().min(0).max(1),
-			w: z.number().finite().min(0).max(1),
-			h: z.number().finite().min(0).max(1)
-		}).strict().optional()
-	}).strict(),
-	video: z.object(commonData).strict(),
-	audio: z.object(commonData).strict(),
-	file: z.object(commonData).strict(),
-	task: z.object({
-		...commonData,
-		taskRunId: z.string().min(1)
-	}).strict()
-};
-const fileViewSchema = z.object({
-	title: z.string().optional(),
-	mimeType: z.string().optional(),
-	size: z.number().finite().nonnegative().optional(),
-	mtimeMs: z.number().finite().nonnegative().optional(),
-	excerpt: z.string().optional(),
-	coverPath: z.string().optional(),
-	coverUrl: z.string().url().optional()
-}).strict();
-const taskViewSchema = BoardTaskSnapshotSchema;
-const emptyViewSchema = z.object({}).strict();
-const viewSchemas = {
-	image: mediaViewSchema,
-	video: mediaViewSchema,
-	audio: audioViewSchema,
-	file: fileViewSchema,
-	task: taskViewSchema,
-	text: emptyViewSchema,
-	geo: emptyViewSchema,
-	draw: emptyViewSchema,
-	arrow: emptyViewSchema,
-	frame: emptyViewSchema
-};
-const nodeEnvelopeSchema = z.object({
-	nodeId: z.string().min(1).max(160),
-	type: z.string().min(1).max(40),
-	parentId: z.string().min(1).max(160).nullable(),
-	orderKey: z.string().max(4096).nullable(),
-	x: z.number().finite(),
-	y: z.number().finite(),
-	width: z.number().finite().positive(),
-	height: z.number().finite().positive(),
-	rotation: z.number().finite(),
-	refKind: z.string().max(40).nullable(),
-	refPath: z.string().max(4096).nullable(),
-	refUrl: z.string().max(4096).nullable(),
-	view: z.record(z.string(), z.unknown()),
-	style: z.record(z.string(), z.unknown()),
-	data: z.record(z.string(), z.unknown())
-}).strict();
-function jsonSchema(schema) {
-	return z.toJSONSchema(schema);
-}
-jsonSchema(nodeEnvelopeSchema), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]));
-function issueDiagnostic(issue, path) {
-	const fullPath = [path, ...issue.path].join(".");
-	const values = "values" in issue && Array.isArray(issue.values) ? issue.values.filter((value) => typeof value === "string") : void 0;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${fullPath}: ${issue.message}`,
-		path: fullPath,
-		...values?.length ? { allowedValues: values } : {}
-	};
-}
-function drawGeometryDiagnostic(node, data, path) {
-	const { x: minX, y: minY, width, height } = boardDrawBounds(data.points, data.size);
-	const tolerance = Math.max(.01, node.width * 1e-6, node.height * 1e-6);
-	if (Math.abs(minX) <= tolerance && Math.abs(minY) <= tolerance && Math.abs(width - node.width) <= tolerance && Math.abs(height - node.height) <= tolerance) return null;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_GEOMETRY",
-		message: `${path}.data.points must use frame-local coordinates and match the node frame`,
-		path: `${path}.data.points`,
-		expected: `frame-local bounds x=0, y=0, width=${width}, height=${height}`,
-		received: {
-			frame: {
-				x: node.x,
-				y: node.y,
-				width: node.width,
-				height: node.height
-			},
-			pointsBounds: {
-				x: minX,
-				y: minY,
-				width,
-				height
-			}
-		},
-		coordinateSpace: "frame-local"
-	};
-}
-function validateBoardNodeInput(node, path = "node") {
-	const envelopeResult = nodeEnvelopeSchema.safeParse(node);
-	if (!envelopeResult.success) return envelopeResult.error.issues.map((issue) => issueDiagnostic(issue, path));
-	if (typeof node.type !== "string" || !BOARD_NATIVE_NODE_TYPES.includes(node.type)) return [{
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${path}.type is not supported`,
-		path: `${path}.type`,
-		expected: "BoardNativeNodeType",
-		received: node.type,
-		allowedValues: BOARD_NATIVE_NODE_TYPES
-	}];
-	const type = node.type;
-	const dataResult = dataSchemas[type].safeParse(node.data ?? {});
-	if (!dataResult.success) return dataResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.data`));
-	const viewResult = viewSchemas[type].safeParse(node.view ?? {});
-	if (!viewResult.success) return viewResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.view`));
-	if (type === "image" || type === "video" || type === "audio" || type === "file") {
-		if (node.refKind !== "space_file" || typeof node.refPath !== "string" || !node.refPath) return [{
-			severity: "error",
-			code: "INVALID_BOARD_NODE",
-			message: `${path} requires a space file reference`,
-			path: `${path}.refPath`,
-			expected: "non-empty refPath with refKind space_file"
-		}];
-	}
-	if (type === "draw") {
-		const diagnostic = drawGeometryDiagnostic(node, dataResult.data, path);
-		return diagnostic ? [diagnostic] : [];
-	}
-	if (type === "arrow") {
-		const data = dataResult.data;
-		const expected = boardArrowFrame(data);
-		const tolerance = Math.max(.01, node.width * 1e-6, node.height * 1e-6);
-		if (Math.abs(node.x - expected.x) > tolerance || Math.abs(node.y - expected.y) > tolerance || Math.abs(node.width - expected.width) > tolerance || Math.abs(node.height - expected.height) > tolerance) return [{
-			severity: "error",
-			code: "INVALID_BOARD_GEOMETRY",
-			message: `${path}.data endpoints must use world-space coordinates and match the arrow frame`,
-			path: `${path}.data`,
-			expected: `world-space curve bounds x=${expected.x}, y=${expected.y}, width=${expected.width}, height=${expected.height}`,
-			received: {
-				frame: {
-					x: node.x,
-					y: node.y,
-					width: node.width,
-					height: node.height
-				},
-				curveBounds: expected
-			},
-			coordinateSpace: "world"
-		}];
-	}
-	return [];
-}
-//#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BoardColorIdSchema, BoardGeoKindSchema, validateBoardNodeInput };