sketchmark 2.0.0

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./types";
+export * from "./validate";
+export * from "./normalize";
+export * from "./kernel";
+export * from "./schema";
+export * from "./patch";
+export * from "./compounds";
+export * from "./project";
+export * from "./scenes";
+export * from "./sequences";
+export * from "./deck";
+export * from "./diagnostics";
+export * from "./render/svg";
+export * from "./render/html";
+export * from "./render/three-html";
+export * from "./render/three-preview-svg";
+export * from "./render/raw-three";
+export * from "./export";
+export * from "./player";

package/dist/src/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./normalize"), exports);
+__exportStar(require("./kernel"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./patch"), exports);
+__exportStar(require("./compounds"), exports);
+__exportStar(require("./project"), exports);
+__exportStar(require("./scenes"), exports);
+__exportStar(require("./sequences"), exports);
+__exportStar(require("./deck"), exports);
+__exportStar(require("./diagnostics"), exports);
+__exportStar(require("./render/svg"), exports);
+__exportStar(require("./render/html"), exports);
+__exportStar(require("./render/three-html"), exports);
+__exportStar(require("./render/three-preview-svg"), exports);
+__exportStar(require("./render/raw-three"), exports);
+__exportStar(require("./export"), exports);
+__exportStar(require("./player"), exports);

package/dist/src/kernel.d.ts

@@ -0,0 +1,8 @@
+import type { KernelVisualDocument, ResolvedVisualDocument, ValidationResult, VisualDocument } from "./types";
+import { type NormalizeOptions } from "./normalize";
+export interface LowerOptions extends NormalizeOptions {
+}
+export declare function lowerVisualDocument(document: VisualDocument, options?: LowerOptions): KernelVisualDocument;
+export declare function resolveKernelFrame(document: VisualDocument, time?: number): KernelVisualDocument;
+export declare function lowerResolvedVisualDocument(document: ResolvedVisualDocument): KernelVisualDocument;
+export declare function validateKernelVisualDocument(document: KernelVisualDocument): ValidationResult;

package/dist/src/kernel.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerVisualDocument = lowerVisualDocument;
+exports.resolveKernelFrame = resolveKernelFrame;
+exports.lowerResolvedVisualDocument = lowerResolvedVisualDocument;
+exports.validateKernelVisualDocument = validateKernelVisualDocument;
+const normalize_1 = require("./normalize");
+const utils_1 = require("./utils");
+const shapes_1 = require("./shapes");
+const KERNEL_2D_TYPES = new Set(["group", "path", "text", "image", "point"]);
+const KERNEL_3D_TYPES = new Set(["group3d", "mesh3d", "line3d", "text3d", "point3d", "light"]);
+function lowerVisualDocument(document, options = {}) {
+    return lowerResolvedVisualDocument((0, normalize_1.normalizeVisualDocument)(document, options));
+}
+function resolveKernelFrame(document, time = 0) {
+    return lowerResolvedVisualDocument((0, normalize_1.resolveVisualFrame)(document, time));
+}
+function lowerResolvedVisualDocument(document) {
+    return {
+        version: document.version,
+        canvas: (0, utils_1.clone)(document.canvas),
+        imports: cloneOptional(document.imports),
+        assets: cloneOptional(document.assets),
+        exports: cloneOptional(document.exports),
+        elements: lowerElements(document.elements ?? [])
+    };
+}
+function validateKernelVisualDocument(document) {
+    const issues = [];
+    const visit = (element, path) => {
+        if (!KERNEL_2D_TYPES.has(element.type) && !KERNEL_3D_TYPES.has(element.type)) {
+            issues.push({ path, code: "unsupported_kernel_type", message: `Kernel element type '${element.type}' is not supported.` });
+            return;
+        }
+        if (element.type === "path" && typeof element.d !== "string") {
+            issues.push({ path, code: "missing_kernel_path", message: "Kernel path requires string 'd'." });
+        }
+        if (element.type === "text" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y))) {
+            issues.push({ path, code: "missing_kernel_text_position", message: "Kernel text requires numeric x and y." });
+        }
+        if (element.type === "image" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y) || !isFiniteNumber(element.width) || !isFiniteNumber(element.height))) {
+            issues.push({ path, code: "missing_kernel_image_box", message: "Kernel image requires numeric x, y, width, and height." });
+        }
+        if (element.type === "point" && (!isFiniteNumber(element.x) || !isFiniteNumber(element.y))) {
+            issues.push({ path, code: "missing_kernel_point", message: "Kernel point requires numeric x and y." });
+        }
+        if (element.type === "mesh3d" && (!Array.isArray(element.vertices) || !Array.isArray(element.indices))) {
+            issues.push({ path, code: "missing_kernel_mesh", message: "Kernel mesh3d requires vertices and indices." });
+        }
+        if ((element.type === "group" || element.type === "group3d") && Array.isArray(element.children)) {
+            element.children.forEach((child, index) => visit(child, `${path}/children/${index}`));
+        }
+    };
+    (document.elements ?? []).forEach((element, index) => visit(element, `/elements/${index}`));
+    return { ok: issues.length === 0, issues, warnings: [] };
+}
+function lowerElements(elements) {
+    return elements.flatMap((element) => lowerElement(element));
+}
+function lowerElement(element) {
+    return (0, shapes_1.lowerAuthoringElement)(element, { lowerElements });
+}
+function cloneOptional(value) {
+    return value === undefined ? undefined : (0, utils_1.clone)(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}

package/dist/src/normalize.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedVisualDocument, VisualDocument } from "./types";
+export interface NormalizeOptions {
+    validate?: boolean;
+}
+export declare function normalizeVisualDocument(document: VisualDocument, options?: NormalizeOptions): ResolvedVisualDocument;
+export declare function resolveVisualFrame(document: VisualDocument, time?: number): ResolvedVisualDocument;

