@aethervtt/shard-ui 0.0.1

package/dist/tree.d.ts

@@ -0,0 +1,172 @@
+import { type Entity, type Table, type World } from '@aethervtt/shard-core';
+import { type Font, TextLayout } from '@aethervtt/shard-text';
+import { FlexTree } from './flex.js';
+import { ResolvedStyle, type StyleColumns } from './style.js';
+import { type UiThemeAsset } from './theme.js';
+/** Interactive node kinds. */
+export declare const Kind: {
+    readonly None: 0;
+    readonly Button: 1;
+    readonly Toggle: 2;
+    readonly Slider: 3;
+    readonly TextInput: 4;
+};
+export declare const AnchorState: {
+    readonly None: 0;
+    readonly OnScreen: 1;
+    readonly Clamped: 2;
+    readonly Hidden: 3;
+};
+export declare const Overflow: {
+    readonly Visible: 0;
+    readonly Clip: 1;
+    readonly Scroll: 2;
+};
+/** Text a node measures and draws, and what it was last measured with. */
+export interface TextNode {
+    entity: Entity;
+    value: string;
+    font: Font | undefined;
+    fontVersion: number;
+    size: number;
+    lineHeight: number;
+    wrap: boolean;
+    /** Two cached measurements: max width → (width, height). */
+    cacheW: Float32Array;
+    cacheOut: Float32Array;
+    cacheN: number;
+    /** The drawn layout (at the final width), and what it was laid out with. */
+    layout: TextLayout;
+    laidWidth: number;
+    laidVersion: number;
+}
+/** One UI tree: its nodes in preorder (children in `order`), and everything computed for them. */
+export declare class UiRootState {
+    readonly entity: Entity;
+    readonly tree: FlexTree;
+    /** Node index → entity. Node 0 is the root. */
+    entities: Entity[];
+    parent: Int32Array<ArrayBuffer>;
+    /** Index past the node's subtree. */
+    end: Int32Array<ArrayBuffer>;
+    /** Node indices in paint order (siblings by zIndex, stable). */
+    paint: Int32Array<ArrayBuffer>;
+    /** Computed rect (root pixels), after scroll and anchor scale. */
+    x: Float32Array<ArrayBuffer>;
+    y: Float32Array<ArrayBuffer>;
+    w: Float32Array<ArrayBuffer>;
+    h: Float32Array<ArrayBuffer>;
+    /** Clip applied to the node (x0, y0, x1, y1), and what it passes to its children. */
+    clip: Float32Array<ArrayBuffer>;
+    childClip: Float32Array<ArrayBuffer>;
+    visible: Uint8Array<ArrayBuffer>;
+    scale: Float32Array<ArrayBuffer>;
+    angle: Float32Array<ArrayBuffer>;
+    anchorState: Uint8Array<ArrayBuffer>;
+    distance: Float32Array<ArrayBuffer>;
+    contentW: Float32Array<ArrayBuffer>;
+    contentH: Float32Array<ArrayBuffer>;
+    overflow: Uint8Array<ArrayBuffer>;
+    scrollX: Float32Array<ArrayBuffer>;
+    scrollY: Float32Array<ArrayBuffer>;
+    /** 1: has UiAnchor; 2: UiAnchorArrow. */
+    anchorKind: Uint8Array<ArrayBuffer>;
+    /** Widget kind (Kind), disabled, and whether the node takes the pointer. */
+    kind: Uint8Array<ArrayBuffer>;
+    disabled: Uint8Array<ArrayBuffer>;
+    solid: Uint8Array<ArrayBuffer>;
+    /** This frame: its flex tree is refilled and laid out; its UiLayout rows are written. */
+    filling: boolean;
+    writing: boolean;
+    /** Widgets, styles, or images changed: refresh kind, disabled, and solid. */
+    flagsDirty: boolean;
+    /** order and zIndex per node when the tree was built. */
+    sortKeys: Int16Array<ArrayBuffer>;
+    /** Distance scale of each anchor (1 for other nodes). */
+    anchorScale: Float32Array<ArrayBuffer>;
+    /** Nodes that measure text, by node index. */
+    texts: (TextNode | undefined)[];
+    /** Image intrinsic size (0 until the texture loads). */
+    imageW: Float32Array<ArrayBuffer>;
+    imageH: Float32Array<ArrayBuffer>;
+    count: number;
+    hasAnchors: boolean;
+    /** Root pixels → screen pixels. */
+    factor: number;
+    width: number;
+    height: number;
+    viewportW: number;
+    viewportH: number;
+    camera: Entity | null;
+    theme: UiThemeAsset | undefined;
+    themeVersion: number;
+    order: number;
+    dirty: boolean;
+    /** Frame counter of the last layout, for describe. */
+    laidOutAt: number;
+    /** Something visual changed since the renderer last built this root. */
+    visualVersion: number;
+    constructor(entity: Entity);
+    reserve(n: number): void;
+}
+/** Every UI tree, which root each node is in, and this frame's work counts. */
+export declare class UiStore {
+    roots: UiRootState[];
+    readonly rootOf: Map<number, UiRootState>;
+    readonly indexOf: Map<number, number>;
+    /** UiNode entities outside any UiRoot (ui/no-root), reported once each. */
+    readonly orphans: Set<number>;
+    readonly reportedOrphans: Set<number>;
+    /** Styles nodes name that their root's theme lacks (ui/unknown-style), reported once each. */
+    readonly reportedStyles: Set<string>;
+    structureDirty: boolean;
+    frame: number;
+    /** This frame: roots laid out, nodes they had, anchor-only repositions, layout calls. */
+    layouts: number;
+    nodesLaidOut: number;
+    repositions: number;
+    flexCalls: number;
+    totalLayouts: number;
+    root(entity: Entity): UiRootState | undefined;
+}
+export declare const UiState: import("@aethervtt/shard-core").ResourceDef<UiStore>;
+/** Marks trees for a rebuild when nodes appear, disappear, or move to another parent. */
+export declare function observeUiStructure(world: World): void;
+/** Lays out a text node's string at a width: block width, and lines × line height. */
+export declare function measureTextNode(t: TextNode, maxWidth: number, out: Float32Array, into?: TextLayout): TextLayout;
+/**
+ * Recomputes which nodes are widgets and which take the pointer (a visible background or border,
+ * an image, or a widget), after anything visual changed.
+ */
+export declare function refreshFlags(world: World, r: UiRootState): void;
+interface LayoutState {
+    roots: ReturnType<World['query']>;
+    nodes: ReturnType<World['query']>;
+    texts: ReturnType<World['query']>;
+    images: ReturnType<World['query']>;
+    anchors: ReturnType<World['query']>;
+    cameras: ReturnType<World['query']>;
+    inputs: ReturnType<World['query']>;
+    styles: ReturnType<World['query']>;
+    widgets: ReturnType<World['query']>[];
+    interactions: ReturnType<World['query']>;
+    measure: (node: number, maxWidth: number, out: Float32Array) => void;
+    current: UiRootState | undefined;
+    style: ResolvedStyle;
+    lastTick: number;
+}
+/**
+ * Lays out UI after transform propagation (anchors need world positions). Only roots with a
+ * changed node, text, image, root, viewport, font, or theme lay out; anchors that only moved
+ * reposition their subtree without a layout.
+ */
+export declare const layoutUi: import("@aethervtt/shard-core").SystemDef<LayoutState>;
+/** UiStyle and UiText columns of a table (either may be missing). Cached per table. */
+export declare function textColumns(table: Table): StyleColumns;
+/**
+ * Absolute rects from the flex tree: parents' positions, scroll offsets, anchor points and
+ * scales; clips from ancestors that clip or scroll; visibility (display none, hidden anchors,
+ * arrows of anchors that aren't clamped); content size for scrolling.
+ */
+export declare function derive(r: UiRootState): void;
+export {};