animl 0.0.0-stage → 0.1.0

package/packages/markup/src/library-hooks.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/markup-libraries/markup/hooks.js';

package/packages/markup/src/library-hooks.js

@@ -0,0 +1 @@
+export * from "../../../modules/markup-libraries/markup/hooks.js";

package/packages/markup/src/lists.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/lists/markup/index.js';

package/packages/markup/src/lists.js

@@ -0,0 +1 @@
+export * from "../../../modules/lists/markup/index.js";

package/packages/markup/src/machine.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/machine/markup/index.js';

package/packages/markup/src/machine.js

@@ -0,0 +1 @@
+export * from "../../../modules/machine/markup/index.js";

package/packages/markup/src/markup-layout.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/layout/markup/index.js';

package/packages/markup/src/markup-layout.js

@@ -0,0 +1 @@
+export * from "../../../modules/layout/markup/index.js";

package/packages/markup/src/mix.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/mix/markup/index.js';

package/packages/markup/src/mix.js

@@ -0,0 +1 @@
+export * from "../../../modules/mix/markup/index.js";

package/packages/markup/src/module-hooks.d.ts

@@ -0,0 +1,21 @@
+import { componentMarkup } from '../../../modules/components/markup/index.js';
+export declare const componentCompiler: Partial<typeof componentMarkup>;
+import { bindMarkup } from '../../../modules/bind/markup/index.js';
+export declare const bindCompiler: Partial<typeof bindMarkup>;
+import { animationMarkup } from '../../../modules/markup-animation/markup/index.js';
+export declare const animationCompiler: Partial<typeof animationMarkup>;
+import { motionMarkup } from '../../../modules/motion/markup/index.js';
+export declare const motionCompiler: Partial<typeof motionMarkup>;
+import { eventsMarkup } from '../../../modules/events/markup/index.js';
+export declare const eventsCompiler: Partial<typeof eventsMarkup>;
+import { structuralMarkup } from '../../../modules/paint/markup/index.js';
+export declare const moduleCompiler: Partial<typeof structuralMarkup>;
+import { dataMarkup } from '../../../modules/data/markup/index.js';
+export declare const dataCompiler: Partial<typeof dataMarkup>;
+import { converterCompiler } from '../../../modules/convert/markup/index.js';
+export declare const convertCompiler: Partial<typeof converterCompiler>;
+import { textMarkup } from '../../../modules/text/markup/index.js';
+export declare const textCompiler: Partial<typeof textMarkup>;
+import { layoutMarkup } from '../../../modules/layout/markup/index.js';
+export declare const layoutCompiler: Partial<typeof layoutMarkup>;
+export declare function prepareModuleMarkup(hooks: Record<string, object>): void;

package/packages/markup/src/module-hooks.js

