@adobe/data-gpu 0.10.8 → 0.10.11

package/src/graphics/animation/animation-track/interpolate.test.ts

@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { describe, it, expect } from "vitest";
+import { Quat } from "@adobe/data/math";
+import type { Schema } from "@adobe/data/schema";
+import { interpolate } from "./interpolate.js";
+
+describe("interpolate", () => {
+    it("resolves a schema's named interpolator via the registry (Quat linear ⇒ slerp)", () => {
+        const a: Quat = [0, 0, 0, 1];                                 // identity
+        const b: Quat = [0, Math.SQRT1_2, 0, Math.SQRT1_2];          // 90° about Y
+        // Must equal slerp exactly — proving it dispatched to the registered
+        // "slerp" function, not the componentwise-lerp fallback (which would
+        // produce a different, non-normalized result).
+        expect(interpolate(Quat.schema, "linear", a, b, 0.5)).toEqual(Quat.slerp(a, b, 0.5));
+    });
+
+    it("falls back to componentwise lerp when no interpolator is named", () => {
+        const schema: Schema = { type: "array", items: { type: "number" } };
+        expect(interpolate(schema, "linear", [0, 10], [10, 20], 0.5)).toEqual([5, 15]);
+    });
+
+    it("throws on a named interpolator that isn't registered", () => {
+        const schema: Schema = { type: "number", interpolators: { linear: "nope" } };
+        expect(() => interpolate(schema, "linear", 0, 1, 0.5)).toThrow(/unknown interpolator "nope"/);
+    });
+});

package/src/graphics/animation/animation-track/interpolate.ts

@@ -3,11 +3,13 @@
 import type { Schema } from "@adobe/data/schema";
 import type { InterpolationMode } from "../interpolation-mode/interpolation-mode.js";
 import { componentwiseLerp } from "./componentwise-lerp.js";
+import { interpolatorRegistry } from "./interpolator-registry.js";
 
 /**
  * Dispatches to a schema-declared interpolator if present, otherwise falls
  * back to a sensible default: `step` returns `next`, `linear` walks the schema
- * and lerps numeric leaves. `cubicSpline` requires a schema override.
+ * and lerps numeric leaves. `cubicSpline` requires a schema override. A schema
+ * names its interpolator (pure JSON); the name is resolved via the registry.
  */
 export function interpolate(
     schema: Schema,
@@ -16,8 +18,12 @@ export function interpolate(
     next: any,
     t: number,
 ): any {
-    const custom = schema.interpolators?.[mode];
-    if (custom) return custom(prev, next, t);
+    const name = schema.interpolators?.[mode];
+    if (name !== undefined) {
+        const custom = interpolatorRegistry[name];
+        if (!custom) throw new Error(`interpolate: unknown interpolator "${name}" for mode "${mode}"`);
+        return custom(prev, next, t);
+    }
     if (mode === "step") return prev;
     if (mode === "linear") return componentwiseLerp(schema, prev, next, t);
     throw new Error(`interpolate: schema type "${schema.type}" has no "${mode}" interpolator`);

package/src/graphics/animation/animation-track/interpolator-registry.ts

@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { Quat } from "@adobe/data/math";
+
+type Interpolator = (prev: any, next: any, t: number) => any;
+
+/**
+ * Resolves the serializable interpolator NAMES a pure-JSON `Schema` may declare
+ * (e.g. `Quat.schema`'s `interpolators.linear = "slerp"`) to their functions.
+ * The schema names the interpolator; the animation system owns the behavior.
+ */
+export const interpolatorRegistry: Readonly<Record<string, Interpolator>> = {
+    slerp: Quat.slerp,
+};