animl 0.0.0-stage → 0.1.0

package/modules/data/core/storage.js

@@ -0,0 +1,109 @@
+import { clone } from "./types.js";
+import { parseHex, formatHex } from "../../../packages/core/src/color.js";
+import { compiled, scalarType } from "./types.js";
+const states = /* @__PURE__ */ new WeakMap();
+function accepts(p, value) {
+  if (p.type === "number") return typeof value === "number" && Number.isFinite(value);
+  if (p.type === "bool") return typeof value === "boolean";
+  if (p.type === "color")
+    return typeof value === "string" ? !!parseHex(value) : Array.isArray(value) && value.length === 4 && value.every((v) => Number.isInteger(v) && v >= 0 && v <= 255);
+  if (p.type === "enum") return typeof value === "string" && !!p.values?.includes(value);
+  if (p.type === "component" || p.type === "text-style")
+    return typeof value === "string" && (!value || !!p.values?.includes(value));
+  if (p.type === "string" || p.type === "asset-ref") return typeof value === "string";
+  return false;
+}
+function normalize(p, value) {
+  if (p.type === "number")
+    return Math.max(p.min ?? -Infinity, Math.min(p.max ?? Infinity, Number(value)));
+  if (p.type === "color" && typeof value === "string") return parseHex(value);
+  return value;
+}
+class DataState extends Map {
+  instances;
+  modelTypes;
+  /** External component aliases owned by this player, never its compiled schema. */
+  componentValues;
+  compiled;
+  signals = /* @__PURE__ */ new Map();
+  converterState = /* @__PURE__ */ new Map();
+  player;
+  initial;
+  constructor(c) {
+    super();
+    this.compiled = c;
+    const seen = /* @__PURE__ */ new Map();
+    this.instances = clone(c.defaults, seen);
+    this.modelTypes = /* @__PURE__ */ new WeakMap();
+    for (const [source, value] of seen) {
+      const name = c.modelOf.get(source);
+      if (name) this.modelTypes.set(value, name);
+    }
+  }
+  /** Authored export discovery; private instances remain available to internal bindings. */
+  exports() {
+    return Object.entries(this.compiled.document.instances ?? {}).filter(([, instance]) => instance.exported).map(([name, instance]) => ({ name, model: instance.model }));
+  }
+  ref(path) {
+    return this.compiled.refs.get(path);
+  }
+  get(path) {
+    const r = this.ref(path);
+    if (!r) return super.get(path);
+    let value = this.instances[r.instance];
+    for (const key of r.keys)
+      value = value == null ? void 0 : value[key];
+    return value;
+  }
+  set(path, value) {
+    const r = this.ref(path);
+    if (!r) return super.set(path, value);
+    if (r.readonly) return this;
+    if (!accepts(r.property, value) && !(r.property.type === "component" && typeof value === "string" && this.componentValues?.has(value)))
+      throw new Error("anima: data-type " + path);
+    let object = this.instances[r.instance];
+    for (const key of r.keys.slice(0, -1)) object = object[key];
+    object[r.keys.at(-1)] = normalize(r.property, value);
+    return this;
+  }
+  read(path) {
+    if (this.ref(path)) return this.get(path);
+    const match = /^\$(?:([\w-]+):)?([\w.-]+)$/.exec(path);
+    if (!match) return void 0;
+    let v = this.instances[match[1] ?? this.compiled.defaultName];
+    for (const k of match[2].split("."))
+      v = v == null ? void 0 : v[k];
+    return v;
+  }
+}
+function dataState(player) {
+  return states.get(player);
+}
+function createScope(player) {
+  const s = new DataState(compiled.get(player.model));
+  s.player = player;
+  states.set(player, s);
+  return s;
+}
+function inputFor(property, value, name, readonly = false) {
+  return {
+    name,
+    type: scalarType(property),
+    def: normalize(property, value),
+    min: property.min ?? -Infinity,
+    max: property.max ?? Infinity,
+    buffer: 0,
+    readonly,
+    accepts: (value2) => accepts(property, value2)
+  };
+}
+const printable = (v) => Array.isArray(v) ? formatHex(v) : v;
+export {
+  DataState,
+  accepts,
+  createScope,
+  dataState,
+  inputFor,
+  normalize,
+  printable
+};

package/modules/data/core/types.d.ts