@@ -0,0 +1,56 @@
+import { VERBOSE } from "animl";
+import { componentMarkup } from "../../../modules/components/markup/index.js";
+const componentCompiler = {};
+if (VERBOSE) Object.assign(componentCompiler, componentMarkup);
+import { bindMarkup } from "../../../modules/bind/markup/index.js";
+const bindCompiler = {};
+if (VERBOSE) Object.assign(bindCompiler, bindMarkup);
+import { animationMarkup } from "../../../modules/markup-animation/markup/index.js";
+const animationCompiler = {};
+if (VERBOSE) Object.assign(animationCompiler, animationMarkup);
+import { motionMarkup } from "../../../modules/motion/markup/index.js";
+const motionCompiler = {};
+if (VERBOSE) Object.assign(motionCompiler, motionMarkup);
+import { eventsMarkup } from "../../../modules/events/markup/index.js";
+const eventsCompiler = {};
+if (VERBOSE) Object.assign(eventsCompiler, eventsMarkup);
+import { structuralMarkup, structuralForms } from "../../../modules/paint/markup/index.js";
+const moduleCompiler = {};
+if (VERBOSE) Object.assign(moduleCompiler, structuralMarkup);
+import { dataMarkup } from "../../../modules/data/markup/index.js";
+const dataCompiler = {};
+if (VERBOSE) Object.assign(dataCompiler, dataMarkup);
+import { converterCompiler } from "../../../modules/convert/markup/index.js";
+const convertCompiler = {};
+if (VERBOSE) Object.assign(convertCompiler, converterCompiler);
+import { textMarkup } from "../../../modules/text/markup/index.js";
+const textCompiler = {};
+if (VERBOSE) Object.assign(textCompiler, textMarkup);
+import { layoutMarkup } from "../../../modules/layout/markup/index.js";
+const layoutCompiler = {};
+if (VERBOSE) Object.assign(layoutCompiler, layoutMarkup);
+function prepareModuleMarkup(hooks) {
+  Object.assign(componentCompiler, hooks["components"]);
+  Object.assign(bindCompiler, hooks["bind"]);
+  Object.assign(animationCompiler, hooks["animation"]);
+  Object.assign(motionCompiler, hooks["motion"]);
+  Object.assign(eventsCompiler, hooks["events"]);
+  Object.assign(moduleCompiler, structuralForms, hooks["paint"]);
+  Object.assign(dataCompiler, hooks["data"]);
+  Object.assign(convertCompiler, hooks["convert"]);
+  Object.assign(textCompiler, hooks["text"]);
+  Object.assign(layoutCompiler, hooks["layout"]);
+}
+export {
+  animationCompiler,
+  bindCompiler,
+  componentCompiler,
+  convertCompiler,
+  dataCompiler,
+  eventsCompiler,
+  layoutCompiler,
+  moduleCompiler,
+  motionCompiler,
+  prepareModuleMarkup,
+  textCompiler
+};

package/packages/markup/src/modules.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/paint/markup/index.js';

package/packages/markup/src/modules.js

@@ -0,0 +1 @@
+export * from "../../../modules/paint/markup/index.js";

package/packages/markup/src/motion.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/motion/markup/index.js';

package/packages/markup/src/motion.js

@@ -0,0 +1 @@
+export * from "../../../modules/motion/markup/index.js";

package/packages/markup/src/names.d.ts

@@ -0,0 +1,32 @@
+import { type NodeType, type Shape, STATIC } from 'animl';
+/** Where a node attribute lives in `.ani`: a key path, and for `cx`/`cy` an index into `center`. */
+export interface NodeField {
+    /** AniML attribute name. */
+    attr: string;
+    /** `.ani` key path on the node: `['x']`, `['fill', 'color']`, `['center']`. */
+    path: string[];
+    /** Index into a vector key (`cx` → 0, `cy` → 1). */
+    index?: number;
+    /** The registry shape of the `.ani` value. */
+    shape: Shape;
+}
+export interface NodeAttr extends NodeField {
+    /** Animatable, so usable in `<track target>` and `<pose>`. */
+    animatable: boolean;
+}
+/** The attributes a node element takes, in canonical order (after `id`). */
+export declare function nodeFields(type: NodeType): NodeField[];
+/** Full authoring descriptors; the compiler needs only the field paths and shapes. */
+export declare function nodeAttrs(type: NodeType): NodeAttr[];
+/** Keys of a node object that `nodeAttrs` does not cover (handled structurally). */
+export declare const STRUCTURAL_NODE_KEYS: string[];
+/** Node element names: one per node type. */
+export declare const NODE_ELEMENTS: readonly string[];
+/**
+ * `<id>.<attr>` (markup) → `<id>.<key path>` (`.ani`), or undefined if the attribute is not an
+ * animatable node attribute (the caller passes the address through so the loader reports it).
+ */
+export declare function aniAddress(address: string, typeOf: (id: string) => NodeType | undefined, attributes?: typeof nodeFields): string | undefined;
+/** `<id>.<key path>` (`.ani`) → `<id>.<attr>` (markup); unchanged when there is no node attribute for it. */
+export declare function markupAddress(address: string, typeOf: (id: string) => NodeType | undefined): string;
+export { STATIC };

