animl 0.0.0-stage → 0.1.0

package/modules/host-fit/web/size.d.ts

@@ -0,0 +1,4 @@
+import '../../../packages/web/src/index.js';
+import type { AnimaIcon } from '../../../packages/web/src/index.js';
+export declare const sizes: WeakMap<AnimaIcon, [number, number]>;
+export declare const refresh: (icon: AnimaIcon) => void;

package/modules/host-fit/web/size.js

@@ -0,0 +1,44 @@
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+const sizes = Icon.hostSizes ??= /* @__PURE__ */ new WeakMap();
+const refresh = (icon) => {
+  icon.attributeChangedCallback("fit", null, icon.getAttribute("fit"));
+  if (icon.player) icon.invalidate();
+};
+if (!Object.getOwnPropertyDescriptor(Icon.prototype, "size")) {
+  Object.defineProperty(Icon.prototype, "size", {
+    get() {
+      return [
+        ...(this.fit === "layout" ? this.player?.layoutSize : void 0) ?? sizes.get(this) ?? this.player?.model.viewBox.slice(2) ?? [0, 0]
+      ];
+    },
+    set(value) {
+      if (!Array.isArray(value) || value.length !== 2 || ![...value].every((v) => Number.isFinite(v) && v > 0)) {
+        this.dispatchEvent(
+          new CustomEvent("anima:error", {
+            detail: [
+              {
+                code: "host-size",
+                severity: "error",
+                pointer: "",
+                message: "invalid artboard size",
+                hint: "set size to [width, height] with finite positive grid units"
+              }
+            ]
+          })
+        );
+        return;
+      }
+      sizes.set(this, [...value]);
+      refresh(this);
+    }
+  });
+  Icon.prototype.resetSize = function() {
+    sizes.delete(this);
+    refresh(this);
+  };
+}
+export {
+  refresh,
+  sizes
+};

package/modules/host-values/core/index.d.ts

@@ -0,0 +1,30 @@
+import type { Module, ModuleRegistry } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { DataState } from '../../data/core/storage.js';
+import type { Property } from '../../data/core/types.js';
+import type { DataInstance, RecordInstance } from '../../host/core/api.js';
+export declare class HostValues {
+    models: WeakMap<object, string>;
+    created: Record<string, {
+        model: string;
+        values: Record<string, unknown>;
+    }>;
+    readonly player: Player;
+    scope: DataState;
+    shared: ModuleRegistry;
+    state: (p: Player) => DataState | undefined;
+    records: Map<string, RecordInstance>;
+    owned: WeakSet<DataInstance>;
+    constructor(player: Player, scope: DataState, shared: ModuleRegistry, state: (p: Player) => DataState | undefined, records: Map<string, RecordInstance>, owned: WeakSet<DataInstance>);
+    share(value: object, target: DataState, seen?: Set<object>): void;
+    index(values: Record<string, unknown>, model: string, raw?: Record<string, unknown>): void;
+    children(properties: Record<string, Property>, values: Record<string, unknown>, raw: Record<string, unknown>): void;
+    copy(input: unknown): unknown;
+    values(properties: Record<string, Property>, values: Record<string, unknown>, seen?: Map<object, Record<string, unknown>>, depth?: number): Record<string, unknown>;
+    validate(def: {
+        properties: Record<string, Property>;
+    }, values: Record<string, unknown>): Record<string, unknown>;
+}
+export declare const hostValues: Module & {
+    Values: typeof HostValues;
+};

package/modules/host-values/core/index.js

