@fungi.computer/sprite-zdog 0.0.0-stage → 0.0.1

package/dist/document.js

@@ -0,0 +1,204 @@
+import * as z from "zod";
+import { colorKeyFromValue } from "./palette.js";
+const transform = z.strictObject({
+    x: z.number().optional(),
+    y: z.number().optional(),
+    z: z.number().optional(),
+});
+const point = z.strictObject({
+    x: z.number(),
+    y: z.number(),
+    z: z.number().optional(),
+});
+const options = z.strictObject({
+    name: z.string().min(1).optional(),
+    x: z.number().optional(),
+    y: z.number().optional(),
+    z: z.number().optional(),
+    translate: transform.optional(),
+    rotate: transform.optional(),
+    scale: transform.optional(),
+    visible: z.boolean().optional(),
+    color: z.string().optional(),
+    stroke: z.union([z.number().nonnegative(), z.literal(false)]).optional(),
+    fill: z.boolean().optional(),
+    backface: z.string().optional(),
+    frontFace: z.string().optional(),
+    updateSort: z.boolean().optional(),
+});
+const identity = {
+    id: z.string().min(1),
+    parent: z.string().min(1).optional(),
+};
+export const zdogNodeSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ ...identity, kind: z.literal("group"), options }),
+    z.strictObject({
+        ...identity,
+        kind: z.literal("shape"),
+        options: options.extend({
+            path: z
+                .array(z.union([
+                point,
+                z.strictObject({ bezier: z.tuple([point, point, point]) }),
+            ]))
+                .optional(),
+            closed: z.boolean().optional(),
+        }),
+    }),
+    z.strictObject({
+        ...identity,
+        kind: z.literal("ellipse"),
+        options: options.extend({ width: z.number(), height: z.number() }),
+    }),
+    z.strictObject({
+        ...identity,
+        kind: z.literal("hemisphere"),
+        options: options.extend({ diameter: z.number() }),
+    }),
+    z.strictObject({
+        ...identity,
+        kind: z.literal("cylinder"),
+        options: options.extend({ diameter: z.number(), length: z.number() }),
+    }),
+]);
+const motion = z.strictObject({
+    target: z.string().min(1),
+    translate: transform.optional(),
+    rotate: transform.optional(),
+    durationMs: z.number().nonnegative().optional(),
+    repeat: z.enum(["none", "loop", "yoyo"]).optional(),
+});
+const expression = z.strictObject({
+    variants: z.record(z.string(), z.string()).optional(),
+    variantChoices: z.record(z.string(), z.array(z.string()).min(1)).optional(),
+    blush: z.number().optional(),
+    motion: motion.optional(),
+});
+const activity = z.strictObject({
+    motion: motion.optional(),
+    mouseInfluence: z.number().optional(),
+    geometry: z
+        .strictObject({
+        expression: z.string().optional(),
+        eyes: z.string().optional(),
+        mouth: z.string().optional(),
+        blush: z.number().optional(),
+    })
+        .optional(),
+    mouthCycle: z
+        .array(z.strictObject({
+        durationMs: z.number().positive(),
+        mouth: z.enum(["base", "open"]),
+    }))
+        .min(1)
+        .optional(),
+});
+/** Zdog's portable native data, not a new cross-renderer animation language. */
+export const zdogDocumentSchema = z
+    .strictObject({
+    root: z.string().min(1),
+    nodes: z.array(zdogNodeSchema).min(1),
+    palette: z.record(z.string(), z.string()),
+    variants: z.record(z.string(), z.record(z.string(), z.string())),
+    expressions: z.record(z.string(), expression),
+    activities: z.record(z.string(), activity),
+    defaultPresentation: z.strictObject({
+        activity: z.string(),
+        expression: z.string(),
+    }),
+})
+    .superRefine((document, context) => {
+    const visited = new Set();
+    const names = new Set();
+    const issue = (message) => {
+        context.addIssue({ code: "custom", message });
+    };
+    for (const node of document.nodes) {
+        if (visited.has(node.id) ||
+            (node.parent !== undefined && !visited.has(node.parent)) ||
+            (node.parent === undefined && node.id !== document.root)) {
+            issue("Scene needs unique, parent-first nodes and one root");
+        }
+        visited.add(node.id);
+        if (node.options.name) {
+            if (names.has(node.options.name))
+                issue(`Duplicate Sprite node name: ${node.options.name}`);
+            names.add(node.options.name);
+        }
+        for (const value of [
+            node.options.color,
+            node.options.backface,
+            node.options.frontFace,
+        ]) {
+            const key = colorKeyFromValue(value);
+            if (key !== undefined && !Object.hasOwn(document.palette, key))
+                issue(`Unknown Sprite palette slot: ${key}`);
+        }
+    }
+    if (!visited.has(document.root))
+        issue("Scene root is missing");
+    for (const variants of Object.values(document.variants)) {
+        for (const id of Object.values(variants)) {
+            if (!visited.has(id))
+                issue("Variant node is missing");
+        }
+    }
+    if (!Object.hasOwn(document.expressions, document.defaultPresentation.expression))
+        issue(`Unknown Sprite default expression: ${document.defaultPresentation.expression}`);
+    const standard = [
+        "idle",
+        "listening",
+        "processing",
+        "speaking",
+        "thinking",
+        "error",
+    ];
+    if (!standard.includes(document.defaultPresentation.activity) &&
+        !Object.hasOwn(document.activities, document.defaultPresentation.activity))
+        issue(`Unknown Sprite default activity: ${document.defaultPresentation.activity}`);
+    const variant = (channel, value) => {
+        if (!Object.hasOwn(document.variants, channel) ||
+            !Object.hasOwn(document.variants[channel] ?? {}, value))
+            issue(`Unknown Sprite variant: ${channel}.${value}`);
+    };
+    const motionTarget = (target) => {
+        if (!names.has(target))
+            issue(`Unknown Sprite motion target: ${target}`);
+    };
+    const blush = (value) => value === 0
+        ? "off"
+        : value <= 0.5
+            ? "small"
+            : value <= 0.8
+                ? "medium"
+                : "big";
+    for (const [name, expression] of Object.entries(document.expressions)) {
+        for (const [channel, value] of Object.entries(expression.variants ?? {}))
+            variant(channel, value);
+        for (const [channel, choices] of Object.entries(expression.variantChoices ?? {}))
+            for (const value of choices)
+                variant(channel, value);
+        if (expression.blush !== undefined)
+            variant("blush", blush(expression.blush));
+        if (expression.motion)
+            motionTarget(expression.motion.target);
+        if (!name.trim())
+            issue("Sprite expression name cannot be empty");
+    }
+    for (const [name, activity] of Object.entries(document.activities)) {
+        if (activity.motion)
+            motionTarget(activity.motion.target);
+        const geometry = activity.geometry;
+        if (geometry?.expression &&
+            !Object.hasOwn(document.expressions, geometry.expression))
+            issue(`Unknown Sprite activity.${name}.geometry.expression: ${geometry.expression}`);
+        if (geometry?.eyes)
+            variant("eyes", geometry.eyes);
+        if (geometry?.mouth)
+            variant("mouth", geometry.mouth);
+        if (geometry?.blush !== undefined)
+            variant("blush", blush(geometry.blush));
+        if (!name.trim())
+            issue("Sprite activity name cannot be empty");
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { default } from "./renderer.js";
+/** Lazy loaders for the bundled local characters; no remote asset access. */
+export declare const builtinCharacters: Readonly<{
+    /** Load the bundled mushroom document and renderer. */
+    mushroom: () => Promise<import("@fungi.computer/sprite").LocalCharacter>;
+    /** Load the bundled cat document and renderer. */
+    cat: () => Promise<import("@fungi.computer/sprite").LocalCharacter>;
+    /** Load the bundled burger document and renderer. */
+    burger: () => Promise<import("@fungi.computer/sprite").LocalCharacter>;
+}>;

package/dist/index.js

@@ -0,0 +1,10 @@
+export { default } from "./renderer.js";
+/** Lazy loaders for the bundled local characters; no remote asset access. */
+export const builtinCharacters = Object.freeze({
+    /** Load the bundled mushroom document and renderer. */
+    mushroom: () => import("./mushroom.js").then(({ default: character }) => character),
+    /** Load the bundled cat document and renderer. */
+    cat: () => import("./cat.js").then(({ default: character }) => character),
+    /** Load the bundled burger document and renderer. */
+    burger: () => import("./burger.js").then(({ default: character }) => character),
+});

package/dist/internal.d.ts

@@ -0,0 +1,41 @@
+import type { ActivitySpec, ExpressionSpec, PathStep, SceneNode, SceneNodeOptions, SpriteDefinition } from "./author.js";
+export { COLOR_PREFIX } from "./palette.js";
+export type InternalNodeKind = "group" | "shape" | "ellipse" | "hemisphere" | "cylinder";
+export type InternalTransform = {
+    readonly x?: number | undefined;
+    readonly y?: number | undefined;
+    readonly z?: number | undefined;
+};
+export type InternalSceneOptions = Omit<SceneNodeOptions, "translate"> & {
+    readonly translate?: InternalTransform | undefined;
+    readonly path?: readonly PathStep[] | undefined;
+    readonly closed?: boolean | undefined;
+    readonly width?: number | undefined;
+    readonly height?: number | undefined;
+    readonly diameter?: number | undefined;
+    readonly length?: number | undefined;
+};
+export type InternalSceneNode = {
+    readonly owner: symbol;
+    readonly kind: InternalNodeKind;
+    readonly name: string | undefined;
+    readonly parent: InternalSceneNode | undefined;
+    readonly children: InternalSceneNode[];
+    readonly options: InternalSceneOptions;
+};
+export type InternalDefinition = {
+    readonly owner: symbol;
+    readonly root: InternalSceneNode;
+    readonly nodesByName: ReadonlyMap<string, InternalSceneNode>;
+    readonly variants: ReadonlyMap<string, ReadonlyMap<string, InternalSceneNode>>;
+    readonly variantNodes: ReadonlySet<InternalSceneNode>;
+    readonly palette: Record<string, string>;
+    readonly activities: Record<string, ActivitySpec>;
+    readonly expressions: Record<string, ExpressionSpec>;
+    readonly defaultActivity: string;
+    readonly defaultExpression: string;
+};
+export declare const registerInternalNode: (publicNode: SceneNode, internalNode: InternalSceneNode) => void;
+export declare const setDefinitionInternals: (definition: SpriteDefinition, internals: InternalDefinition) => void;
+export declare const getDefinitionInternals: (definition: SpriteDefinition) => InternalDefinition;
+export declare const asInternalNode: (node: SceneNode) => InternalSceneNode;

package/dist/internal.js

@@ -0,0 +1,21 @@
+export { COLOR_PREFIX } from "./palette.js";
+const definitions = new WeakMap();
+const publicNodes = new WeakMap();
+export const registerInternalNode = (publicNode, internalNode) => {
+    publicNodes.set(publicNode, internalNode);
+};
+export const setDefinitionInternals = (definition, internals) => {
+    definitions.set(definition, internals);
+};
+export const getDefinitionInternals = (definition) => {
+    const internals = definitions.get(definition);
+    if (!internals)
+        throw new Error("Invalid Sprite definition");
+    return internals;
+};
+export const asInternalNode = (node) => {
+    const internal = publicNodes.get(node);
+    if (internal === undefined)
+        throw new Error("Invalid Sprite scene node");
+    return internal;
+};