package/packages/markup/src/names.js

@@ -0,0 +1,89 @@
+import { layoutCompiler } from "./module-hooks.js";
+import {
+  COMMON,
+  NODE_TYPES,
+  OWN,
+  PAINT,
+  PAINTED,
+  STATIC,
+  markupName,
+  nodeShape
+} from "animl";
+const TRANSFORM = "pivot x y rotate scale scaleX scaleY opacity visible".split(" ");
+function nodeFields(type) {
+  const out = [];
+  const ns = nodeShape(type);
+  for (const key of /* @__PURE__ */ new Set([
+    ...Object.keys(STATIC[type]).filter((k) => k !== "children"),
+    ...Object.keys(OWN[type]),
+    ...TRANSFORM
+  ])) {
+    const shape = ns.p[key];
+    if (shape.element) continue;
+    const name = markupName(shape, key);
+    const parts = name.split(" ");
+    if (parts.length > 1)
+      parts.forEach((attr, index) => out.push({ attr, path: [key], index, shape }));
+    else out.push({ attr: name, path: [key], shape });
+  }
+  if (PAINTED.includes(type)) {
+    for (const paint of ["fill", "stroke"]) {
+      for (const field of Object.keys(ns.p[paint].p)) {
+        const obj = ns.p[paint];
+        const shape = obj.p[field];
+        if (shape.element) continue;
+        out.push({
+          attr: markupName(shape, field),
+          path: [paint, field],
+          shape
+        });
+      }
+    }
+    out.push({ attr: "knockout", path: ["knockout"], shape: ns.p.knockout });
+  }
+  layoutCompiler.fields?.(out, ns);
+  return out;
+}
+function nodeAttrs(type) {
+  return nodeFields(type).map((a) => ({
+    ...a,
+    animatable: a.index === void 0 && (a.path.length === 2 ? a.path[1] in (PAINT[a.path[0]] ?? {}) : a.path[0] in COMMON || a.path[0] in OWN[type])
+  }));
+}
+const STRUCTURAL_NODE_KEYS = [
+  "id",
+  "type",
+  "children",
+  ...Object.keys(STATIC.group).filter((k) => nodeShape("group").p[k]?.element),
+  "paints",
+  "inputs"
+];
+const NODE_ELEMENTS = NODE_TYPES;
+function aniAddress(address, typeOf, attributes = nodeFields) {
+  const dot = address.indexOf(".");
+  if (dot < 0) return void 0;
+  const type = typeOf(address.slice(0, dot));
+  if (!type) return void 0;
+  const a = attributes(type).find(
+    (x) => x.attr === address.slice(dot + 1) && x.index === void 0
+  );
+  return a ? `${address.slice(0, dot)}.${a.path.join(".")}` : void 0;
+}
+function markupAddress(address, typeOf) {
+  const dot = address.indexOf(".");
+  if (dot < 0) return address;
+  const type = typeOf(address.slice(0, dot));
+  if (!type) return address;
+  const key = address.slice(dot + 1);
+  const a = nodeAttrs(type).find((x) => x.path.join(".") === key && x.index === void 0);
+  return a ? `${address.slice(0, dot)}.${a.attr}` : address;
+}
+export {
+  NODE_ELEMENTS,
+  STATIC,
+  STRUCTURAL_NODE_KEYS,
+  aniAddress,
+  markupAddress,
+  nodeAttrs,
+  nodeFields
+};

package/packages/markup/src/nested.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/nested/markup/index.js';

package/packages/markup/src/nested.js

@@ -0,0 +1 @@
+export * from "../../../modules/nested/markup/index.js";

package/packages/markup/src/pathfollow.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/pathfollow/markup/index.js';

package/packages/markup/src/pathfollow.js

@@ -0,0 +1 @@
+export * from "../../../modules/pathfollow/markup/index.js";