@@ -0,0 +1,169 @@
+import { clone as copy } from "../../data/core/types.js";
+import { DataError, fail } from "../../host/core/errors.js";
+class HostValues {
+  models;
+  created = {};
+  player;
+  scope;
+  shared;
+  state;
+  records;
+  owned;
+  constructor(player, scope, shared, state, records, owned) {
+    this.player = player;
+    this.scope = scope;
+    this.shared = shared;
+    this.state = state;
+    this.records = records;
+    this.owned = owned;
+    this.models = scope.modelTypes ??= /* @__PURE__ */ new WeakMap();
+  }
+  share(value, target, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(value)) return;
+    seen.add(value);
+    const model = this.models.get(value);
+    if (model) (target.modelTypes ??= /* @__PURE__ */ new WeakMap()).set(value, model);
+    for (const child of Object.values(value))
+      if (child && typeof child === "object") this.share(child, target, seen);
+  }
+  index(values, model, raw = {}) {
+    if (this.models.has(values)) return;
+    this.models.set(values, model);
+    this.children(this.scope.compiled.document.models[model].properties, values, raw);
+  }
+  children(properties, values, raw) {
+    for (const [key, p] of Object.entries(properties)) {
+      if (key === "$comment") continue;
+      const source = raw[key] ?? p.default;
+      const item = (v, input, fixed) => {
+        const r = input;
+        const named = typeof input === "string" ? input : r?.instance;
+        const instance = named ? this.scope.compiled.document.instances?.[named] ?? this.created[named] : void 0;
+        const type = fixed ?? instance?.model ?? r?.model;
+        if (v && typeof v === "object" && type)
+          this.index(
+            v,
+            type,
+            instance?.values ?? r?.values ?? input
+          );
+      };
+      if (p.type === "model-ref") item(values[key], source, p.model);
+      if (p.type === "list")
+        values[key].forEach(
+          (v, i) => item(v, source?.[i], p.of)
+        );
+    }
+  }
+  copy(input) {
+    const seen = /* @__PURE__ */ new Map();
+    const value = copy(input, seen);
+    for (const [source, cloned] of seen) {
+      const model = this.models.get(source);
+      if (model) this.models.set(cloned, model);
+    }
+    return value;
+  }
+  values(properties, values, seen = /* @__PURE__ */ new Map(), depth = 0) {
+    if (!values || typeof values !== "object" || Array.isArray(values))
+      fail("type", "", "instance values must be property maps");
+    if (depth >= 32) return values;
+    if (seen.has(values)) return seen.get(values);
+    const out = { ...values };
+    seen.set(values, out);
+    const item = (value, fixed) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+      if (this.owned.has(value)) return { instance: value.name };
+      const raw = value;
+      if (raw.instance) return value;
+      const known = this.models.get(value);
+      const model = known ?? raw.model ?? fixed;
+      const def = model && this.scope.compiled.document.models[model];
+      return def ? {
+        model,
+        values: this.values(
+          def.properties,
+          known ? value : raw.values ?? value,
+          seen,
+          depth + 1
+        )
+      } : value;
+    };
+    for (const [key, value] of Object.entries(values)) {
+      const p = properties[key];
+      out[key] = p?.type === "list" && Array.isArray(value) ? value.map((v) => item(v, p.of)) : p?.type === "model-ref" ? item(value, p.model) : value;
+    }
+    return out;
+  }
+  validate(def, values) {
+    values = this.values(def.properties, values);
+    const document = this.scope.compiled.document;
+    let instanceName = "hostValue";
+    while (this.records.has(instanceName)) instanceName += "X";
+    let name = "HostValue";
+    while (Object.hasOwn(document.models, name)) name += "X";
+    const result = this.shared.load({
+      anima: "0.1",
+      name: "host-value",
+      grid: 20,
+      nodes: [{ id: "host", type: "group", children: [] }],
+      requires: this.player.model.doc.requires,
+      // Validation needs the component vocabulary, not consumers whose inherited $scope
+      // belongs to a different model than this temporary value construction.
+      ...this.player.model.doc.components ? {
+        components: Object.fromEntries(
+          Object.keys(this.player.model.doc.components).filter((name2) => name2 !== "$comment").map((name2) => [
+            name2,
+            {
+              grid: 20,
+              data: { models: { HostShell: { properties: {} } } },
+              nodes: [{ id: "host", type: "group", children: [] }]
+            }
+          ])
+        )
+      } : {},
+      ...this.player.model.doc.converters ? { converters: this.player.model.doc.converters } : {},
+      ...this.player.model.doc.assets ? { assets: this.player.model.doc.assets } : {},
+      data: {
+        ...document,
+        model: name,
+        models: { ...document.models, [name]: def },
+        instances: {
+          ...Object.fromEntries(
+            Object.entries({ ...document.instances, ...this.created }).map(([k, v]) => [
+              k,
+              { ...v, default: false }
+            ])
+          ),
+          [instanceName]: { model: name, values, default: true }
+        }
+      }
+    });
+    const error = result.diagnostics.find((d) => d.severity === "error");
+    if (error) throw DataError.from(error);
+    const scope = this.state(new this.shared.Player(result.model));
+    const replacements = new Map(
+      Object.entries(scope.instances).filter(([k]) => this.records.has(k)).map(([k, v]) => [v, this.records.get(k).values])
+    );
+    const seen = new Map(replacements);
+    const clone = (v) => {
+      if (!v || typeof v !== "object") return v;
+      if (seen.has(v)) return seen.get(v);
+      const out = Array.isArray(v) ? [] : {};
+      seen.set(v, out);
+      for (const [k, x] of Object.entries(v)) out[k] = clone(x);
+      return out;
+    };
+    const built = clone(scope.instances[instanceName]);
+    this.children(def.properties, built, values);
+    return built;
+  }
+}
+const hostValues = {
+  name: "hostvalues",
+  entries: [],
+  Values: HostValues
+};
+export {
+  HostValues,
+  hostValues
+};