@@ -0,0 +1,78 @@
+import type { Value, Model, InputM } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+export type PropertyType = 'number' | 'string' | 'bool' | 'color' | 'trigger' | 'enum' | 'list' | 'model-ref' | 'asset-ref' | 'component' | 'text-style';
+export interface Property {
+    type: PropertyType;
+    default?: unknown;
+    value?: string;
+    convert?: string;
+    min?: number;
+    max?: number;
+    values?: string[];
+    enum?: string;
+    system?: string;
+    of?: string;
+    model?: string;
+    assetType?: 'image' | 'audio' | 'font' | 'blob';
+    public?: boolean;
+    label?: string;
+}
+export interface Definition {
+    properties: Record<string, Property>;
+    global?: boolean;
+}
+export interface Instance {
+    model: string;
+    values?: Record<string, unknown>;
+    default?: boolean;
+    exported?: boolean;
+    label?: string;
+}
+export interface DataDocument {
+    models: Record<string, Definition>;
+    instances?: Record<string, Instance>;
+    enums?: Record<string, (string | {
+        key: string;
+        label?: string;
+    })[]>;
+    model?: string;
+    preview?: string;
+}
+export interface Binding {
+    value: string;
+    mode?: 'to-target' | 'to-source' | 'two-way' | 'once';
+    prefer?: 'source' | 'target';
+    convert?: string;
+    options?: Record<string, unknown>;
+}
+export interface Context {
+    player: Player;
+    dt: number;
+    direction: 'forward' | 'reverse';
+    get(path: string): unknown;
+    state: Map<unknown, unknown>;
+    key?: string;
+}
+export type Converter = (value: unknown, options: Record<string, unknown>, ctx: Context) => unknown;
+export interface Ref {
+    instance: string;
+    keys: string[];
+    property: Property;
+    readonly?: boolean;
+    input: InputM;
+}
+export interface Compiled {
+    document: DataDocument;
+    defaults: Record<string, Record<string, unknown>>;
+    defaultName: string;
+    refs: Map<string, Ref>;
+    model: Model;
+    modelOf: WeakMap<object, string>;
+}
+export declare const compiled: WeakMap<Model, Compiled>;
+export declare const converters: Map<string, Converter>;
+export declare function registerConverter(name: string, run: Converter): void;
+export declare function scalarType(p: Property): InputM['type'];
+export declare const same: (a: unknown, b: unknown) => boolean;
+export declare const asValue: (x: unknown) => Value;
+export declare function clone<T>(v: T, seen?: Map<object, unknown>): T;

package/modules/data/core/types.js

@@ -0,0 +1,27 @@
+const compiled = /* @__PURE__ */ new WeakMap();
+const converters = /* @__PURE__ */ new Map();
+function registerConverter(name, run) {
+  converters.set(name, run);
+}
+function scalarType(p) {
+  return p.type === "enum" || p.type === "asset-ref" || p.type === "component" || p.type === "text-style" ? "string" : p.type === "list" || p.type === "model-ref" ? "number" : p.type;
+}
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const asValue = (x) => x;
+function clone(v, seen = /* @__PURE__ */ new Map()) {
+  if (v === null || 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, seen);
+  return out;
+}
+export {
+  asValue,
+  clone,
+  compiled,
+  converters,
+  registerConverter,
+  same,
+  scalarType
+};

package/modules/data/manifest.d.ts

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

package/modules/data/manifest.js