package/packages/markup/src/reuse.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/markup-libraries/markup/reuse.js';

package/packages/markup/src/reuse.js

@@ -0,0 +1 @@
+export * from "../../../modules/markup-libraries/markup/reuse.js";

package/packages/markup/src/rig.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/rig/markup/index.js';

package/packages/markup/src/rig.js

@@ -0,0 +1 @@
+export * from "../../../modules/rig/markup/index.js";

package/packages/markup/src/scroll.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/scroll/markup/index.js';

package/packages/markup/src/scroll.js

@@ -0,0 +1 @@
+export * from "../../../modules/scroll/markup/index.js";

package/packages/markup/src/skin.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/skin/markup/index.js';

package/packages/markup/src/skin.js

@@ -0,0 +1 @@
+export * from "../../../modules/skin/markup/index.js";

package/packages/markup/src/text-effects.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/text-effects/markup/index.js';

package/packages/markup/src/text-effects.js

@@ -0,0 +1 @@
+export * from "../../../modules/text-effects/markup/index.js";

package/packages/markup/src/text-input.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/text-input/markup/index.js';

package/packages/markup/src/text-input.js

@@ -0,0 +1 @@
+export * from "../../../modules/text-input/markup/index.js";

package/packages/markup/src/text.d.ts

@@ -0,0 +1 @@
+export * from '../../../modules/text/markup/index.js';

package/packages/markup/src/text.js

@@ -0,0 +1 @@
+export * from "../../../modules/text/markup/index.js";

package/packages/markup/src/xml.d.ts

@@ -0,0 +1,67 @@
+export interface Pos {
+    file?: string;
+    related?: Pos;
+    locate?: (offset: number) => Pos;
+    /** 0-based offset into the text. */
+    offset: number;
+    /** 1-based line and column. */
+    line: number;
+    col: number;
+}
+export interface Attr {
+    name: string;
+    /** Entity-decoded value. */
+    value: string;
+    /** Where the attribute name starts. */
+    at: Pos;
+    /** Where the value starts (the first character inside the quotes). */
+    valueAt: Pos;
+}
+export interface Element {
+    kind: 'element';
+    name: string;
+    attrs: Attr[];
+    children: Child[];
+    at: Pos;
+}
+export interface Text {
+    /** Expanded raw character → original source offset. */
+    offsets?: number[];
+    kind: 'text';
+    /** Entity-decoded text. */
+    value: string;
+    /** The text exactly as written (for positions inside it, e.g. keyframes). */
+    raw: string;
+    at: Pos;
+}
+export interface Comment {
+    kind: 'comment';
+    value: string;
+    at: Pos;
+}
+export type Child = Element | Text | Comment;
+export interface XmlError {
+    message: string;
+    at: Pos;
+}
+export interface XmlDocument {
+    /** The root element, or null when there were errors. */
+    root: Element | null;
+    /** Comments before and after the root element. */
+    outer: Comment[];
+    /** Position of any offset in the text. */
+    pos(offset: number): Pos;
+}
+/** Characters XML 1.0 forbids, literally or as a reference (lone surrogates included). */
+export declare const NOT_CHAR: RegExp;
+/** Parse AniML's XML subset. Never throws; problems come back as errors with positions. */
+export declare function parseXml(text: string): {
+    doc: XmlDocument;
+    errors: XmlError[];
+};
+/** Characters XML forbids become U+FFFD, so written markup always parses again (ANIML §8). */
+export declare const xmlChars: (s: string) => string;
+/** Escape text for an attribute value written with double quotes. */
+export declare const escapeAttr: (s: string) => string;
+/** Escape element text. */
+export declare const escapeText: (s: string) => string;

package/packages/markup/src/xml.js

