sketchmark 2.1.0 → 2.1.2

package/dist/src/export/index.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportVisual = exportVisual;
-const html_1 = require("../render/html");
-const svg_1 = require("../render/svg");
-function exportVisual(document, options = {}) {
-    const format = options.format ?? "svg";
-    if (format === "svg") {
-        return { format, content: (0, svg_1.renderToSvg)(document, options), mimeType: "image/svg+xml" };
-    }
-    if (format === "html") {
-        return { format, content: (0, html_1.renderToHtml)(document, options), mimeType: "text/html" };
-    }
-    throw new Error(`${format.toUpperCase()} export is reserved for the advanced renderer/export adapter. The primitive JSON core currently exports svg and html directly.`);
-}

package/dist/src/kernel.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,68 +0,0 @@
-"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/motion.d.ts

@@ -1,4 +0,0 @@
-import type { MotionDriver, MotionExpressionInput, MotionValue, VisualDocument, VisualElement } from "./types";
-export declare function applyMotionDrivers(document: VisualDocument, time: number): VisualDocument;
-export declare function evaluateDriver(driver: MotionDriver, elements: VisualElement[], time: number): MotionValue | undefined;
-export declare function evaluateExpression(input: MotionExpressionInput, elements: VisualElement[], time: number): MotionValue;

