animl 0.0.0-stage → 0.1.0

package/modules/input/core/index.js

@@ -0,0 +1,159 @@
+import { registerEventKinds } from "../../components/core/events.js";
+import { after } from "../manifest.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { extendListener, nodeShapes, soloShape } from "./registry.js";
+import { install, configurations } from "./runtime.js";
+import { events, fields } from "./types.js";
+import { listenerValue } from "./values.js";
+export * from "./runtime.js";
+export * from "./types.js";
+const input = {
+  listenerValue,
+  name: "input",
+  after,
+  draw: {
+    tree(model, tree) {
+      for (let i = 0; i < model.nodes.length; i++) {
+        const deps = new Set(tree.nodes[i].dependencies ?? [i]);
+        for (let n = model.nodes[i].parent; n >= 0; n = model.nodes[n].parent) deps.add(n);
+        tree.nodes[i].dependencies = [...deps];
+      }
+    },
+    frame(player, node, data) {
+      data.visible = player.visible(node);
+    }
+  },
+  entries: [
+    {
+      target: "node",
+      shapes: nodeShapes,
+      props: {
+        pointerEnabled: { type: "bool", def: true },
+        collapsed: { type: "bool", def: false }
+      }
+    },
+    { target: "group", shapes: { solo: soloShape }, props: { solo: { type: "number", def: -1 } } }
+  ],
+  init(_modules, shared) {
+    install(shared.Player, _modules);
+    registerEventKinds(_modules, "input", events);
+    const listeners = shared.DOC.p.listeners;
+    return {
+      ...input,
+      init: void 0,
+      entries: [
+        ...input.entries,
+        {
+          target: "document",
+          shapes: {
+            listeners: { ...listeners, feature: "", of: extendListener(listeners.of) }
+          }
+        }
+      ]
+    };
+  },
+  resolve(model) {
+    if (!model.doc.requires?.includes("input")) return;
+    for (const r of model.doc.listeners ?? []) {
+      if (typeof r.write === "string") {
+        r.write = { [r.value ?? ""]: r.write };
+        delete r.value;
+      }
+      if (r.write && !["set", "fire", "toggle", "emit"].some((key) => key in r)) r.set = {};
+    }
+  },
+  load(model, raw, diag) {
+    const enabled = raw.requires?.includes("input");
+    const result = [];
+    const error = (code, p, m, h) => diag.err(code, p, V && m, V && h);
+    for (const [i, r] of (raw.listeners ?? []).entries()) {
+      const on = r.on.split("|");
+      if (!enabled) {
+        if (on.length > 1 || on.some(
+          (x) => events.includes(x) && !["enter", "leave", "move", "down", "up", "click"].includes(x)
+        ))
+          error(
+            "undeclared-feature",
+            `/listeners/${i}/on`,
+            "extended listeners require input",
+            'add "input" to requires'
+          );
+        continue;
+      }
+      const p = `/listeners/${i}`;
+      for (const key of ["button", "index", "control"])
+        if (r[key] !== void 0 && !Number.isInteger(r[key]))
+          error(
+            "input-index",
+            p + "/" + key,
+            "indices must be whole numbers",
+            "use a nonnegative integer"
+          );
+      if (r.button !== void 0 && r.button > 2)
+        error(
+          "input-index",
+          p + "/button",
+          "unsupported pointer button",
+          "use 0 (primary), 1 (middle), or 2 (secondary)"
+        );
+      if (r.modifiers !== void 0 && !/^(?:shift\+)?(?:control\+)?(?:alt\+)?(?:meta\+)?$/.test(
+        r.modifiers ? r.modifiers + "+" : ""
+      ))
+        error(
+          "input-modifiers",
+          p + "/modifiers",
+          "invalid exact modifier set",
+          "use shift+control+alt+meta in that order, omitting unheld keys"
+        );
+      for (const [field, name] of Object.entries(r.write ?? {})) {
+        if (!fields.includes(field))
+          error(
+            "input-write",
+            p + "/write/" + field,
+            "unknown event value",
+            "use a documented input event field (pointer coordinates need number; key-pressed needs string)"
+          );
+        if (field === "text-index" && String(model.nodes[model.ids.get(r.target ?? "") ?? -1]?.type) !== "text")
+          error(
+            "input-write",
+            p + "/write/" + field,
+            "text-index needs a text target",
+            "set target to a text node"
+          );
+        const input2 = model.inputs.get(name), type = field === "key-pressed" ? "string" : field === "pressed" ? "bool" : "number";
+        if (!input2 || input2.type !== type || input2.readonly)
+          error(
+            "input-write",
+            p + "/write/" + field,
+            `event value needs a ${type} input`,
+            `declare ${name} as ${type}`
+          );
+      }
+      const action = model.listeners[i];
+      let depth = 0;
+      for (let n = action.target; n >= 0; n = model.nodes[n].parent) depth++;
+      result.push({ ...r, on, action, target: action.target, order: i, depth });
+    }
+    if (enabled) {
+      configurations.set(model.inputs, result);
+      const written = new Set(result.flatMap((l) => Object.values(l.write ?? {})));
+      for (let i = diag.list.length - 1; i >= 0; i--)
+        if (diag.list[i].code === "unused-input" && written.has(diag.list[i].pointer.slice("/inputs/".length)))
+          diag.list.splice(i, 1);
+    }
+    const walk = (nodes, base) => nodes.forEach((n, i) => {
+      if (n.solo !== void 0 && (!Number.isInteger(n.solo) || n.solo >= (n.children?.length ?? 0)))
+        error(
+          "input-solo",
+          `${base}/${i}/solo`,
+          "solo index is outside direct children",
+          "use -1 for no selected child or an existing zero-based child index"
+        );
+      if (n.children) walk(n.children, `${base}/${i}/children`);
+    });
+    if (enabled) walk(raw.nodes, "/nodes");
+  }
+};
+export {
+  input
+};

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