@@ -0,0 +1,211 @@
+import { VERBOSE } from "animl";
+const NAME = /[A-Za-z_][A-Za-z0-9._-]*/y;
+const ENTITY = /&(?:(amp|lt|gt|quot|apos)|#([0-9]{1,7})|#x([0-9a-fA-F]{1,6}));/y;
+const NAMED = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const NOT_CHAR = (
+  // eslint-disable-next-line no-control-regex -- matching XML 1.0's forbidden control characters is the point
+  /[\0-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/
+);
+function decode(s, lenient, bad) {
+  if (!s.includes("&")) return s;
+  let out = "";
+  for (let i = 0; i < s.length; ) {
+    if (s[i] !== "&") {
+      out += s[i++];
+      continue;
+    }
+    ENTITY.lastIndex = i;
+    const m = ENTITY.exec(s);
+    const cp = m && !m[1] ? m[2] ? parseInt(m[2], 10) : parseInt(m[3], 16) : 0;
+    if (m && (m[1] || !(cp > 1114111 || NOT_CHAR.test(String.fromCodePoint(cp))))) {
+      out += m[1] ? NAMED[m[1]] : String.fromCodePoint(cp);
+      i = ENTITY.lastIndex;
+    } else if (m) {
+      bad(
+        i,
+        VERBOSE ? "numeric character reference is outside the Unicode range or not an XML character" : ""
+      );
+      out += m[0];
+      i = ENTITY.lastIndex;
+    } else {
+      if (!lenient) bad(i);
+      out += "&";
+      i++;
+    }
+  }
+  return out;
+}
+function parseXml(text) {
+  const lineStarts = [0];
+  for (const m of text.matchAll(/\r\n?|\n/g)) lineStarts.push(m.index + m[0].length);
+  const pos = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return { offset, line: lo + 1, col: offset - lineStarts[lo] + 1 };
+  };
+  const errors = [];
+  const outer = [];
+  const doc = { root: null, outer, pos };
+  let i = 0;
+  class Stop extends Error {
+  }
+  const fail = (message, at = i) => {
+    errors.push({ message, at: pos(at) });
+    throw new Stop();
+  };
+  const name = () => {
+    NAME.lastIndex = i;
+    const m = NAME.exec(text);
+    if (!m) fail(VERBOSE ? "expected a name" : "");
+    i = NAME.lastIndex;
+    if (text[i] === ":") fail(VERBOSE ? "namespace prefixes are not allowed in AniML" : "");
+    return m[0];
+  };
+  const ws = () => {
+    while (i < text.length && /\s/.test(text[i])) i++;
+  };
+  const comment = () => {
+    const at = i;
+    const end = text.indexOf("-->", i + 4);
+    if (end < 0) fail(VERBOSE ? "comment is not closed with -->" : "", at);
+    const c = { kind: "comment", value: text.slice(i + 4, end), at: pos(at) };
+    i = end + 3;
+    return c;
+  };
+  const special = () => {
+    if (text.startsWith("<![CDATA[", i))
+      fail(VERBOSE ? "CDATA sections are not allowed in AniML" : "");
+    if (text.startsWith("<!", i))
+      fail(VERBOSE ? "DOCTYPE and other declarations are not allowed in AniML" : "");
+    if (text.startsWith("<?", i))
+      fail(
+        VERBOSE ? "processing instructions are not allowed in AniML (only an <?xml \u2026?> declaration at the very start)" : ""
+      );
+  };
+  const element = (depth) => {
+    if (depth > 256) fail(VERBOSE ? "elements nest too deeply" : "");
+    const at = i;
+    i++;
+    const el = { kind: "element", name: name(), attrs: [], children: [], at: pos(at) };
+    for (; ; ) {
+      const before = i;
+      ws();
+      if (text.startsWith("/>", i)) {
+        i += 2;
+        return el;
+      }
+      if (text[i] === ">") {
+        i++;
+        break;
+      }
+      if (i >= text.length) fail(VERBOSE ? `<${el.name}> is not closed` : "", at);
+      if (i === before) fail(VERBOSE ? "expected whitespace before the attribute" : "");
+      const aAt = i;
+      const aName = name();
+      ws();
+      if (text[i] !== "=") fail(VERBOSE ? `attribute "${aName}" needs a value (name="value")` : "");
+      i++;
+      ws();
+      const q = text[i];
+      if (q !== '"' && q !== "'") fail(VERBOSE ? `the value of "${aName}" must be quoted` : "");
+      const vStart = i + 1;
+      const vEnd = text.indexOf(q, vStart);
+      if (vEnd < 0) fail(VERBOSE ? `the value of "${aName}" is not closed` : "", vStart - 1);
+      el.attrs.push({
+        name: aName,
+        value: decode(text.slice(vStart, vEnd), true, (k, message) => {
+          if (message !== void 0) errors.push({ message, at: pos(vStart + k) });
+        }),
+        at: pos(aAt),
+        valueAt: pos(vStart)
+      });
+      i = vEnd + 1;
+    }
+    for (; ; ) {
+      if (i >= text.length) fail(VERBOSE ? `<${el.name}> is not closed` : "", at);
+      if (text.startsWith("</", i)) {
+        const closeAt = i;
+        i += 2;
+        const n = name();
+        ws();
+        if (text[i] !== ">") fail(VERBOSE ? `expected > after </${n}` : "");
+        i++;
+        if (n !== el.name)
+          fail(
+            VERBOSE ? `</${n}> closes <${el.name}> (opened at line ${el.at.line})` : "",
+            closeAt
+          );
+        return el;
+      }
+      if (text.startsWith("<!--", i)) {
+        el.children.push(comment());
+        continue;
+      }
+      if (text[i] === "<") {
+        special();
+        el.children.push(element(depth + 1));
+        continue;
+      }
+      const tAt = i;
+      let end = text.indexOf("<", i);
+      if (end < 0) end = text.length;
+      const raw = text.slice(i, end);
+      const value = decode(
+        raw,
+        false,
+        (k, message) => errors.push({
+          message: VERBOSE ? message ?? "a bare & in text must be written &amp;" : "",
+          at: pos(tAt + k)
+        })
+      );
+      el.children.push({ kind: "text", value, raw, at: pos(tAt) });
+      i = end;
+    }
+  };
+  try {
+    const bad = NOT_CHAR.exec(text);
+    if (bad) fail(VERBOSE ? "this character is not allowed in XML" : "", bad.index);
+    if (text.charCodeAt(0) === 65279) i = 1;
+    if (text.startsWith("<?xml", i)) {
+      const end = text.indexOf("?>", i);
+      if (end < 0) fail(VERBOSE ? "the <?xml declaration is not closed" : "");
+      i = end + 2;
+    }
+    for (; ; ) {
+      ws();
+      if (i >= text.length) break;
+      if (text.startsWith("<!--", i)) {
+        outer.push(comment());
+        continue;
+      }
+      if (text[i] !== "<")
+        fail(
+          VERBOSE ? doc.root ? "text after the root element" : "expected the <anima> root element" : ""
+        );
+      special();
+      if (doc.root) fail(VERBOSE ? "only one root element is allowed" : "");
+      doc.root = element(0);
+    }
+    if (!doc.root) fail(VERBOSE ? "the document is empty: expected <anima \u2026>" : "");
+  } catch (e) {
+    if (!(e instanceof Stop)) throw e;
+    doc.root = null;
+  }
+  if (errors.length) doc.root = null;
+  return { doc, errors };
+}
+const xmlChars = (s) => s.replace(new RegExp(NOT_CHAR, "g"), "\uFFFD");
+const escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+const escapeText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+export {
+  NOT_CHAR,
+  escapeAttr,
+  escapeText,
+  parseXml,
+  xmlChars
+};

package/packages/playground/src/app.d.ts

@@ -0,0 +1,3 @@
+import 'animl/web/components';
+import 'animl/web/bind';
+import 'animl/web/paint';