package/dist/src/motion.js

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMotionDrivers = applyMotionDrivers;
-exports.evaluateDriver = evaluateDriver;
-exports.evaluateExpression = evaluateExpression;
-const path_sampling_1 = require("./path-sampling");
-const shapes_1 = require("./shapes");
-const utils_1 = require("./utils");
-const utils_2 = require("./utils");
-function applyMotionDrivers(document, time) {
-    const next = (0, utils_1.clone)(document);
-    const drivers = next.motion?.drivers ?? [];
-    if (!drivers.length)
-        return next;
-    const elements = next.elements ?? [];
-    for (const driver of drivers) {
-        const value = evaluateDriver(driver, elements, time);
-        if (value !== undefined)
-            applyDriverValue(elements, driver.target, value);
-    }
-    return next;
-}
-function evaluateDriver(driver, elements, time) {
-    if (driver.expr !== undefined)
-        return evaluateExpression(driver.expr, elements, time);
-    if (Array.isArray(driver.keyframes))
-        return interpolateKeyframes(driver.keyframes, time, driver.ease);
-    return undefined;
-}
-function evaluateExpression(input, elements, time) {
-    if (typeof input === "number" || typeof input === "string" || isMotionPoint(input))
-        return (0, utils_1.clone)(input);
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        return 0;
-    switch (input.op) {
-        case "time":
-            return time;
-        case "prop":
-            return propertyValue(elements, input.target, input.property);
-        case "point": {
-            const [x, y] = input.args;
-            return [numberValue(evaluateExpression(x, elements, time)), numberValue(evaluateExpression(y, elements, time))];
-        }
-        case "add":
-            return input.args.reduce((total, item) => addValues(total, evaluateExpression(item, elements, time)), 0);
-        case "sub": {
-            const [first, ...rest] = input.args;
-            return rest.reduce((total, item) => subValues(total, evaluateExpression(item, elements, time)), evaluateExpression(first ?? 0, elements, time));
-        }
-        case "mul":
-            return input.args.reduce((total, item) => mulValues(total, evaluateExpression(item, elements, time)), 1);
-        case "div": {
-            const [first, ...rest] = input.args;
-            return rest.reduce((total, item) => divValues(total, evaluateExpression(item, elements, time)), evaluateExpression(first ?? 0, elements, time));
-        }
-        case "mod": {
-            const [left, right] = input.args;
-            const divisor = numberValue(evaluateExpression(right ?? 1, elements, time));
-            return divisor === 0 ? 0 : numberValue(evaluateExpression(left ?? 0, elements, time)) % divisor;
-        }
-        case "min":
-            return Math.min(...input.args.map((item) => numberValue(evaluateExpression(item, elements, time))));
-        case "max":
-            return Math.max(...input.args.map((item) => numberValue(evaluateExpression(item, elements, time))));
-        case "sin":
-            return Math.sin(numberValue(evaluateExpression(input.arg, elements, time)));
-        case "cos":
-            return Math.cos(numberValue(evaluateExpression(input.arg, elements, time)));
-        case "abs":
-            return absValue(evaluateExpression(input.arg, elements, time));
-        case "clamp":
-            return Math.max(numberValue(evaluateExpression(input.min, elements, time)), Math.min(numberValue(evaluateExpression(input.max, elements, time)), numberValue(evaluateExpression(input.value, elements, time))));
-        case "lerp":
-            return interpolateValue(evaluateExpression(input.from, elements, time), evaluateExpression(input.to, elements, time), numberValue(evaluateExpression(input.t, elements, time)));
-        case "bbox": {
-            const target = findElement(elements, input.target);
-            const box = target ? (0, utils_1.elementBox)(target) : undefined;
-            return box ? box[input.property] : 0;
-        }
-        case "anchor": {
-            const target = findElement(elements, input.target);
-            const box = target ? (0, utils_1.elementBox)(target) : undefined;
-            const point = box ? (0, utils_1.anchorPoint)(box, input.anchor) : [0, 0];
-            if (input.offset === undefined)
-                return point;
-            return point2Value(addValues(point, evaluateExpression(input.offset, elements, time)));
-        }
-        case "pointAt":
-            return pointOnTarget(elements, input.target, numberValue(evaluateExpression(input.progress, elements, time))) ?? [0, 0];
-        case "pathLength": {
-            const path = firstKernelPathForTarget(elements, input.target);
-            return path ? (0, path_sampling_1.pathLength)(path.d) : 0;
-        }
-        default:
-            return 0;
-    }
-}
-function interpolateKeyframes(keyframes, time, ease) {
-    const frames = keyframes
-        .filter((frame) => Array.isArray(frame) && (0, utils_1.isFiniteNumber)(frame[0]))
-        .slice()
-        .sort((left, right) => left[0] - right[0]);
-    if (!frames.length)
-        return undefined;
-    if (time <= frames[0][0])
-        return (0, utils_1.clone)(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]);
-            return interpolateValue(prev[1], next[1], (0, utils_2.easing)(ease, (time - prev[0]) / span));
-        }
-    }
-    return (0, utils_1.clone)(frames[frames.length - 1][1]);
-}
-function interpolateValue(from, to, t) {
-    const eased = Math.max(0, Math.min(1, t));
-    if (typeof from === "number" && typeof to === "number")
-        return from + (to - from) * eased;
-    if (isMotionPoint(from) && isMotionPoint(to))
-        return from.map((value, index) => value + (Number(to[index]) - value) * eased);
-    if (typeof from === "string" && typeof to === "string") {
-        const fromColor = parseHexColor(from);
-        const toColor = parseHexColor(to);
-        if (fromColor && toColor) {
-            return `#${hex(Math.round(fromColor[0] + (toColor[0] - fromColor[0]) * eased))}${hex(Math.round(fromColor[1] + (toColor[1] - fromColor[1]) * eased))}${hex(Math.round(fromColor[2] + (toColor[2] - fromColor[2]) * eased))}`;
-        }
-    }
-    return eased < 1 ? (0, utils_1.clone)(from) : (0, utils_1.clone)(to);
-}
-function applyDriverValue(elements, targetPath, value) {
-    const separator = targetPath.indexOf(".");
-    if (separator <= 0)
-        return;
-    const id = targetPath.slice(0, separator);
-    const property = targetPath.slice(separator + 1);
-    const target = findElement(elements, id);
-    if (!target)
-        return;
-    const record = target;
-    if (property === "position" && (0, utils_1.isPoint2)(value)) {
-        if ("cx" in record || target.type === "circle" || target.type === "ellipse" || target.type === "arc") {
-            record.cx = value[0];
-            record.cy = value[1];
-        }
-        else {
-            record.x = value[0];
-            record.y = value[1];
-        }
-        return;
-    }
-    record[property] = (0, utils_1.clone)(value);
-}
-function propertyValue(elements, id, property) {
-    const target = findElement(elements, id);
-    if (!target)
-        return 0;
-    const record = target;
-    if (property === "position") {
-        if ((0, utils_1.isFiniteNumber)(record.cx) && (0, utils_1.isFiniteNumber)(record.cy))
-            return [record.cx, record.cy];
-        if ((0, utils_1.isFiniteNumber)(record.x) && (0, utils_1.isFiniteNumber)(record.y))
-            return [record.x, record.y];
-    }
-    const value = record[property];
-    return typeof value === "number" || typeof value === "string" || isMotionPoint(value) ? (0, utils_1.clone)(value) : 0;
-}
-function pointOnTarget(elements, id, progress) {
-    const path = firstKernelPathForTarget(elements, id);
-    return path ? (0, path_sampling_1.pointOnPath)(path.d, progress) : undefined;
-}
-function firstKernelPathForTarget(elements, id) {
-    const target = findElement(elements, id);
-    if (!target)
-        return undefined;
-    const definition = (0, shapes_1.getInternalShapeDefinition)(target.type);
-    if (!definition?.pathQueryable)
-        return undefined;
-    const lowered = lowerFollowTarget(target);
-    return firstKernelPath(lowered);
-}
-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 findElement(elements, id) {
-    return (0, utils_1.flattenElements)(elements).find((element) => element.id === id);
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function addValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a + b);
-    return numberValue(left) + numberValue(right);
-}
-function subValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a - b);
-    return numberValue(left) - numberValue(right);
-}
-function mulValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a * b);
-    return numberValue(left) * numberValue(right);
-}
-function divValues(left, right) {
-    if (isMotionPoint(left) || isMotionPoint(right))
-        return combinePointValues(left, right, (a, b) => a / safeDenominator(b));
-    return numberValue(left) / safeDenominator(numberValue(right));
-}
-function absValue(value) {
-    if (isMotionPoint(value))
-        return value.map((item) => Math.abs(item));
-    return Math.abs(numberValue(value));
-}
-function combinePointValues(left, right, fn) {
-    const length = (isMotionPoint(left) && left.length === 3) || (isMotionPoint(right) && right.length === 3) ? 3 : 2;
-    const values = Array.from({ length }, (_, index) => fn(componentValue(left, index), componentValue(right, index)));
-    return values;
-}
-function componentValue(value, index) {
-    if (isMotionPoint(value))
-        return (0, utils_1.isFiniteNumber)(value[index]) ? value[index] : 0;
-    return numberValue(value);
-}
-function point2Value(value) {
-    if (isMotionPoint(value))
-        return [value[0], value[1]];
-    const scalar = numberValue(value);
-    return [scalar, scalar];
-}
-function safeDenominator(value) {
-    if (Math.abs(value) >= 0.000001)
-        return value;
-    return value < 0 ? -0.000001 : 0.000001;
-}
-function isMotionPoint(value) {
-    return Array.isArray(value) && (value.length === 2 || value.length === 3) && value.every((item) => typeof item === "number" && Number.isFinite(item));
-}
-function parseHexColor(value) {
-    const match = /^#([0-9a-f]{6})$/i.exec(value.trim());
-    if (!match)
-        return undefined;
-    return [parseInt(match[1].slice(0, 2), 16), parseInt(match[1].slice(2, 4), 16), parseInt(match[1].slice(4, 6), 16)];
-}
-function hex(value) {
-    return value.toString(16).padStart(2, "0");
-}