@@ -0,0 +1,5 @@
+import type { Shape, ObjShape } from '../../../packages/core/src/registry.js';
+export declare const listenerFields: Record<string, Shape>;
+export declare function extendListener(listener: ObjShape): ObjShape;
+export declare const nodeShapes: Record<string, Shape>;
+export declare const soloShape: Shape;

package/modules/input/core/registry.js

@@ -0,0 +1,59 @@
+import { cursors, events, fields } from "./types.js";
+const num = (min) => ({ k: "num", ...min === void 0 ? {} : { min } });
+const str = (en) => ({ k: "str", ...en ? { of: [...en] } : {} });
+const listenerFields = {
+  button: num(0),
+  capture: { k: "bool" },
+  consume: { k: "bool" },
+  propagate: { k: "bool" },
+  key: str(),
+  modifiers: str(),
+  index: num(0),
+  control: num(0),
+  mapping: str(["standard", "raw"]),
+  phase: str(["press", "release", "both"]),
+  value: str(),
+  write: {
+    k: "alt",
+    description: `Map event field \u2192 declared input name (not an expression). Available event fields: ${fields.map((f) => f + (f === "key-pressed" ? " (string)" : f === "pressed" ? " (bool)" : " (number)")).join(", ")}. Missing fields leave inputs unchanged. x/y use target parent coordinates; align="preserve" retains the grab offset. Example: write='{"x":"dragX"}'.`,
+    of: [
+      str(),
+      {
+        k: "map",
+        of: str(),
+        key: /^[a-z][a-zA-Z0-9-]*$/
+      }
+    ]
+  },
+  align: str(["preserve", "snap"])
+};
+function extendListener(listener) {
+  const old = listener.p.on;
+  const pattern = `^(?:${events.join("|")})(?:\\|(?:${events.join("|")}))*$`;
+  return {
+    ...listener,
+    p: {
+      ...listener.p,
+      on: {
+        k: "str",
+        re: new RegExp(`(?:${old.re?.source ?? `^(?:${old.of.join("|")})$`})|(?:${pattern})`)
+      },
+      ...Object.fromEntries(
+        Object.entries(listenerFields).map(([k, v]) => [k, { ...v, feature: "input" }])
+      )
+    }
+  };
+}
+const nodeShapes = {
+  pointerEnabled: { k: "bool" },
+  opaque: { k: "bool" },
+  cursor: str(cursors),
+  collapsed: { k: "bool" }
+};
+const soloShape = num(-1);
+export {
+  extendListener,
+  listenerFields,
+  nodeShapes,
+  soloShape
+};

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

@@ -0,0 +1,65 @@
+import type { Player } from '../../../packages/core/src/player.js';
+import type { Cursor, GamepadRecord, InputListener, KeyOptions, PointerEventKind, PointerOptions, ScrollOptions } from './types.js';
+export declare const configurations: WeakMap<Map<string, import("../../../packages/core/src/load.js").InputM>, InputListener[]>;
+declare let peers: ReadonlyMap<string, import('../../../packages/core/src/modules.js').Module>;
+interface Contact {
+    x: number;
+    y: number;
+    startX: number;
+    startY: number;
+    button: number;
+    over: Set<number>;
+    pressed: Set<number>;
+    drag: boolean;
+    moved: number;
+    origins: Map<number, [number, number]>;
+}
+export interface HitOptions {
+    bounded?: boolean;
+    scroll?: boolean;
+}
+export declare class InputController {
+    enabled: boolean;
+    /** Optional focus-module target; explicit key options take precedence. */
+    keyTarget?: string;
+    readonly contacts: Map<number, Contact>;
+    readonly disabled: Set<number>;
+    readonly pads: Map<number, GamepadRecord>;
+    private latch?;
+    readonly player: Player;
+    constructor(player: Player);
+    get listeners(): InputListener[];
+    private eligible;
+    private ancestor;
+    private hits;
+    private rank;
+    private foremost;
+    /** Hit targets foremost first; an opaque target keeps its ancestor chain. */
+    targets(x: number, y: number, options?: HitOptions): Set<number>;
+    hitTest(x: number, y: number, options?: HitOptions): string[];
+    occludes(x: number, y: number, options?: HitOptions): boolean;
+    get cursor(): Cursor | undefined;
+    private dispatch;
+    private deliver;
+    private children;
+    private route;
+    pointer(kind: PointerEventKind, x?: number, y?: number, opts?: PointerOptions): boolean;
+    enablePointer(id: number, enabled: boolean): void;
+    cancel(): void;
+    key(kind: 'down' | 'up', key: string, opts?: KeyOptions): boolean;
+    private dispatchKey;
+    scroll(x: number, y: number, deltaX: number, deltaY: number, opts?: ScrollOptions): boolean;
+    wantsScroll(x: number, y: number, time?: number): boolean;
+    cancelScroll(): void;
+    gamepads(batch: readonly GamepadRecord[]): void;
+}
+export interface InputAPI {
+    input(): InputController;
+}
+declare module '../../../packages/core/src/player.ts' {
+    interface Player {
+        input(): InputController;
+    }
+}
+export declare function install(Class: typeof Player, modules: typeof peers): void;
+export {};