package/modules/host-values/web/index.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/host-values/web/index.js

@@ -0,0 +1,3 @@
+import "../../../packages/web/src/index.js";
+import { hostValues } from "../core/index.js";
+customElements.get("anima-icon").registerModule(hostValues);

package/modules/ik/core/index.d.ts

@@ -0,0 +1,2 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare const ik: Module;

package/modules/ik/core/index.js

@@ -0,0 +1,135 @@
+import { invert, localMatrix, mul } from "../../../packages/core/src/geom.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import { compose, decompose, registerConstraint } from "../../rig/core/api.js";
+import { after } from "../manifest.js";
+const inverse = (m) => {
+  const r = invert(m);
+  return r && r.every(Number.isFinite) ? r : null;
+};
+function chain(model, node, count) {
+  const out = [];
+  while (count-- > 0 && model.nodes[node]?.type === "bone") {
+    out.unshift(node);
+    if (model.nodes[node].raw.root) break;
+    node = model.nodes[node].parent;
+  }
+  return out;
+}
+const ik = {
+  name: "ik",
+  after,
+  entries: [],
+  init() {
+    registerConstraint({
+      kind: "ik",
+      shape: {
+        k: "obj",
+        p: {
+          target: { k: "str", feature: "ik" },
+          bones: { k: "num", min: 1, int: true },
+          bend: { k: "str", of: ["cw", "ccw"] }
+        },
+        req: ["target"]
+      },
+      targets: (r) => [r.target],
+      writes: (r, i, m) => chain(m, i, r.bones ?? 1).filter((j) => j !== i),
+      solve(ctx, node, raw, k) {
+        const ids = chain(ctx.model, node, raw.bones ?? 1), n = ids.length;
+        if (!n) return;
+        const frames = ids.map((i) => ctx.world(i)), points = ids.map((i) => ctx.position(i));
+        const backs = frames.map(inverse);
+        if (backs.some((b) => !b)) return;
+        const last = frames[n - 1], length = ids.map(
+          (i, j) => ctx.player.num(i, "length", 0) * Math.hypot(frames[j][0], frames[j][1])
+        );
+        points.push([
+          last[4] + last[0] * ctx.player.num(node, "length", 0),
+          last[5] + last[1] * ctx.player.num(node, "length", 0)
+        ]);
+        const start = [...points[0]], target = ctx.position(ctx.model.ids.get(raw.target));
+        const dx = target[0] - start[0], dy = target[1] - start[1], dist = Math.hypot(dx, dy);
+        if (!dist) return;
+        const total = length.reduce((a, b) => a + b, 0);
+        if (n === 1 || dist >= total) {
+          for (let j = 0; j < n; j++)
+            points[j + 1] = [
+              points[j][0] + dx / dist * length[j],
+              points[j][1] + dy / dist * length[j]
+            ];
+        } else {
+          const parent2 = ctx.model.nodes[ids[0]].parent, m = ctx.world(parent2), side = (raw.bend === "ccw" ? -1 : 1) * (m[0] * m[3] - m[1] * m[2] < 0 ? -1 : 1);
+          const pair = (j) => {
+            const a0 = points[j], c0 = points[j + 1], b0 = points[n], tx = target[0] - a0[0], ty = target[1] - a0[1], c = Math.hypot(tx, ty), rx = b0[0] - c0[0], ry = b0[1] - c0[1], a = Math.hypot(rx, ry), b = length[j];
+            if (!c || !a) return;
+            const far = c >= a + b, along = far ? b : (b * b - a * a + c * c) / (2 * c), height = far ? 0 : Math.sqrt(Math.max(0, b * b - along * along)), next = [
+              a0[0] + (tx * along - ty * height * side) / c,
+              a0[1] + (ty * along + tx * height * side) / c
+            ], end = far ? [a0[0] + tx / c * (a + b), a0[1] + ty / c * (a + b)] : target, angle = Math.atan2(end[1] - next[1], end[0] - next[0]) - Math.atan2(ry, rx), co = Math.cos(angle), si = Math.sin(angle);
+            for (let q = j + 2; q <= n; q++) {
+              const x = points[q][0] - c0[0], y = points[q][1] - c0[1];
+              points[q] = [next[0] + co * x - si * y, next[1] + si * x + co * y];
+            }
+            points[j + 1] = next;
+          };
+          for (let j = 0; j < n - 1; j++) pair(j);
+        }
+        const strength = ctx.num(node, k, "strength", 1);
+        const locals = ids.map((i, j) => {
+          if (j) return mul(backs[j - 1], frames[j]);
+          const p = ctx.model.nodes[i].parent, linked = ctx.model.nodes[p]?.type === "bone" && !ctx.model.nodes[i].raw.root, scale = ctx.player.num(i, "scale", 1);
+          return localMatrix(
+            linked ? ctx.player.num(p, "length", 0) : ctx.player.num(i, "x", 0),
+            linked ? 0 : ctx.player.num(i, "y", 0),
+            0,
+            0,
+            ctx.player.num(i, "rotate", 0),
+            scale * ctx.player.num(i, "scaleX", 1),
+            scale * ctx.player.num(i, "scaleY", 1)
+          );
+        }), rest = inverse(locals[0]);
+        if (!rest) return;
+        const base = mul(frames[0], rest), solved = [], parents = [];
+        for (let j = 0; j < n; j++) {
+          const parent2 = j ? solved[j - 1] : base, back = inverse(parent2);
+          if (!back) return;
+          parents[j] = back;
+          const dx2 = points[j + 1][0] - points[j][0], dy2 = points[j + 1][1] - points[j][1], parts = decompose(locals[j]);
+          parts[2] = Math.atan2(back[1] * dx2 + back[3] * dy2, back[0] * dx2 + back[2] * dy2);
+          solved[j] = mul(parent2, compose(parts));
+        }
+        let parent = base;
+        for (let j = 0; j < n; j++) {
+          parent = mul(parent, ctx.blend(locals[j], mul(parents[j], solved[j]), strength));
+          ctx.setWorld(ids[j], parent);
+        }
+      }
+    });
+    return ik;
+  },
+  load(model, _raw, d) {
+    if (!model.doc.requires?.includes("ik")) return;
+    for (const [i, n] of model.nodes.entries())
+      for (const [k, r] of (n.raw.constraints ?? []).entries()) {
+        if (r?.kind !== "ik") continue;
+        const at = nodePointer(model, i) + "/constraints/" + k;
+        if (n.type !== "bone")
+          d.err(
+            "rig-ik-host",
+            at,
+            V && "ik constraints must be hosted by a bone",
+            V && "move the ik constraint onto the chain tip bone"
+          );
+        else if (chain(model, i, r.bones ?? 1).length < (r.bones ?? 1))
+          d.err(
+            "rig-ik-chain",
+            at + "/bones",
+            V && "ik bones exceeds the available bone chain",
+            V && "reduce bones or add parent bones to the chain"
+          );
+      }
+  }
+};
+export {
+  ik
+};

