@moku-labs/game 0.2.0 → 0.3.0

package/dist/{types-CqkrEY06.d.mts → types-CVUHPvMB.d.mts}

@@ -1,439 +1,9 @@
-import { A as TrackSegment, At as Json, E as NumericFields, F as ComponentHandle, I as ComponentType, M as AnyComponent, P as AnyComponentValue, R as Entity, St as Api, T as MotionHandle, _t as TypeTag, h as Api$2, k as TrackOptions, nn as Require, q as Api$1, t as Api$3, x as Ease } from "./types-BZ1OLf24.mjs";
-import { o as Events$1, t as Api$4 } from "./types-C47fKNcn.mjs";
-import { F as Events$2, H as InputApi, I as I18nApi, L as Message, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-X9jXjka3.mjs";
+import { $ as Ease, I as AnyComponentValue, Kt as Json, L as ComponentHandle, Nt as TypeTag, P as AnyComponent, Rt as Api, V as Entity, ct as TrackSegment, it as NumericFields, k as Api$2, m as Api$3, rt as MotionHandle, st as TrackOptions, ut as Api$1, vn as Require, z as ComponentType } from "./types-Dy1xB68L.mjs";
+import { D as TextApi, H as InputApi, I as I18nApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-VErbiEXy.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
 
-//#region src/plugins/text/types.d.ts
-declare namespace types_d_exports$2 {
-  export { AdvanceTable, BundleLoaded, BundleUnloaded, Config$2 as Config, Deps$2 as Deps, DrawnLabel, IconRun, KernelSlice$2 as KernelSlice, LayoutOptions, Line, LocaleChanged, Point, Run, SeenText, Size, State$2 as State, TextAlign, TextApi, TextBind, TextCtx, TextLayout, TextRun, TextShadow, TextStyle, TextStyleInput, TextStyles, TextValue, TextWrap, Warn };
-}
-/**
- * A point in reference units: where a label sits, and which point of the block sits there.
- *
- * @example
- * ```ts
- * const anchor: Point = { x: 0.5, y: 0.5 };
- * ```
- */
-type Point = {
-  x: number;
-  y: number;
-};
-/**
- * The size of a measured block, in reference pixels.
- *
- * @example
- * ```ts
- * const size: Size = { width: 57.6, height: 38.4 };
- * ```
- */
-type Size = {
-  width: number;
-  height: number;
-};
-/**
- * Which numeric component field a label shows. The component is named, not imported: a HUD is
- * written before the game's components are in scope.
- *
- * @example
- * ```ts
- * const bind: TextBind = { component: "Counter", field: "value" };
- * ```
- */
-type TextBind = {
-  component: string;
-  field: string;
-};
-/**
- * What the `Text` component holds. `resolved` is engine-owned: a game writes `content`, `style`,
- * `bind`, `anchor` and `alpha`, and reads `resolved`. `alpha` fades every run, shadow and icon of
- * the block together, 1 by default; a change is written in place and a tween can drive it.
- *
- * @example
- * ```ts
- * const value: TextValue = {
- *   content: "+5", style: "body", bind: undefined, anchor: { x: 0.5, y: 0.5 }, alpha: 1,
- *   resolved: "+5"
- * };
- * // The hint of an empty name field, at half alpha.
- * const hint: TextValue = { ...value, content: "Your name", alpha: 0.5, resolved: "Your name" };
- * ```
- */
-type TextValue = {
-  content: string | Message;
-  style: string;
-  bind: TextBind | undefined;
-  anchor: Point;
-  alpha: number;
-  resolved: string;
-};
-/**
- * Where the lines of a block sit inside the widest of them.
- *
- * @example
- * ```ts
- * const align: TextAlign = "center";
- * ```
- */
-type TextAlign = "left" | "center" | "right";
-/**
- * The wrap width of a style in reference pixels, or `"none"` for one line per `\n` segment.
- *
- * @example
- * ```ts
- * const wrap: TextWrap = 480;
- * ```
- */
-type TextWrap = number | "none";
-/**
- * The drop shadow of a style as the plugin stores it: a copy of every glyph run in `color`, at
- * `alpha`, moved by `dx` and `dy` reference pixels.
- *
- * @example
- * ```ts
- * const shadow: TextShadow = { color: 0x5b3a1e, dx: 0, dy: 4, alpha: 1 };
- * ```
- */
-type TextShadow = {
-  color: number;
-  dx: number;
-  dy: number;
-  alpha: number;
-};
-/**
- * One style as a game writes it: the font and the size are required, the rest has defaults.
- *
- * @example
- * ```ts
- * // A popup title: cream display glyphs over a brown shadow 4 px down.
- * const title: TextStyleInput = {
- *   font: "ui.font-display", size: 56, fill: 0xfff3d6, shadow: { color: 0x5b3a1e, dx: 0, dy: 4 }
- * };
- *
- * defineTextStyles({ "popup.title": title }).map["popup.title"]?.shadow;
- * // { color: 0x5b3a1e, dx: 0, dy: 4, alpha: 1 }
- * ```
- */
-type TextStyleInput = {
-  font: string;
-  bold?: string;
-  italic?: string;
-  size: number;
-  fill: number; /** The outline colour. Drawn only when `strokeWidth` is above 0. */
-  stroke?: number;
-  /**
-   * The outline width in reference px: 8 copies of each glyph run on a circle this wide (12 from 6
-   * on), tinted `stroke`. 0 draws none. It never changes what `measure` answers.
-   */
-  strokeWidth?: number;
-  letterSpacing?: number;
-  align?: TextAlign;
-  wrap?: TextWrap;
-  digits?: boolean;
-  /**
-   * A drop shadow under every glyph run, in reference px at the style size. `alpha` is 1 when
-   * left out. It never changes what `measure` answers.
-   */
-  shadow?: {
-    color: number;
-    dx: number;
-    dy: number;
-    alpha?: number;
-  };
-};
-/**
- * One style as the plugin stores it: every field filled, `bold` and `italic` only when the game
- * shipped those MSDF fonts, `shadow` only when the style has one.
- *
- * @example
- * ```ts
- * const style: TextStyle = {
- *   font: "ui.font-body", bold: undefined, italic: undefined, size: 32, fill: 0xffffff,
- *   stroke: 0x000000, strokeWidth: 0, letterSpacing: 0, align: "left", wrap: "none",
- *   digits: false, shadow: undefined
- * };
- * ```
- */
-type TextStyle = {
-  font: string;
-  bold: string | undefined;
-  italic: string | undefined;
-  size: number;
-  fill: number;
-  stroke: number;
-  strokeWidth: number;
-  letterSpacing: number;
-  align: TextAlign;
-  wrap: TextWrap;
-  digits: boolean;
-  shadow: TextShadow | undefined;
-};
-/**
- * What `defineTextStyles` returns and a feature registers under its `textStyles` key. Structural
- * on purpose: `flow` carries the map, `text` reads it.
- *
- * @example
- * ```ts
- * const styles: TextStyles = { kind: "textStyles", map: { "hud.title": bodyStyle } };
- * ```
- */
-type TextStyles = {
-  readonly kind: "textStyles";
-  readonly map: Record<string, TextStyle>;
-};
-/**
- * The advances of one font at the size the `.fnt` was exported with. Widths scale by
- * `style.size / size`; kerning pairs are ignored.
- *
- * @example
- * ```ts
- * const table: AdvanceTable = { size: 32, lineHeight: 40, advances: new Map([["1", 18]]) };
- * ```
- */
-type AdvanceTable = {
-  size: number;
-  lineHeight: number;
-  advances: Map<string, number>;
-};
-/**
- * One run of glyphs: the text and the flags every glyph in it shares.
- *
- * @example
- * ```ts
- * const run: TextRun = { kind: "text", text: "+5", bold: true, italic: false, color: 0xffe082 };
- * ```
- */
-type TextRun = {
-  kind: "text";
-  text: string;
-  bold: boolean;
-  italic: boolean;
-  color: number | undefined;
-};
-/**
- * One inline icon: an asset key drawn square at the line height.
- *
- * @example
- * ```ts
- * const run: IconRun = { kind: "icon", key: "hud.coin" };
- * ```
- */
-type IconRun = {
-  kind: "icon";
-  key: string;
-};
-/**
- * A piece of a line: glyphs or one inline icon.
- *
- * @example
- * ```ts
- * const runs: Run[] = [{ kind: "icon", key: "hud.coin" }];
- * ```
- */
-type Run = TextRun | IconRun;
-/**
- * One laid-out line and how wide it is.
- *
- * @example
- * ```ts
- * const line: Line = { runs: [{ kind: "icon", key: "hud.coin" }], width: 38.4 };
- * ```
- */
-type Line = {
-  runs: Run[];
-  width: number;
-};
-/**
- * A laid-out block: its lines and the size `measure` answers with.
- *
- * @example
- * ```ts
- * const layout: TextLayout = { lines: [], width: 0, height: 0 };
- * ```
- */
-type TextLayout = {
-  lines: Line[];
-  width: number;
-  height: number;
-};
-/**
- * What one label container was last filled from: the style object and the laid-out block. An
- * update with the same style object, the same anchor and the same lines and runs writes the new
- * text and positions into the objects already there.
- */
-type DrawnLabel = {
-  style: TextStyle;
-  layout: TextLayout;
-};
-/**
- * A dev warning that is written once per key. Pure modules take it as an argument, so nothing
- * below the plugin context reaches the log itself.
- *
- * @example
- * ```ts
- * const warn: Warn = (key, message) => seen.has(key) || log.warn(message);
- * ```
- */
-type Warn = (key: string, message: string, data?: Record<string, unknown>) => void;
-/**
- * What the pure layout needs next to the runs, the style and the tables.
- *
- * @example
- * ```ts
- * const options: LayoutOptions = { warn: () => undefined };
- * ```
- */
-type LayoutOptions = {
-  warn: Warn;
-};
-/**
- * What was resolved for one entity last, so the frame step knows whether anything moved.
- *
- * @example
- * ```ts
- * const seen: SeenText = { content: "+5", style: "body", bind: undefined, locale: "ru" };
- * ```
- */
-type SeenText = {
-  content: unknown;
-  style: string;
-  bind: string | undefined;
-  locale: string;
-};
-/**
- * text plugin config.
- *
- * @example
- * ```ts
- * createApp({ pluginConfigs: { text: { fonts: { body: "ui.body", digits: "ui.digits" } } } });
- * ```
- */
-type Config$2 = {
-  /** The two fonts every game ships in its boot bundle. They back the built-in styles. */fonts: {
-    body: string;
-    digits: string;
-  };
-};
-/**
- * text plugin state.
- */
-type State$2 = {
-  /** Built-in styles first, then the styles of every feature in feature order. */styles: Map<string, TextStyle>; /** Style name to the feature that brought it, for the duplicate error. */
-  styleOwner: Map<string, string>; /** The config fonts plus every `font`, `bold` and `italic` of every style. */
-  fontKeys: Set<string>; /** The parsed advance table per font key, filled when `assets` has the font. */
-  tables: Map<string, AdvanceTable>; /** The font keys handed to `renderer.sync.fonts.install`. */
-  installed: Set<string>; /** What was resolved for an entity last. */
-  seen: Map<Entity, SeenText>; /** `bind.component` to its world type; `undefined` after the one warning. */
-  bindTypes: Map<string, AnyComponent | undefined>; /** The measured size of every live label, for `ui`. */
-  measured: Map<Entity, Size>; /** Layout per `style + resolved`, oldest dropped first. */
-  cache: Map<string, TextLayout>; /** What every live label container was last filled from, by container. */
-  drawn: WeakMap<object, DrawnLabel>; /** Entities to re-resolve in the next layout phase. */
-  dirty: Set<Entity>; /** Warning keys already written, so a style, a tag, a glyph or a font warns once. */
-  warned: Set<string>; /** The system, the two world hooks and the display adapter. */
-  removers: Array<() => void>;
-};
-/**
- * text plugin API, `app.text`. Two questions: how big a piece of text is, and which styles the
- * game registered. Everything else happens in the frame.
- *
- * @example
- * ```ts
- * app.text.measure("120", "digits"); // { width: 57.6, height: 38.4 }
- * app.text.styles(); // ["body", "digits"]
- * ```
- */
-type TextApi = {
-  /**
-   * The size of a piece of text in reference pixels, from the advance table of the style's font.
-   * A `Message` is formatted in the current locale first. Never touches a canvas, so the answer
-   * is the same in a browser and in plain Bun. Cached per style and resolved string.
-   *
-   * @param content - A plain string, or what `tr` returned.
-   * @param style - A registered style name. An unknown one warns once and measures as `body`.
-   * @returns The width and height of the block.
-   * @example
-   * ```ts
-   * // `ui.layout` asks once per invalidation, from the Yoga measure function of a text element.
-   * const text = ctx.require(textPlugin);
-   *
-   * text.measure("120", "digits"); // { width: 57.6, height: 38.4 } on the 0.6 em fallback
-   * ```
-   */
-  measure(content: string | Message, style: string): Size;
-  /**
-   * Whether the font of a style has a glyph for one character, the lookup Pixi draws by. A
-   * character its font lacks is drawn as nothing and `measure` counts it 0 wide. While the font is
-   * not loaded every character counts, as the 0.6 em fallback measures it. An unknown style warns
-   * once and looks up `body`.
-   *
-   * @param char - One character, a whole code point.
-   * @param style - A registered style name.
-   * @returns False only for a character a loaded font has no glyph for.
-   * @example
-   * ```ts
-   * // `ui` measures the caret of a text field over the characters the font draws.
-   * const text = ctx.require(textPlugin);
-   *
-   * text.hasGlyph("A", "body"); // true
-   * text.hasGlyph("😀", "body"); // false once the body font is loaded: it has no emoji glyph
-   * ```
-   */
-  hasGlyph(char: string, style: string): boolean;
-  /**
-   * The registered style names: the two built-ins first, then the styles of every feature in
-   * feature order.
-   *
-   * @returns A frozen list of style names.
-   * @example
-   * ```ts
-   * // A dev overlay lists what a game may write in a `style` prop.
-   * app.text.styles(); // ["body", "digits", "hud.digits"]
-   * ```
-   */
-  styles(): readonly string[];
-};
-/**
- * Resolved dependency APIs.
- */
-type Deps$2 = {
-  time: Api;
-  flow: Api$1;
-  world: Api$2;
-  renderer: Api$3;
-  assets: Api$4;
-  i18n: I18nApi;
-};
-/**
- * What the kernel context offers before the deps are attached.
- *
- * `text` owns no event, so `emit` is the kernel's and never called here.
- */
-type KernelSlice$2 = PluginCtx<Config$2, State$2> & {
-  readonly global: object;
-  readonly log: Log.LogApi;
-  readonly require: Require;
-};
-/**
- * Domain context shared by the files of the plugin: the kernel slice plus the resolved deps.
- */
-type TextCtx = KernelSlice$2 & {
-  readonly deps: Deps$2;
-};
-/**
- * Payload of the `assets:bundle-loaded` hook: a bundle landed, so a font may be readable now.
- */
-type BundleLoaded = Events$1["assets:bundle-loaded"];
-/**
- * Payload of the `assets:bundle-unloaded` hook: `keys` names the assets that left.
- */
-type BundleUnloaded = Events$1["assets:bundle-unloaded"];
-/**
- * Payload of the `i18n:locale-changed` hook: every message has to be resolved again.
- */
-type LocaleChanged = Events$2["i18n:locale-changed"];
-//#endregion
 //#region src/plugins/ui/layout/types.d.ts
 /**
  * layout module state. `nodes` is attach minus detach: Yoga 3.2.1 has no instance counter.
@@ -598,7 +168,8 @@ type UiApi = {
    * The live screen as plain data: every root in layer order, every element in child order, with
    * its rect in root coordinates, its resolved style and its seven state flags. A rect is natural:
    * under a `fit: "contain"` element it is the rect before that scale, and the fitted element
-   * adds `fitScale`. Works headless.
+   * adds `fitScale`. A windowed scroll adds `window`, and its content lists the live rows only.
+   * Works headless.
    *
    * @returns The root node; several roots come back under one `screen` node.
    * @example
@@ -1731,4 +1302,4 @@ type AnimCtx = KernelSlice & {
   readonly deps: Deps;
 };
 //#endregion
-export { UiApi as A, spawned as C, wait as D, use as E, TextApi as F, TextStyleInput as I, TextStyles as L, Config$2 as M, Point as N, Config$1 as O, State$2 as P, TextValue as R, spawn as S, tween as T, parallel as _, State as a, set as b, HapticKind as c, HAPTIC_KINDS as d, defineAnimation as f, mark as g, haptic as h, MotionKeyframe as i, types_d_exports$1 as j, State$1 as k, SfxDescriptor as l, frames as m, Config as n, Target as o, external as p, FramesValue as r, types_d_exports as s, AnimApi as t, Step as u, play as v, stagger as w, sfx as x, sequence as y, types_d_exports$2 as z };
+export { UiApi as A, spawned as C, wait as D, use as E, Config$1 as O, spawn as S, tween as T, parallel as _, State as a, set as b, HapticKind as c, HAPTIC_KINDS as d, defineAnimation as f, mark as g, haptic as h, MotionKeyframe as i, types_d_exports$1 as j, State$1 as k, SfxDescriptor as l, frames as m, Config as n, Target as o, external as p, FramesValue as r, types_d_exports as s, AnimApi as t, Step as u, play as v, stagger as w, sfx as x, sequence as y };

package/dist/{types-DmhTHRVW.d.mts → types-DtmFVCHf.d.mts}

@@ -1,4 +1,4 @@
-import { At as Json, Ht as RngState, St as Api, ft as FlowState, ht as RouteStep, pt as JournalEntry, q as Api$1, xt as Answer, zt as Snapshot } from "./types-BZ1OLf24.mjs";
+import { At as JournalEntry, Kt as Json, Lt as Answer, Rt as Api, in as RngState, jt as RouteStep, kt as FlowState, tn as Snapshot, ut as Api$1 } from "./types-Dy1xB68L.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/headless.d.ts