@moku-labs/game 0.15.11 → 0.15.13

package/dist/{types-D5Pmo8BD.d.mts → types-xmH1X8qd.d.mts}

@@ -2791,6 +2791,14 @@ type JsxState = {
   fields: Map<Entity, Field>;
   text: TextState;
   hints: Hint[];
+  /**
+   * The elements whose `Box` came since the last `sync`: their enter hooks play there, after the game's systems
+   * (F48). The first `count` slots are the queue; the array keeps its length, so a frame allocates nothing.
+   */
+  entering: {
+    list: Entity[];
+    count: number;
+  };
   scrolls: Set<Entity>;
   windowRenders: number; /** True from a restore or a load until the next reconcile built every root again. */
   remount: boolean;

package/dist/{visual-Dwfy9wDb.mjs → visual-CbGKzlj0.mjs}

@@ -1,3 +1,4 @@
+import { t as defineComponent } from "./component-DGg5DqKK.mjs";
 //#region src/plugins/world/ecs/define.ts
 /**
 * Declares a component type. The defaults give the TypeScript type, the JSON shape and the
@@ -369,6 +370,250 @@ function componentsFor() {
 		HudPart
 	};
 }
+//#endregion
+//#region src/plugins/renderer/sync/pose.ts
+/**
+* @file renderer/sync — the pose helpers: where an entity really is, in root (reference) space,
+* and the local pose that puts it there under a parent. Pure component math over `world.ecs.get`,
+* the same math the renderer draws with: `position` is where the `pivot` lands, and the pivot is
+* the local point the view turns and scales around.
+*
+* Engine-internal, not a root export. `input`, `anim` and `ui` import `rootPoseOf` and
+* `localPoseOf` from this module path (`../renderer/sync/pose`) and never walk the `Parent` chain
+* themselves; a per-frame reader (`effects`' following emitters) writes the root pose into its own
+* object with `rootPoseInto`, which allocates nothing; `input` places a carried view under the last pose of a despawned held view with
+* `poseUnder`; `sync` places a box with `rootPointOf`. `input` places the drop lookup of an aimed
+* view with `applyPose`.
+*/
+/** How deep a parent chain is followed; deeper is treated as a loop. */
+const MAX_DEPTH = 32;
+/**
+* The parent an entity moves with.
+*
+* @param ecs - The world read.
+* @param entity - The entity.
+* @returns The parent entity, or `0` when it has none or names itself.
+*/
+function parentOf(ecs, entity) {
+	const parent = ecs.get(entity, Parent)?.entity ?? 0;
+	return parent === entity ? 0 : parent;
+}
+/**
+* Tells whether an entity is on its way out: it or an ancestor of its `Parent` chain carries `Exiting` (a ui element
+* whose exit plays, a world view in its exit queue). Its despawn is coming; nothing else of the teardown is owed.
+*
+* @param ecs - The world read.
+* @param entity - The entity.
+* @returns True while it, or what it hangs under, leaves.
+*/
+function isLeaving(ecs, entity) {
+	let current = entity;
+	for (let depth = 0; depth < MAX_DEPTH && current !== 0; depth += 1) {
+		if (ecs.has(current, Exiting)) return true;
+		current = parentOf(ecs, current);
+	}
+	return false;
+}
+/**
+* A fresh copy of a pose, so a caller may change what it got without touching the world.
+*
+* @param pose - The pose to copy.
+* @returns The same numbers in new objects.
+* @example
+* ```ts
+* copyPose({ x: 1, y: 2, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }).pivot.x; // 0
+* ```
+*/
+function copyPose(pose) {
+	return {
+		x: pose.x,
+		y: pose.y,
+		rotation: pose.rotation,
+		scale: pose.scale,
+		pivot: {
+			x: pose.pivot.x,
+			y: pose.pivot.y
+		}
+	};
+}
+/**
+* Moves a point out of the local space of a pose, into the space the pose sits in.
+*
+* @param pose - The pose whose local space the point is in.
+* @param point - The local point.
+* @returns The point one space higher.
+* @example
+* ```ts
+* applyPose({ x: 10, y: 0, rotation: 0, scale: 2, pivot: { x: 5, y: 0 } }, { x: 5, y: 1 });
+* // { x: 10, y: 2 }
+* ```
+*/
+function applyPose(pose, point) {
+	const cos = Math.cos(pose.rotation);
+	const sin = Math.sin(pose.rotation);
+	const dx = point.x - pose.pivot.x;
+	const dy = point.y - pose.pivot.y;
+	return {
+		x: pose.x + pose.scale * (dx * cos - dy * sin),
+		y: pose.y + pose.scale * (dx * sin + dy * cos)
+	};
+}
+/**
+* Places a local pose under a parent pose: the pose in the space the parent sits in. The step
+* `rootPoseOf` takes once per parent: the position through the parent's pivot, rotation, scale
+* and position, the rotations added and the scales multiplied.
+*
+* @param above - The parent pose.
+* @param local - The pose under it.
+* @returns The composed pose; it keeps the local pivot.
+* @example
+* ```ts
+* poseUnder(
+*   { x: 400, y: 300, rotation: 0, scale: 2, pivot: { x: 0, y: 0 } },
+*   { x: 0, y: 30, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+* ); // { x: 400, y: 360, rotation: 0, scale: 2, pivot: { x: 0, y: 0 } }
+* ```
+*/
+function poseUnder(above, local) {
+	const landed = applyPose(above, local);
+	return {
+		x: landed.x,
+		y: landed.y,
+		rotation: local.rotation + above.rotation,
+		scale: local.scale * above.scale,
+		pivot: {
+			x: local.pivot.x,
+			y: local.pivot.y
+		}
+	};
+}
+/**
+* Where an entity really is, written into the caller's pose: its `Transform` composed through the `Parent` chain,
+* every pivot on the way applied, the numbers of `rootPoseOf` (the same steps in the same order). The answer keeps the
+* entity's own pivot. Allocates nothing: a reader that asks every frame passes the same object.
+*
+* @param ecs - The world read, `world.ecs`.
+* @param entity - The entity to place.
+* @param out - The pose to write, its `pivot` object included; it may be `own`.
+* @param own - A pose to use in place of the entity's own `Transform`, such as its rest pose.
+* @returns `out`, in root space. An entity without a `Transform` sits at the identity pose.
+* @example
+* ```ts
+* // `effects` follows a host every frame: the slot sits at (40, 60) scaled 0.5, the host at (100, 200) inside it.
+* const pose = { x: 0, y: 0, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } };
+* rootPoseInto(ctx.require(worldPlugin).ecs, host, pose);
+* // pose is { x: 90, y: 160, rotation: 0, scale: 0.5, pivot: { x: 0, y: 0 } }
+* ```
+*/
+function rootPoseInto(ecs, entity, out, own) {
+	const start = own ?? ecs.get(entity, Transform) ?? Transform.defaults;
+	out.x = start.x;
+	out.y = start.y;
+	out.rotation = start.rotation;
+	out.scale = start.scale;
+	out.pivot.x = start.pivot.x;
+	out.pivot.y = start.pivot.y;
+	let current = entity;
+	for (let depth = 0; depth < MAX_DEPTH; depth += 1) {
+		const parent = parentOf(ecs, current);
+		if (parent === 0) break;
+		const above = ecs.get(parent, Transform) ?? Transform.defaults;
+		const cos = Math.cos(above.rotation);
+		const sin = Math.sin(above.rotation);
+		const dx = out.x - above.pivot.x;
+		const dy = out.y - above.pivot.y;
+		out.x = above.x + above.scale * (dx * cos - dy * sin);
+		out.y = above.y + above.scale * (dx * sin + dy * cos);
+		out.rotation = out.rotation + above.rotation;
+		out.scale = out.scale * above.scale;
+		current = parent;
+	}
+	return out;
+}
+/**
+* Where an entity really is: its `Transform` composed through the `Parent` chain, every pivot on
+* the way applied. The answer keeps the entity's own pivot, so it can be written straight into the
+* `Transform` of an entity without a parent and the view does not move.
+*
+* @param ecs - The world read, `world.ecs`.
+* @param entity - The entity to place.
+* @param own - A pose to use in place of the entity's own `Transform`, such as its rest pose.
+* @returns The pose in root space, a fresh object. An entity without a `Transform` sits at the identity pose.
+* @example
+* ```ts
+* // `input` lifts a board cell out of its slot: the slot sits at (40, 60) scaled 0.5,
+* // the cell at (100, 200) inside it.
+* rootPoseOf(ctx.require(worldPlugin).ecs, cell);
+* // { x: 90, y: 160, rotation: 0, scale: 0.5, pivot: { x: 0, y: 0 } }
+* ```
+*/
+function rootPoseOf(ecs, entity, own) {
+	return rootPoseInto(ecs, entity, {
+		x: 0,
+		y: 0,
+		rotation: 0,
+		scale: 1,
+		pivot: {
+			x: 0,
+			y: 0
+		}
+	}, own);
+}
+/**
+* The inverse of `rootPoseOf`: the local pose under `parent` that puts an entity at a root pose.
+* The pivot is kept, as it is a local point of the entity itself.
+*
+* @param ecs - The world read, `world.ecs`.
+* @param parent - The entity to hang under; `0` for none, which answers the root pose itself.
+* @param root - The pose in root space.
+* @returns The local pose. A parent collapsed to scale 0 counts as scale 1, so the answer stays
+*   finite.
+* @example
+* ```ts
+* // `input` drops the cell back into the slot at (40, 60) scaled 0.5, where the finger left it.
+* localPoseOf(ctx.require(worldPlugin).ecs, slot, {
+*   x: 90, y: 160, rotation: 0, scale: 0.5, pivot: { x: 0, y: 0 }
+* });
+* // { x: 100, y: 200, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+* ```
+*/
+function localPoseOf(ecs, parent, root) {
+	if (parent === 0) return copyPose(root);
+	const above = rootPoseOf(ecs, parent);
+	const scale = above.scale === 0 ? 1 : above.scale;
+	const cos = Math.cos(-above.rotation);
+	const sin = Math.sin(-above.rotation);
+	const dx = root.x - above.x;
+	const dy = root.y - above.y;
+	return {
+		x: above.pivot.x + (dx * cos - dy * sin) / scale,
+		y: above.pivot.y + (dx * sin + dy * cos) / scale,
+		rotation: root.rotation - above.rotation,
+		scale: root.scale / scale,
+		pivot: {
+			x: root.pivot.x,
+			y: root.pivot.y
+		}
+	};
+}
+/**
+* Where a local point of an entity lands in root (reference) space: the point posed through the
+* entity's own `Transform` and its whole `Parent` chain, the forward walk of the hit test's
+* `localPoseOf`. The scale is the real one, so a view collapsed to scale 0 lands on one point.
+*
+* @param ecs - The world read, `world.ecs`.
+* @param entity - The entity whose local space the point is in.
+* @param point - The local point.
+* @returns The point in root space, a fresh object.
+* @example
+* ```ts
+* // The corner of a 64 x 64 cell at (100, 200) inside a slot at (40, 60) scaled 0.5.
+* rootPointOf(ctx.require(worldPlugin).ecs, cell, { x: -32, y: -32 }); // { x: 74, y: 144 }
+* ```
+*/
+function rootPointOf(ecs, entity, point) {
+	return applyPose(rootPoseOf(ecs, entity), point);
+}
 /**
 * Words on the screen: a string or a message, the style it is drawn in, and the string `text`
 * resolved out of it. A game writes `content`, `style`, `bind`, `anchor` and `alpha`; `resolved`
@@ -666,6 +911,204 @@ function textFor() {
 	};
 }
 //#endregion
+//#region src/plugins/ui/styles/define.ts
+/**
+* Declares one style. The work is the type: a field outside the vocabulary, or a value outside
+* its union, is an error where the style is written, not where it is used.
+*
+* @param style - The style, with its `is` and `when` variants.
+* @returns The same object, frozen.
+* @example
+* ```ts
+* defineStyle({ direction: "row", gap: 12 }).gap; // 12
+* ```
+*/
+function defineStyle(style) {
+	return Object.freeze(style);
+}
+//#endregion
+//#region src/plugins/ui/styles/tokens.ts
+/**
+* Declares the design tokens of a game: spaces, colours, radii and font keys, flat and plain.
+*
+* @param tokens - The four groups; every key inside them is the game's own.
+* @returns The same object, frozen.
+* @example
+* ```ts
+* defineTokens({ space: { md: 16 } }).space.md; // 16
+* ```
+*/
+function defineTokens(tokens) {
+	return Object.freeze(tokens);
+}
+//#endregion
+//#region src/plugins/ui/components.ts
+/**
+* Who owns every entity `ui` spawns. The projection module checks it before it hands out a view
+* handle, so only `ui` may move a ui element.
+*/
+const UI_OWNER = {
+	kind: "plugin",
+	name: "ui"
+};
+/** Fresh defaults for the patch, so no two buttons share one object. */
+const localWriteDefaults = { patch: {} };
+/**
+* The rect of a ui element in root coordinates. Written by the solve, read by `tree()`, `lint()`
+* and the hit test of `guide`.
+*/
+const Box = /*#__PURE__*/ component("Box", {
+	x: 0,
+	y: 0,
+	w: 0,
+	h: 0
+});
+/**
+* On a button that writes local state instead of naming an intent. `input.onTap` reports the tap
+* and `ui` merges the patch into the nearest component instance.
+*/
+const LocalWrite = /*#__PURE__*/ component("LocalWrite", localWriteDefaults);
+/**
+* On a scroll container. Internal to `ui`: not exported from the package root.
+*/
+const Scroll = /*#__PURE__*/ component("Scroll", {
+	axis: "y",
+	offset: 0,
+	min: 0
+});
+/**
+* On every scroll container: where it stands and whether it moves, for a game system and the
+* read door. `ui` writes it in a frame where the offset or `max` changed, and once more with
+* `moving: false` when it stops; a game reads it and never writes it.
+*
+* @example
+* ```ts
+* // A board system dims the events of the order strip while it rests on the orders.
+* export const stripMist = system({
+*   name: "board.stripMist",
+*   phase: "animate",
+*   query: [ScrollState, OrderStrip],
+*   run: entities => {
+*     for (const [entity, scroll] of entities) {
+*       // scroll: { offset: 318, max: 390, moving: false }
+*     }
+*   }
+* });
+* ```
+*/
+const ScrollState = /*#__PURE__*/ component("ScrollState", {
+	offset: 0,
+	max: 0,
+	moving: false
+});
+/**
+* On the root entity of a popup kept beneath another popup (`popup(..., { over })`). Internal to
+* `ui`: not exported from the package root. Every element of that root resolves `is.covered`.
+*/
+const Covered = /*#__PURE__*/ tag("Covered");
+/**
+* On a button with the `escape` prop: the control the Escape key taps while its root is the top
+* one, meant for the close button or the backdrop of a dismissable popup. Internal to `ui`: the
+* game writes the prop, never the tag.
+*/
+const Escapable = /*#__PURE__*/ tag("Escapable");
+/**
+* On the view a player taps five times within three seconds to open the editor's overlay on a debug build: the
+* version line of the settings, usually. One helper on top of `app.debug.overlay.open()`; a game that wants another
+* gesture calls that itself. The view must take a press (a `button`, or any element with `Touchable`); a `button`
+* that names no intent is the plain choice. Without the agent flag the tag does nothing.
+*
+* @example
+* ```tsx
+* // The version line of the settings sheet. Five taps open the overlay of `moku-game build --debug` on the phone.
+* <button key="versionLine" style={versionLineStyle} components={[DebugTrigger()]}>
+*   <text key="version" style="settings.version" content={tr("settings.version", { version: "1.4.0" })} />
+* </button>
+* ```
+*/
+const DebugTrigger = /*#__PURE__*/ tag("DebugTrigger");
+/**
+* The three Yoga counters, the reconcile count of the frame, the range re-renders of the windowed
+* lists, and the style and write passes of the reconcile. Written by the two systems of `ui`, read
+* by the acceptance tests. Not part of `app.ui`.
+*/
+const UiCounters = /*#__PURE__*/ resource("UiCounters", {
+	solves: 0,
+	nodes: 0,
+	measured: 0,
+	reconciles: 0,
+	windowRenders: 0,
+	styled: 0,
+	written: 0
+});
+/**
+* Builds the effect a node awaits to show a popup. The gate opens for the outcomes of the
+* component, so the node resolves with the intent one of its buttons answered. `over` names the
+* component of a popup that stays mounted beneath this one, drawn covered, until this one is gone.
+*
+* @param component - A component declared with `outcomes`.
+* @param props - What its view is called with.
+* @param options - How the popup stands to the others.
+* @param options.over - The component name of the popup kept beneath this one.
+* @returns The descriptor `fx()` takes.
+* @example
+* ```ts
+* const Reward = defineComponent("Reward", {
+*   outcomes: { claim: {} },
+*   view: () => ({ type: "panel", props: {}, children: [] })
+* });
+* popup(Reward, { gold: 5 });
+* // { kind: "popup", payload: { component: "Reward", props: { gold: 5 } }, answers: ["claim"] }
+* await fx(popup(Reward, { gold: 5 })); // Answer<"claim">: { intent: "claim" }
+* ```
+* @example
+* ```ts
+* // The settings node asks before a reset; the settings stay beneath, covered.
+* const Confirm = defineComponent("Confirm", {
+*   outcomes: { reset: {}, cancel: {} },
+*   view: () => ({ type: "panel", props: {}, children: [] })
+* });
+* popup(Confirm, {}, { over: "Settings" });
+* // { kind: "popup", payload: { component: "Confirm", props: {}, over: "Settings" },
+* //   answers: ["reset", "cancel"] }
+* ```
+*/
+function popup(component, props, options) {
+	const over = options?.over;
+	return {
+		kind: "popup",
+		payload: over === void 0 ? {
+			component: component.name,
+			props
+		} : {
+			component: component.name,
+			props,
+			over
+		},
+		answers: Object.keys(component.outcomes)
+	};
+}
+/**
+* Binds the four ui helpers to one game. Type-only: the same four functions, plus the intrinsic
+* table this game's tags are checked against.
+*
+* @returns The helpers and the intrinsic type carrier.
+* @example
+* ```ts
+* const { defineStyle } = uiFor<"ui.coin", "digits", "hud.coins">();
+* defineStyle({ gap: 8 }).gap; // 8
+* ```
+*/
+function uiFor() {
+	return {
+		defineComponent,
+		defineStyle,
+		defineTokens,
+		popup,
+		intrinsics: {}
+	};
+}
+//#endregion
 //#region src/plugins/ui/visual.ts
 /**
 * @file ui plugin — the look of an element: the visual component it is drawn with, and where a
@@ -919,4 +1362,4 @@ function drawnRect(pose, local) {
 	};
 }
 //#endregion
-export { Now as A, Sprite as C, sprite as D, componentsFor as E, resource as F, system as I, systemsFor as L, Tree as M, component as N, Exiting as O, mut as P, tag as R, Shape as S, arcDefaults as T, HudPart as _, scaleByFits as a, OverlayLevel as b, Countdown as c, builtInStyles as d, defineTextStyles as f, Display as g, textFor as h, samePose as i, Order as j, Layer as k, Text as l, readStyle as m, drawnRect as n, visualOf as o, label as p, fitScaleOf as r, visualRectOf as s, CONTENT as t, bind as u, NineSlice as v, Transform as w, Parent as x, Overlay as y };
+export { component as $, localPoseOf as A, OverlayLevel as B, builtInStyles as C, textFor as D, readStyle as E, rootPoseOf as F, arcDefaults as G, Shape as H, Display as I, Exiting as J, componentsFor as K, HudPart as L, poseUnder as M, rootPointOf as N, applyPose as O, rootPoseInto as P, Tree as Q, NineSlice as R, bind as S, label as T, Sprite as U, Parent as V, Transform as W, Now as X, Layer as Y, Order as Z, uiFor as _, visualOf as a, Countdown as b, Covered as c, LocalWrite as d, mut as et, Scroll as f, popup as g, UiCounters as h, samePose as i, tag as it, parentOf as j, isLeaving as k, DebugTrigger as l, UI_OWNER as m, drawnRect as n, system as nt, visualRectOf as o, ScrollState as p, sprite as q, fitScaleOf as r, systemsFor as rt, Box as s, CONTENT as t, resource as tt, Escapable as u, defineTokens as v, defineTextStyles as w, Text as x, defineStyle as y, Overlay as z };

package/dist/{visual-B5Sypqal.d.mts → visual-DExHHx-a.d.mts}

@@ -1,9 +1,9 @@
 import { $t as Api$1, K as Api, Rr as Api$3, xr as Api$2 } from "./types-CuEK0Vam.mjs";
-import { P as AnimApi, r as UiApi } from "./types-CpBnGqDU.mjs";
-import { M as InputApi } from "./types-D5Pmo8BD.mjs";
+import { P as AnimApi, r as UiApi } from "./types-3bEK86Z1.mjs";
+import { M as InputApi } from "./types-xmH1X8qd.mjs";
 import { r as Repro } from "./headless-DHtavbqk.mjs";
 import { a as InputOf, r as ControlApp } from "./types-_a6-ALzz.mjs";
-import { t as commands } from "./commands-C3yVtCg1.mjs";
+import { t as commands } from "./commands-aLTGwuyk.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/visual.d.mts

@@ -1,2 +1,2 @@
-import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-B5Sypqal.mjs";
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-DExHHx-a.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/dist/visual.mjs

@@ -1,4 +1,4 @@
-import { n as read, t as sources } from "./sources-CJgUypyC.mjs";
+import { n as read, t as sources } from "./sources-Fbq_PFVH.mjs";
 import { n as commands, t as run } from "./run-BqYmcNo7.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.15.11",
+  "version": "0.15.13",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": [