package/modules/ik/core/svg.d.ts

@@ -0,0 +1,2 @@
+import type { SVGBackend } from '../../../packages/core/src/svg.js';
+export declare const ikSVG: SVGBackend;

package/modules/ik/core/svg.js

@@ -0,0 +1,4 @@
+const ikSVG = {};
+export {
+  ikSVG
+};

package/modules/ik/manifest.d.ts

@@ -0,0 +1,33 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+        heavy: boolean;
+        over: string;
+    }[];
+    adapters: {
+        'packages/core/src/modules/ik/index.ts': string;
+        'packages/core/src/modules/ik/svg.ts': string;
+        'packages/markup/src/ik.ts': string;
+        'packages/web/src/ik.ts': string;
+    };
+    exports: {
+        'core:./ik': string;
+        'markup:./ik': string;
+        'web:./ik': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/ik/manifest.js

@@ -0,0 +1,33 @@
+const after = ["rig"];
+var manifest_default = {
+  ...{
+    name: "ik",
+    summary: "Inverse kinematics: bend a bone chain so its tip reaches a target (one, two or more bones, bend side, strength).",
+    after: [],
+    core: { entry: "core/index.ts", export: "ik", svg: "core/svg.ts", svgExport: "ikSVG" },
+    web: [{ name: "ik", budget: 896, heavy: true, over: "rig" }],
+    adapters: {
+      "packages/core/src/modules/ik/index.ts": "core/index.ts",
+      "packages/core/src/modules/ik/svg.ts": "core/svg.ts",
+      "packages/markup/src/ik.ts": "markup/index.ts",
+      "packages/web/src/ik.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./ik": "packages/core/src/modules/ik/index.ts",
+      "markup:./ik": "packages/markup/src/ik.ts",
+      "web:./ik": "packages/web/src/ik.ts"
+    },
+    tests: [
+      "modules/ik/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts"
+    ],
+    conformance: ["rigging-ik", "rigging-ik-bend"],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/ik/markup/index.d.ts

@@ -0,0 +1 @@
+export {};

package/modules/ik/web/index.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/ik/web/index.js

@@ -0,0 +1,5 @@
+import { ik } from "../core/index.js";
+import { ikSVG } from "../core/svg.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(ik);
+customElements.get("anima-icon").registerSVGBackend("ik", ikSVG);

package/modules/input/core/commands.d.ts

@@ -0,0 +1,3 @@
+import type { Player } from '../../../packages/core/src/player.js';
+/** Returns false for commands owned by the base language; true commands need a subsequent step(0). */
+export declare function inputCommand(player: Player, command: string, args: string[]): boolean;

package/modules/input/core/commands.js

@@ -0,0 +1,55 @@
+const number = (text) => {
+  if (text === void 0 || text.trim() === "" || !Number.isFinite(Number(text)))
+    throw Error("expected a finite number");
+  return Number(text);
+};
+function inputCommand(player, command, args) {
+  if (!["contact", "key", "scroll", "gamepads", "pointer-enable", "scroll-cancel"].includes(command))
+    return false;
+  const c = player.input();
+  if (command === "contact") {
+    if (!["move", "down", "up", "leave", "cancel"].includes(args[0]) || ![2, 4, 5].includes(args.length))
+      throw Error("use contact <move|down|up|leave|cancel> <id> [x y [button]]");
+    const kind = args[0];
+    if (kind === "leave" || kind === "cancel" ? args.length !== 2 : args.length < 4)
+      throw Error("contact leave/cancel takes only an id; other phases need x y");
+    c.pointer(kind, args.length > 2 ? number(args[2]) : 0, args.length > 2 ? number(args[3]) : 0, {
+      id: number(args[1]),
+      button: args[4] === void 0 ? 0 : number(args[4])
+    });
+  } else if (command === "key") {
+    if (!["down", "up", "repeat"].includes(args[0]) || args.length < 2 || args.length > 4)
+      throw Error("use key <down|up|repeat> <key|Space> [shift+control+alt+meta|-] [target]");
+    const opts = { repeat: args[0] === "repeat", target: args[3] };
+    const mods = args[2] && args[2] !== "-" ? args[2].split("+") : [];
+    if (mods.some((m) => !["shift", "control", "alt", "meta"].includes(m)) || new Set(mods).size !== mods.length)
+      throw Error("unknown or duplicate key modifier");
+    for (const key of mods) opts[key] = true;
+    c.key(args[0] === "up" ? "up" : "down", args[1] === "Space" ? " " : args[1], opts);
+  } else if (command === "scroll") {
+    if (args.length < 4 || args.length > 6)
+      throw Error("use scroll <x> <y> <dx> <dy> [start|move|end|cancel] [seconds]");
+    const phase = args[4];
+    if (phase && !["start", "move", "end", "cancel"].includes(phase))
+      throw Error("unknown scroll phase");
+    c.scroll(number(args[0]), number(args[1]), number(args[2]), number(args[3]), {
+      phase,
+      time: args[5] === void 0 ? void 0 : number(args[5])
+    });
+  } else if (command === "gamepads") {
+    const batch = JSON.parse(args.join(" "));
+    if (!Array.isArray(batch)) throw Error("gamepads expects a JSON array");
+    c.gamepads(batch);
+  } else if (command === "pointer-enable") {
+    if (args.length !== 2 || !["true", "false"].includes(args[1]))
+      throw Error("use pointer-enable <id> <true|false>");
+    c.enablePointer(number(args[0]), args[1] === "true");
+  } else {
+    if (args.length) throw Error("scroll-cancel takes no arguments");
+    c.cancelScroll();
+  }
+  return true;
+}
+export {
+  inputCommand
+};

package/modules/input/core/index.d.ts

@@ -0,0 +1,7 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import { listenerValue } from './values.js';
+export * from './runtime.js';
+export * from './types.js';
+export declare const input: Module & {
+    listenerValue: typeof listenerValue;
+};