animl 0.0.0-stage → 0.1.0

package/modules/data-host/manifest.d.ts

@@ -0,0 +1,28 @@
+export declare const after: string[];
+declare const _default: {
+    name: string;
+    summary: string;
+    after: string[];
+    core: {
+        entry: string;
+        export: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/data-host/index.ts': string;
+        'packages/web/src/data-host.ts': string;
+        'packages/web/src/datahost.ts': string;
+    };
+    exports: {
+        'core:./data-host': string;
+        'web:./data-host': string;
+        'web:./datahost': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/data-host/manifest.js

@@ -0,0 +1,29 @@
+const after = ["host", "data", "assets", "input"];
+var manifest_default = {
+  name: "data-host",
+  summary: "Data: read and write page-provided data (nested models, lists, fonts, images) from the host.",
+  after,
+  core: { entry: "core/index.ts", export: "dataHost" },
+  web: [{ name: "data-host", budget: 1088 }],
+  adapters: {
+    "packages/core/src/modules/data-host/index.ts": "core/index.ts",
+    "packages/web/src/data-host.ts": "web/index.ts",
+    "packages/web/src/datahost.ts": "web/index.ts"
+  },
+  exports: {
+    "core:./data-host": "packages/core/src/modules/data-host/index.ts",
+    "web:./data-host": "packages/web/src/data-host.ts",
+    "web:./datahost": "packages/web/src/datahost.ts"
+  },
+  tests: [
+    "modules/data-host/test/**/*.test.ts",
+    "packages/markup/test/corpus.test.ts",
+    "packages/markup/test/names.test.ts"
+  ],
+  conformance: ["data-host", "transforms-computed-transform-values"],
+  docs: ["modules/data-host/SPEC.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

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

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

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

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

package/modules/derive/core/index.js

@@ -0,0 +1,369 @@
+import { ptr } from "../../../packages/core/src/diag.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { accepts, normalize, inputFor } from "../../data/core/storage.js";
+import { after } from "../manifest.js";
+const derive = {
+  name: "derive",
+  after,
+  entries: [],
+  init(registry, shared) {
+    const data = registry.get("data");
+    const bind = registry.get("bind");
+    if (!data || !bind) return derive;
+    const shape = shared.DOC.p.data;
+    const models = shape.p.models;
+    const properties = models.of.p.properties;
+    const property = properties.of;
+    return {
+      ...derive,
+      init: void 0,
+      entries: [
+        {
+          target: "document",
+          shapes: {
+            data: {
+              ...shape,
+              p: {
+                ...shape.p,
+                models: {
+                  ...models,
+                  of: {
+                    ...models.of,
+                    p: {
+                      ...models.of.p,
+                      properties: {
+                        ...properties,
+                        of: {
+                          ...property,
+                          p: {
+                            ...property.p,
+                            value: { k: "str", feature: "derive" },
+                            convert: { k: "str", feature: "convert" }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      ],
+      prepare(model, d) {
+        prepare(model, d, data, bind);
+      }
+    };
+  }
+};
+function prepare(model, d, data, bind) {
+  if (!model.doc.requires?.includes("derive")) return;
+  const c = data.compiled.get(model);
+  if (!c) return;
+  for (const [path, ref] of [...c.refs]) {
+    if (ref.property.type !== "string") continue;
+    const property = { type: "number" };
+    const input = inputFor(property, String(ref.input.def).length, path + ".length", true);
+    c.refs.set(path + ".length", {
+      ...ref,
+      keys: [...ref.keys, "length"],
+      property,
+      input,
+      readonly: true
+    });
+    model.inputs.set(path + ".length", input);
+  }
+  const defs = c.document.models;
+  const plans = /* @__PURE__ */ new Map();
+  const points = /* @__PURE__ */ new Map();
+  const error = (code, at, message) => d.err(
+    code,
+    at,
+    V && message,
+    V && (code === "read-only-path" ? "write the source properties instead of the computed property" : "use acyclic scalar expressions with matching types and declared converters")
+  );
+  const types = new Map([...model.inputs].map(([n, i]) => [n, i.type]));
+  const relative = (name, prefix = "$", stack = []) => {
+    if (stack.includes(name)) return;
+    for (const [key, p] of Object.entries(defs[name]?.properties ?? {})) {
+      if (p.type === "model-ref") relative(p.model, prefix + key + ".", [...stack, name]);
+      else if (!["list", "trigger"].includes(p.type))
+        types.set(prefix + key, p.type === "enum" ? "string" : p.type);
+      if (p.type === "string") types.set(prefix + key + ".length", "number");
+    }
+  };
+  for (const [name, def] of Object.entries(defs)) {
+    for (const key of types.keys())
+      if (key.startsWith("$") && !key.includes(":")) types.delete(key);
+    relative(name);
+    for (const ref of c.refs.values()) {
+      let object = c.defaults[ref.instance];
+      for (let i = 0; i < ref.keys.length; i++) {
+        if (object && typeof object === "object" && c.modelOf.get(object) === name)
+          types.set("$" + ref.keys.slice(i).join("."), ref.input.type);
+        object = object && object[ref.keys[i]];
+      }
+    }
+    for (const [key, p] of Object.entries(def.properties)) {
+      const at = ptr(ptr("/data/models", name) + "/properties", key);
+      if (p.value === void 0) {
+        if (p.convert)
+          error("derive-type", at + "/convert", "convert requires a computed value expression");
+        continue;
+      }
+      points.set(p, at);
+      if (!["number", "string", "bool", "color", "enum"].includes(p.type)) {
+        error("derive-type", at + "/value", "only scalar properties can be computed");
+        continue;
+      }
+      if (!model.doc.requires.includes("bind"))
+        error("undeclared-feature", at + "/value", "computed expressions require bind");
+      if (p.convert && (!model.doc.requires.includes("convert") || !Object.hasOwn(model.doc.converters ?? {}, p.convert)))
+        error("derive-converter", at + "/convert", "declare convert and a named converter");
+      try {
+        const e = bind.parse(p.value, types);
+        const expected = p.type === "enum" ? "string" : p.type;
+        if (!p.convert && e.type !== expected && !(expected === "number" && e.type === "bool"))
+          error("derive-type", at + "/value", `expected ${expected}, got ${e.type}`);
+        plans.set(p, e);
+      } catch (e) {
+        const err = e;
+        d.err(
+          err.code ?? "bind-syntax",
+          at + "/value",
+          V && err.message,
+          V && `check token ${JSON.stringify(p.value.slice(err.at ?? 0).match(/^\S+/)?.[0] ?? "end of expression")}; use typed values, arithmetic, comparisons, and/or/not or registered calls`
+        );
+      }
+    }
+  }
+  if (!plans.size) return;
+  const propertyAt = (name, path) => {
+    const m = /^\$(?:([\w-]+):)?(.+)$/.exec(path);
+    if (!m) return;
+    if (m[1]) name = c.document.instances?.[m[1]]?.model ?? "";
+    const keys = m[2].split(".");
+    let p;
+    for (let i = 0; i < keys.length; i++) {
+      p = defs[name]?.properties[keys[i]];
+      if (p?.type === "string" && keys[i + 1] === "length") return p;
+      if (p?.type === "model-ref") name = p.model;
+      else if (p?.type === "list") {
+        name = p.of;
+        i++;
+      }
+    }
+    return p;
+  };
+  const visiting = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+  const owner = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(defs))
+    for (const p of Object.values(def.properties)) owner.set(p, name);
+  const cycle = (p) => {
+    if (visiting.has(p)) {
+      error("derive-cycle", points.get(p) + "/value", "cyclic computed property dependency");
+      return;
+    }
+    if (done.has(p)) return;
+    visiting.add(p);
+    for (const input of plans.get(p)?.inputs ?? []) {
+      const q = propertyAt(owner.get(p), input);
+      if (q && plans.has(q)) cycle(q);
+    }
+    visiting.delete(p);
+    done.add(p);
+  };
+  for (const p of plans.keys()) cycle(p);
+  for (const r of c.refs.values())
+    if (r.property.value !== void 0) {
+      r.readonly = true;
+      r.input.readonly = true;
+    }
+  const scan = (value, at) => {
+    if (!value || typeof value !== "object") return;
+    for (const [key, v] of Object.entries(value)) {
+      if (key === "components" || key === "data") continue;
+      const point = ptr(at, key);
+      if (["set", "toggle", "write"].includes(key)) {
+        const targets = key === "set" ? Object.keys(v) : key === "write" ? Object.values(v) : Array.isArray(v) ? v : [v];
+        for (const target of targets)
+          if (c.refs.get(String(target))?.property.value !== void 0)
+            error(
+              "read-only-path",
+              key === "set" ? ptr(point, String(target)) : point,
+              "computed destination is read-only"
+            );
+      }
+      if (key === "copy" && typeof v === "string" && c.refs.get(v.split("->")[1]?.trim() ?? "")?.property.value !== void 0)
+        error("read-only-path", point, "computed copy destination is read-only");
+      if (key === "bind" && v && typeof v === "object") {
+        for (const [target, b] of Object.entries(v))
+          if (b && typeof b === "object" && ["to-source", "two-way"].includes(b.mode) && c.refs.get(b.value)?.property.value !== void 0)
+            error(
+              "read-only-path",
+              ptr(point, target),
+              "computed reverse binding destination is read-only"
+            );
+      }
+      scan(v, point);
+    }
+  };
+  scan(model.doc, "");
+  const step = (s, dt, report = false) => {
+    const done2 = /* @__PURE__ */ new WeakMap(), active = /* @__PURE__ */ new WeakMap();
+    const read = (object, name, keys) => {
+      if (!object) return void 0;
+      name = s.modelTypes?.get(object) ?? name;
+      if (!keys.length) return object;
+      const [key, ...tail] = keys, p = defs[name]?.properties[key];
+      if (!p) return void 0;
+      const e = plans.get(p);
+      if (e && !done2.get(object)?.has(key)) {
+        let pending = active.get(object);
+        if (!pending) active.set(object, pending = /* @__PURE__ */ new Set());
+        if (pending.has(key)) {
+          if (report)
+            error("derive-cycle", points.get(p) + "/value", "cyclic computed property dependency");
+          return object[key];
+        }
+        pending.add(key);
+        const get = (path) => {
+          const m = /^\$(?:([\w-]+):)?(.+)$/.exec(path);
+          if (!m) return s.get(path);
+          const instance = m[1];
+          return instance ? read(
+            s.instances[instance],
+            c.document.instances[instance]?.model ?? "",
+            m[2].split(".")
+          ) : read(object, name, m[2].split("."));
+        };
+        if (report) {
+          for (const input of e.inputs)
+            if (get(input) === void 0)
+              error(
+                "data-path",
+                points.get(p) + "/value",
+                "unknown instance-relative path " + input
+              );
+        }
+        let value2 = e.evaluate({ get });
+        if (p.convert && !report)
+          value2 = data.converters.get(p.convert)(
+            value2,
+            {},
+            {
+              player: s.player,
+              dt,
+              direction: "forward",
+              get,
+              state: s.converterState,
+              key: points.get(p) + ":" + ids(object)
+            }
+          );
+        if (!report) {
+          if (p.type === "number" && typeof value2 === "boolean") value2 = Number(value2);
+          if (typeof value2 === "number" && !Number.isFinite(value2)) value2 = 0;
+          if (!accepts(p, value2)) throw new Error("anima: derive-type " + points.get(p));
+          value2 = normalize(p, value2);
+        }
+        object[key] = value2;
+        pending.delete(key);
+        let seen = done2.get(object);
+        if (!seen) done2.set(object, seen = /* @__PURE__ */ new Set());
+        seen.add(key);
+      }
+      const value = object[key];
+      if (!tail.length) return value;
+      if (p.type === "string" && tail.length === 1 && tail[0] === "length")
+        return String(value).length;
+      if (p.type === "model-ref") return read(value, p.model, tail);
+      if (p.type === "list") {
+        const [index, ...rest] = tail;
+        if (index === "length") return value.length;
+        return read(value[+index], p.of, rest);
+      }
+      return void 0;
+    };
+    const visit = (object, name, seen = /* @__PURE__ */ new Set()) => {
+      if (!object || seen.has(object)) return;
+      name = s.modelTypes?.get(object) ?? name;
+      seen.add(object);
+      for (const [key, p] of Object.entries(defs[name]?.properties ?? {})) {
+        read(object, name, [key]);
+        if (p.type === "model-ref") visit(object[key], p.model, seen);
+        if (p.type === "list")
+          for (const v of object[key]) visit(v, p.of, seen);
+      }
+    };
+    for (const [name, values] of Object.entries(s.instances))
+      visit(values, c.document.instances[name]?.model ?? "");
+  };
+  const identity = /* @__PURE__ */ new WeakMap();
+  let next = 0;
+  const ids = (o) => {
+    if (!identity.has(o)) identity.set(o, ++next);
+    return identity.get(o);
+  };
+  const initial = (name, values, at) => {
+    for (const [key, v] of Object.entries(values)) {
+      const p = defs[name]?.properties[key] ?? propertyAt(name, "$" + key);
+      if (!p) continue;
+      if (p.value !== void 0)
+        error("read-only-path", ptr(at, key), "computed initial value is read-only");
+      if (p.type === "list" && Array.isArray(v))
+        v.forEach((x, i) => {
+          if (x && typeof x === "object")
+            initial(x.model ?? p.of, x.values ?? x, ptr(at, key) + "/" + i);
+        });
+      if (p.type === "model-ref" && v && typeof v === "object")
+        initial(
+          p.model,
+          v.values ?? v,
+          ptr(at, key)
+        );
+    }
+  };
+  for (const [name, i] of Object.entries(c.document.instances ?? {}))
+    initial(i.model, i.values ?? {}, ptr("/data/instances", name) + "/values");
+  if (d.list.some((x) => x.severity === "error")) return;
+  step(
+    {
+      instances: c.defaults,
+      modelTypes: c.modelOf,
+      get: (path) => model.inputs.get(path)?.def
+    },
+    0,
+    true
+  );
+  const factory = model.inputScope;
+  model.inputScope = (p) => {
+    const s = factory(p);
+    s.modelTypes = /* @__PURE__ */ new WeakMap();
+    const seen = /* @__PURE__ */ new WeakSet();
+    const index = (source, target) => {
+      if (!source || typeof source !== "object" || !target || typeof target !== "object" || seen.has(source))
+        return;
+      seen.add(source);
+      const name = c.modelOf.get(source);
+      if (name) s.modelTypes.set(target, name);
+      for (const [key, value] of Object.entries(source))
+        index(value, target[key]);
+    };
+    index(c.defaults, s.instances);
+    for (const input of model.inputs.values())
+      if (!c.refs.has(input.name) && input.type !== "trigger") s.set(input.name, input.def);
+    step(s, 0);
+    s.initial = new Map(
+      [...c.refs].filter(([, r]) => r.property.value !== void 0).map(([path]) => [path, s.get(path)])
+    );
+    return s;
+  };
+  const previous = model.prepareInputs;
+  model.prepareInputs = (p, scope, dt) => {
+    previous?.(p, scope, dt);
+    step(scope, dt);
+  };
+}
+export {
+  derive
+};

package/modules/derive/manifest.d.ts

@@ -0,0 +1,26 @@
+export declare const after: string[];
+declare const _default: {
+    name: string;
+    summary: string;
+    after: string[];
+    core: {
+        entry: string;
+        export: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/derive/index.ts': string;
+        'packages/web/src/derive.ts': string;
+    };
+    exports: {
+        'core:./derive': string;
+        'web:./derive': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/derive/manifest.js

@@ -0,0 +1,28 @@
+const after = ["data", "bind", "convert"];
+var manifest_default = {
+  name: "derive",
+  summary: "Derived data: computed, read-only model properties from expressions.",
+  after,
+  core: { entry: "core/index.ts", export: "derive" },
+  web: [{ name: "derive", budget: 2624 }],
+  adapters: {
+    "packages/core/src/modules/derive/index.ts": "core/index.ts",
+    "packages/web/src/derive.ts": "web/index.ts"
+  },
+  exports: {
+    "core:./derive": "packages/core/src/modules/derive/index.ts",
+    "web:./derive": "packages/web/src/derive.ts"
+  },
+  tests: [
+    "modules/derive/test/**/*.test.ts",
+    "packages/markup/test/corpus.test.ts",
+    "packages/markup/test/names.test.ts",
+    "packages/markup/test/decompile.test.ts"
+  ],
+  conformance: ["derive-", "bind-comparisons"],
+  docs: ["modules/derive/SPEC.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

package/modules/derive/web/index.js

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

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

@@ -0,0 +1,19 @@
+import '../../../packages/web/src/index.js';
+type Stats = {
+    fps: number;
+    frameMs: number;
+    frames: number;
+};
+declare module '../../../packages/web/src/index.ts' {
+    namespace AnimaIcon {
+        let warnings: 'once' | 'always' | 'off' | {
+            off: readonly string[];
+        };
+        function warn(code: string, message: string): void;
+    }
+    interface AnimaIcon {
+        readonly stats: Stats;
+        perfMarks: boolean;
+    }
+}
+export {};

package/modules/devtools/web/index.js

@@ -0,0 +1,58 @@
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+const samples = /* @__PURE__ */ new WeakMap();
+const read = (icon) => {
+  const list = samples.get(icon) ?? [];
+  const cutoff = performance.now() - 1e3;
+  while (list.length && list[0][0] <= cutoff) list.shift();
+  return list;
+};
+Object.defineProperty(Icon.prototype, "stats", {
+  get() {
+    const list = read(this);
+    return {
+      fps: list.length,
+      frameMs: list.reduce((sum, s) => sum + s[1], 0) / (list.length || 1),
+      frames: list.length
+    };
+  }
+});
+const t0 = performance.now();
+const born = /* @__PURE__ */ new WeakMap();
+const seen = /* @__PURE__ */ new WeakSet();
+const connected = Icon.prototype.connectedCallback;
+Icon.prototype.connectedCallback = function() {
+  born.set(this, performance.now());
+  connected.call(this);
+};
+const frame = Icon.prototype.frame;
+Icon.prototype.frame = function(now) {
+  const start = performance.now();
+  const marks = this.perfMarks || this.hasAttribute("perf");
+  const mark = marks ? performance.mark("anima:frame:start") : void 0;
+  try {
+    frame.call(this, now);
+  } finally {
+    if (mark) {
+      performance.measure("anima:frame", { start: mark.startTime, end: performance.now() });
+      performance.clearMarks("anima:frame:start");
+      if (!seen.has(this)) {
+        seen.add(this);
+        const start2 = born.get(this) ?? t0;
+        performance.mark("anima:load", { startTime: start2 });
+        performance.measure("anima:first-frame", { start: start2, end: performance.now() });
+      }
+    }
+    const list = read(this);
+    list.push([performance.now(), performance.now() - start]);
+    samples.set(this, list);
+  }
+};
+Icon.warnings = "once";
+const warned = /* @__PURE__ */ new Set();
+Icon.warn = (code, message) => {
+  if (Icon.warnings === "off" || typeof Icon.warnings === "object" && Icon.warnings.off.includes(code) || Icon.warnings === "once" && warned.has(code))
+    return;
+  warned.add(code);
+  console.warn(message);
+};

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

@@ -0,0 +1,16 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { ObjShape } from '../../../packages/core/src/registry.js';
+export interface EventDefinition {
+    payload?: Record<string, {
+        type: 'number' | 'bool' | 'string' | 'color';
+        value?: number | boolean | string;
+        input?: string;
+        address?: string;
+    }>;
+    url?: string;
+    target?: '_blank' | '_parent' | '_self' | '_top';
+    audio?: string;
+    volume?: number;
+}
+export declare const definition: ObjShape;
+export declare const events: Module;