package/dist/src/patch.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,72 +0,0 @@
-"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/player/index.d.ts

@@ -1,68 +0,0 @@
-import type { VisualDocument } from "../types";
-import { documentForDeckStep } from "../deck";
-export { documentForDeckStep };
-export type { VisualDocument } from "../types";
-export type BrowserExportFormat = "svg" | "png" | "jpg" | "html" | "json" | "mp4";
-export type BrowserExportExtension = BrowserExportFormat | "webm";
-export interface BrowserExportOptions {
-    title?: string;
-    filename?: string;
-    time?: number;
-    document?: VisualDocument;
-    sourceDocument?: VisualDocument;
-}
-export interface BrowserExportResult {
-    blob: Blob;
-    filename: string;
-    mimeType: string;
-    extension: BrowserExportExtension;
-    fallback?: "webm";
-}
-export interface VisualPlayerOptions {
-    document: VisualDocument;
-    autoplay?: boolean;
-    loop?: boolean;
-    onFrame?: (state: VisualPlayerState) => void;
-    onError?: (error: Error) => void;
-}
-export interface VisualPlayerState {
-    time: number;
-    duration: number;
-    playing: boolean;
-}
-export declare class VisualPlayer {
-    readonly ready: Promise<VisualPlayer>;
-    private root;
-    private document;
-    private loop;
-    private onFrame?;
-    private onError?;
-    private raf;
-    private startedAt;
-    private startedTime;
-    private currentTime;
-    private playing;
-    constructor(root: HTMLElement, options: VisualPlayerOptions);
-    play(): void;
-    pause(): void;
-    seek(time: number): void;
-    render(time?: number): void;
-    setDocument(document: VisualDocument): void;
-    getDocument(): VisualDocument;
-    getState(): VisualPlayerState;
-    toSvg(time?: number): string;
-    downloadSvg(filename?: string, time?: number): void;
-    exportBrowser(format: BrowserExportFormat, options?: BrowserExportOptions): Promise<BrowserExportResult>;
-    download(format: BrowserExportFormat, options?: BrowserExportOptions): Promise<BrowserExportResult>;
-    destroy(): void;
-    private tick;
-    private duration;
-    private emit;
-    private handleError;
-}
-export declare function createVisualPlayer(root: HTMLElement, options: VisualPlayerOptions): VisualPlayer;
-export declare class SketchmarkPlayer extends VisualPlayer {
-}
-export declare function createSketchmarkPlayer(root: HTMLElement, options: VisualPlayerOptions): SketchmarkPlayer;
-export declare function exportVisualFromBrowser(player: VisualPlayer, format: BrowserExportFormat, options?: BrowserExportOptions): Promise<BrowserExportResult>;
-export declare function downloadBrowserExport(result: BrowserExportResult): void;