package/dist/src/normalize.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVisualDocument = normalizeVisualDocument;
+exports.resolveVisualFrame = resolveVisualFrame;
+const path_sampling_1 = require("./path-sampling");
+const shapes_1 = require("./shapes");
+const utils_1 = require("./utils");
+const validate_1 = require("./validate");
+function normalizeVisualDocument(document, options = {}) {
+    if (options.validate !== false) {
+        const result = (0, validate_1.validateVisualDocument)(document);
+        if (!result.ok) {
+            const first = result.issues[0];
+            throw new Error(first ? `${first.path}: ${first.message}` : "Invalid visual document.");
+        }
+    }
+    const cloned = (0, utils_1.clone)(document);
+    const elements = cloned.elements ?? [];
+    const resolvedElements = resolveEndpointReferences(elements);
+    return { ...cloned, elements: resolvedElements };
+}
+function resolveVisualFrame(document, time = 0) {
+    const normalized = normalizeVisualDocument(document);
+    const source = (0, utils_1.clone)(document.elements ?? normalized.elements);
+    const animated = source.map((element) => resolveElementAnimation(element, time));
+    const endpoints = resolveEndpointReferences(animated);
+    const followed = endpoints.map((element) => resolveElementFollowers(element, endpoints, time));
+    return { ...normalized, elements: followed };
+}
+function resolveEndpointReferences(elements) {
+    const map = new Map();
+    for (const element of (0, utils_1.flattenElements)(elements)) {
+        if (element.id)
+            map.set(element.id, element);
+    }
+    return elements.map((element) => resolveElementEndpoints(element, map));
+}
+function resolveElementEndpoints(element, map) {
+    const next = (0, utils_1.clone)(element);
+    if ((next.type === "line" || next.type === "arrow" || next.type === "curve") && next.from !== undefined && next.to !== undefined) {
+        next.from = resolveEndpoint(next.from, map);
+        next.to = resolveEndpoint(next.to, map);
+    }
+    if (next.type === "group" && Array.isArray(next.children)) {
+        next.children = next.children.map((child) => resolveElementEndpoints(child, map));
+    }
+    return next;
+}
+function resolveEndpoint(endpoint, map) {
+    if ((0, utils_1.isPoint2)(endpoint))
+        return [endpoint[0], endpoint[1]];
+    const { id, anchor } = (0, utils_1.parseReference)(String(endpoint));
+    const target = map.get(id);
+    const box = target ? (0, utils_1.elementBox)(target) : undefined;
+    if (!box)
+        return [0, 0];
+    return (0, utils_1.anchorPoint)(box, anchor);
+}
+function resolveElementAnimation(element, time) {
+    const next = (0, utils_1.clone)(element);
+    if (next.animate) {
+        for (const [property, animation] of Object.entries(next.animate)) {
+            const record = next;
+            record[property] = resolveAnimation(animation, time, record[property]);
+        }
+        delete next.animate;
+    }
+    if (next.type === "group" && Array.isArray(next.children)) {
+        next.children = next.children.map((child) => resolveElementAnimation(child, time));
+    }
+    return next;
+}
+function resolveElementFollowers(element, elements, time) {
+    const next = (0, utils_1.clone)(element);
+    if (next.type === "circle" && next.follow) {
+        const point = pointOnFollowPath(elements, next.follow, progressValue(next.progress, time));
+        if (point) {
+            next.cx = point[0];
+            next.cy = point[1];
+        }
+    }
+    if (next.type === "group" && Array.isArray(next.children)) {
+        next.children = next.children.map((child) => resolveElementFollowers(child, elements, time));
+    }
+    return next;
+}
+function progressValue(progress, time) {
+    if (typeof progress === "number")
+        return clamp(progress, 0, 1);
+    if (progress && typeof progress === "object")
+        return clamp(Number(resolveAnimation(progress, time, progress.from ?? 0)), 0, 1);
+    return 0;
+}
+function resolveAnimation(animation, time, fallback) {
+    if (Array.isArray(animation.keyframes) && animation.keyframes.length) {
+        const frames = animation.keyframes.slice().sort((left, right) => left[0] - right[0]);
+        if (time <= frames[0][0])
+            return frames[0][1];
+        for (let index = 1; index < frames.length; index += 1) {
+            const prev = frames[index - 1];
+            const next = frames[index];
+            if (time <= next[0]) {
+                const span = Math.max(0.000001, next[0] - prev[0]);
+                const t = (time - prev[0]) / span;
+                return interpolateValue(prev[1], next[1], t);
+            }
+        }
+        return frames[frames.length - 1][1];
+    }
+    const from = animation.from ?? fallback;
+    const to = animation.to ?? from;
+    const delay = animation.delay ?? 0;
+    const duration = Math.max(0.000001, animation.duration ?? 0);
+    const t = (0, utils_1.easing)(animation.ease, (time - delay) / duration);
+    return interpolateValue(from ?? 0, to ?? from ?? 0, t);
+}
+function pointOnFollowPath(elements, id, progress) {
+    const target = (0, utils_1.flattenElements)(elements).find((element) => element.id === id);
+    if (!target)
+        return undefined;
+    const definition = (0, shapes_1.getInternalShapeDefinition)(target.type);
+    if (!definition?.followable)
+        return undefined;
+    const lowered = lowerFollowTarget(target);
+    const path = firstKernelPath(lowered);
+    return path ? (0, path_sampling_1.pointOnPath)(path.d, progress) : undefined;
+}
+function lowerFollowTarget(target) {
+    const lowerElements = (items) => items.flatMap((item) => (0, shapes_1.lowerAuthoringElement)(item, { lowerElements }));
+    return lowerElements([target]);
+}
+function firstKernelPath(elements) {
+    for (const element of elements) {
+        if (element.type === "path")
+            return element;
+        if ((element.type === "group" || element.type === "group3d") && Array.isArray(element.children)) {
+            const nested = firstKernelPath(element.children);
+            if (nested)
+                return nested;
+        }
+    }
+    return undefined;
+}
+function interpolateValue(from, to, t) {
+    const eased = clamp(t, 0, 1);
+    if (typeof from === "number" && typeof to === "number")
+        return from + (to - from) * eased;
+    if (typeof from === "string" && typeof to === "string") {
+        const fromColor = parseHexColor(from);
+        const toColor = parseHexColor(to);
+        if (fromColor && toColor)
+            return formatHexColor({
+                r: Math.round(fromColor.r + (toColor.r - fromColor.r) * eased),
+                g: Math.round(fromColor.g + (toColor.g - fromColor.g) * eased),
+                b: Math.round(fromColor.b + (toColor.b - fromColor.b) * eased),
+                a: fromColor.a + (toColor.a - fromColor.a) * eased
+            });
+    }
+    return eased < 1 ? from : to;
+}
+function parseHexColor(value) {
+    const input = value.trim();
+    const short = /^#([0-9a-f]{3}|[0-9a-f]{4})$/i.exec(input);
+    if (short) {
+        const chars = short[1];
+        return {
+            r: parseInt(chars[0] + chars[0], 16),
+            g: parseInt(chars[1] + chars[1], 16),
+            b: parseInt(chars[2] + chars[2], 16),
+            a: chars.length === 4 ? parseInt(chars[3] + chars[3], 16) / 255 : 1
+        };
+    }
+    const long = /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.exec(input);
+    if (!long)
+        return undefined;
+    const hex = long[1];
+    return {
+        r: parseInt(hex.slice(0, 2), 16),
+        g: parseInt(hex.slice(2, 4), 16),
+        b: parseInt(hex.slice(4, 6), 16),
+        a: hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1
+    };
+}
+function formatHexColor(color) {
+    const hex = (value) => clamp(Math.round(value), 0, 255).toString(16).padStart(2, "0");
+    const alpha = clamp(Math.round(color.a * 255), 0, 255);
+    return alpha >= 255 ? `#${hex(color.r)}${hex(color.g)}${hex(color.b)}` : `#${hex(color.r)}${hex(color.g)}${hex(color.b)}${hex(alpha)}`;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/src/patch.d.ts

@@ -0,0 +1,5 @@
+import type { VisualDocument, VisualPatchOperation } from "./types";
+export interface PatchResult {
+    document: VisualDocument;
+}
+export declare function applyVisualPatch(document: VisualDocument, operations: VisualPatchOperation | VisualPatchOperation[]): PatchResult;

package/dist/src/patch.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVisualPatch = applyVisualPatch;
+const utils_1 = require("./utils");
+const validate_1 = require("./validate");
+function applyVisualPatch(document, operations) {
+    const ops = Array.isArray(operations) ? operations : [operations];
+    const next = (0, utils_1.clone)(document);
+    next.elements = next.elements ?? [];
+    for (const operation of ops) {
+        applyOperation(next, operation);
+    }
+    const result = (0, validate_1.validateVisualDocument)(next);
+    if (!result.ok) {
+        const first = result.issues[0];
+        throw new Error(first ? `${first.path}: ${first.message}` : "Patch produced an invalid document.");
+    }
+    return { document: next };
+}
+function applyOperation(document, operation) {
+    const elements = document.elements ?? [];
+    if (operation.op === "add") {
+        if (operation.element.id && findElement(elements, operation.element.id))
+            throw new Error(`Element '${operation.element.id}' already exists.`);
+        const index = clampIndex(operation.index ?? elements.length, elements.length);
+        elements.splice(index, 0, (0, utils_1.clone)(operation.element));
+        return;
+    }
+    const target = "id" in operation ? findElement(elements, operation.id) : undefined;
+    if (!target)
+        throw new Error(`Element '${"id" in operation ? operation.id : ""}' was not found.`);
+    if (operation.op === "update") {
+        Object.assign(target.element, (0, utils_1.clone)(operation.set));
+        return;
+    }
+    if (operation.op === "remove") {
+        target.parent.splice(target.index, 1);
+        return;
+    }
+    if (operation.op === "replace") {
+        target.parent[target.index] = (0, utils_1.clone)(operation.element);
+        return;
+    }
+    if (operation.op === "move") {
+        const record = target.element;
+        for (const key of ["x", "y", "cx", "cy"]) {
+            if (typeof operation[key] === "number")
+                record[key] = operation[key];
+        }
+        return;
+    }
+    if (operation.op === "reorder") {
+        const [item] = target.parent.splice(target.index, 1);
+        target.parent.splice(clampIndex(operation.index, target.parent.length), 0, item);
+    }
+}
+function findElement(elements, id) {
+    for (let index = 0; index < elements.length; index += 1) {
+        const element = elements[index];
+        if (element.id === id)
+            return { element, parent: elements, index };
+        if (element.type === "group" && Array.isArray(element.children)) {
+            const found = findElement(element.children, id);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function clampIndex(index, length) {
+    return Math.max(0, Math.min(length, Math.floor(index)));
+}

package/dist/src/path-sampling.d.ts

@@ -0,0 +1,3 @@
+import type { Point2 } from "./types";
+export declare function pointOnPath(d: string, progress: number): Point2 | undefined;
+export declare function samplePath(d: string): Point2[];