@@ -0,0 +1,114 @@
+const after = ["components", "bind", "events", "input", "focus", "paint"];
+var manifest_default = {
+  ...{
+    name: "data",
+    summary: "Data: typed view models, $ paths, named instances, lists of models and two-way binding.",
+    after: [],
+    core: { entry: "core/index.ts", export: "data" },
+    web: [{ name: "data", budget: 7040 }],
+    adapters: {
+      "packages/core/src/modules/data/index.ts": "core/index.ts",
+      "packages/markup/src/data.ts": "markup/index.ts",
+      "packages/web/src/data.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./data": "packages/core/src/modules/data/index.ts",
+      "markup:./data": "packages/markup/src/data.ts",
+      "web:./data": "packages/web/src/data.ts"
+    },
+    markupHook: {
+      browserName: "data",
+      slot: "dataCompiler",
+      type: "dataMarkup",
+      value: "dataMarkup"
+    },
+    tests: [
+      "modules/data/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts",
+      "packages/markup/test/decompile.test.ts",
+      "packages/markup/test/compile.test.ts"
+    ],
+    conformance: [
+      "data-bind-conditions",
+      "data-bind-converter-options",
+      "data-bind-instance-values",
+      "data-bind-keyframes",
+      // seam(P7-2): layout owns data.bind-layout and its completed probes.
+      "data-bind-script-inputs",
+      "data-bind-text",
+      "data-binding-absolute",
+      "data-binding-once",
+      "data-binding-relative",
+      "data-binding-to-source",
+      "data-binding-two-way-prefer-source",
+      "data-binding-two-way-prefer-target",
+      "data-component-public-data",
+      "data-custom-property-boolean",
+      "data-custom-property-color",
+      "data-custom-property-enum",
+      "data-custom-property-number",
+      "data-custom-property-string",
+      "data-custom-property-trigger",
+      "data-default-instance",
+      "data-editor-preview-instance",
+      "data-enum-members",
+      "data-global-model",
+      "data-instance-export",
+      "data-list-items",
+      "data-model-definition",
+      "data-named-instances",
+      "data-operation-operand-view-model",
+      "data-property-artboard",
+      "data-property-asset-blob",
+      "data-property-asset-font",
+      "data-property-asset-image",
+      "data-property-boolean",
+      "data-property-color",
+      "data-property-enum-custom",
+      "data-property-enum-system",
+      "data-property-list",
+      "data-property-number",
+      "data-property-string",
+      "data-property-symbol-list-index",
+      "data-property-text-style",
+      "data-property-trigger",
+      "data-property-view-model",
+      "data-script-model-api",
+      "data-scripted-converter",
+      "data-state-action-trigger",
+      "data-system-enum-horizontal-text-align",
+      "data-system-enum-layout-alignment",
+      "data-system-enum-layout-direction",
+      "data-system-enum-layout-display",
+      "data-system-enum-layout-flex-direction",
+      "data-system-enum-layout-position",
+      "data-system-enum-layout-position-units",
+      "data-system-enum-layout-scale-type",
+      "data-system-enum-layout-wrap",
+      "data-system-enum-scroll-direction",
+      "data-system-enum-semantic-check-state",
+      "data-system-enum-text-box",
+      "data-system-enum-text-overflow",
+      "data-system-enum-text-trim-bottom",
+      "data-system-enum-text-trim-top",
+      "data-system-enum-vertical-text-align",
+      "data-system-enum-word-wrap",
+      "drawing-paint-gradient-channel-binding",
+      "input-data-listener",
+      "input-write-data-constant",
+      "input-write-data-copy",
+      "input-write-focused",
+      "input-write-gamepad-axis",
+      "input-write-gamepad-button-pressed",
+      "input-write-gamepad-button-value",
+      "input-write-gamepad-changed-value"
+    ],
+    docs: ["spec/SPEC.md", "spec/ANIML.md", "modules/data/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

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

@@ -0,0 +1,16 @@
+import type { LayoutElement } from '../../../packages/markup/src/layout.js';
+type Obj = Record<string, unknown>;
+export declare const dataMarkup: {
+    attributes(name: string): string[];
+    rootAttrs(d: Obj): [string, string][];
+    definitions(d: Obj): LayoutElement[];
+    form(el: import("animl/markup").Element, base: import("animl/markup/compile.ts").Form): import("animl/markup/compile.ts").Form;
+    binding(a: Map<string, import("animl/markup").Attr>): unknown;
+    rootChild(c: import("animl/markup/compile.ts").Compiler, el: import("animl/markup").Element, o: {
+        [x: string]: unknown;
+    }, p: string): boolean;
+    node(el: import("animl/markup").Element, o: {
+        [x: string]: unknown;
+    }): void;
+};
+export {};

package/modules/data/markup/index.js

@@ -0,0 +1,100 @@
+import { dataMarkup as compiler, propertyNames } from "../../markup-hooks/markup/data.js";
+const dataMarkup = {
+  ...compiler,
+  attributes(name) {
+    return ["anima", "component", "model", "instance", "set", "bind", ...propertyNames].includes(
+      name
+    ) ? [
+      "name",
+      "global",
+      "model",
+      "default",
+      "export",
+      "exported",
+      "label",
+      "min",
+      "max",
+      "values",
+      "enum",
+      "system",
+      "of",
+      "type",
+      "public",
+      "path",
+      "value",
+      "mode",
+      "prefer",
+      "convert",
+      "options",
+      "data"
+    ] : [];
+  },
+  rootAttrs(d) {
+    const data = d.data;
+    if (!data) return [];
+    if (typeof data === "string") return [["data", data]];
+    const metadata = Object.fromEntries(
+      Object.entries(data).filter(([key]) => !["models", "instances", "enums"].includes(key))
+    );
+    return Object.keys(metadata).length ? [["data", JSON.stringify(metadata)]] : [];
+  },
+  definitions(d) {
+    const data = d.data;
+    if (!data || typeof data === "string") return [];
+    const entry = (name, o, attrs = []) => ({
+      name,
+      attrs: [
+        ...attrs,
+        ...Object.entries(o).filter(([k]) => k !== "$comment").map(([k, v]) => [k, typeof v === "string" ? v : JSON.stringify(v)])
+      ],
+      children: []
+    });
+    return [
+      ...Object.entries(data.enums ?? {}).map(
+        ([name, v]) => entry(
+          "enum",
+          {
+            values: v.some((x) => typeof x === "object") ? JSON.stringify(v) : v.join(" ")
+          },
+          [["name", name]]
+        )
+      ),
+      ...Object.entries(data.models ?? {}).map(([name, def]) => {
+        const el = entry(
+          "model",
+          Object.fromEntries(Object.entries(def).filter(([k]) => k !== "properties")),
+          [["name", name]]
+        );
+        el.children = Object.entries(def.properties).filter(([k]) => k !== "$comment").map(
+          ([key, p]) => entry(
+            p.type,
+            Object.fromEntries(
+              Object.entries(p).filter(([k]) => k !== "type").map(([k, v]) => [
+                k === "assetType" ? "type" : k,
+                k === "values" ? v.join(" ") : k === "default" && typeof v === "string" ? JSON.stringify(v) : v
+              ])
+            ),
+            [["name", key]]
+          )
+        );
+        return el;
+      }),
+      ...Object.entries(data.instances ?? {}).map(([name, def]) => {
+        const el = entry(
+          "instance",
+          Object.fromEntries(
+            Object.entries(def).filter(([k]) => k !== "values").map(([k, v]) => [k === "exported" ? "export" : k, v])
+          ),
+          [["name", name]]
+        );
+        el.children = Object.entries(def.values ?? {}).map(
+          ([path, value]) => entry("set", { path, value: typeof value === "string" ? JSON.stringify(value) : value })
+        );
+        return el;
+      })
+    ];
+  }
+};
+export {
+  dataMarkup
+};

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

@@ -0,0 +1,2 @@
+import '../../../packages/web/src/index.js';
+export { dataState } from '../core/index.js';

package/modules/data/web/index.js

@@ -0,0 +1,8 @@
+import { data } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(data);
+import { dataState } from "../core/index.js";
+export {
+  dataState
+};

package/modules/data-artboard/capabilities/data-host-artboard/registry.d.ts

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

package/modules/data-artboard/capabilities/data-host-artboard/registry.js

@@ -0,0 +1,23 @@
+const entries = [
+  {
+    target: "document",
+    shapes: {},
+    elements: {
+      artboard: {
+        shape: {
+          k: "obj",
+          req: ["name"],
+          p: {
+            name: { k: "str" },
+            default: { k: "str" },
+            model: { k: "str" },
+            public: { k: "bool" }
+          }
+        }
+      }
+    }
+  }
+];
+export {
+  entries
+};

package/modules/data-artboard/core/index.d.ts

@@ -0,0 +1,21 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { Model } from '../../../packages/core/src/load.js';
+export interface ComponentValue {
+    readonly document: Model;
+    readonly name: string;
+}
+export declare function component(document: Model, name: string): ComponentValue;
+export declare const assignments: WeakMap<Player, Map<string, Model> & {
+    next?: number;
+}>;
+export declare const dataArtboard: Module & {
+    resources: {
+        adopt?: (parent: Player, child: Player) => void;
+    };
+};
+declare module '../../host/core/api.ts' {
+    interface HostData {
+        artboard(path: string): DataHandle<string | ComponentValue>;
+    }
+}