@cimplify/sdk 0.108.0 → 0.110.2

package/dist/ui-DwHicuFv.d.mts

@@ -0,0 +1,563 @@
+import { d as UiLength, e as UiVar, f as UiAlign, b as UiColor, g as UiVarValue, U as UiTheme, h as UiStyle, P as PatchWriter, S as StyleCache, i as UiKindName, c as UiNumberFormatName, j as UiVectorPlayKind, k as UiVectorSeekKind, l as UiTransitionName, m as UiEasingName, n as UiRoleName, o as UiEventName, G as GameUiEventView, p as UiAnchorName } from './vars-Dc_PrhBK.mjs';
+
+interface FontMetrics {
+    readonly atlas: readonly [number, number];
+    readonly emPx: number;
+    readonly rangePx: number;
+    readonly ascender: number;
+    readonly descender: number;
+    readonly lineGap: number;
+}
+declare class FontTable {
+    readonly metrics: FontMetrics;
+    readonly fallback: number;
+    readonly glyphCount: number;
+    private readonly ascii;
+    private readonly codepoints;
+    private readonly cmapGlyphs;
+    private readonly advances;
+    private readonly planes;
+    private readonly uvs;
+    private readonly kernKeys;
+    private readonly kernValues;
+    private readonly kernRows;
+    private readonly formCodepoints;
+    private readonly formGlyphs;
+    private readonly ligatureKeys;
+    private readonly ligatureGlyphs;
+    constructor(bytes: ArrayBuffer);
+    lookup(codepoint: number): number;
+    glyph(codepoint: number): number;
+    advance(glyph: number): number;
+    plane(glyph: number, corner: number): number;
+    uv(glyph: number, corner: number): number;
+    kerning(left: number, right: number): number;
+    get hasForms(): boolean;
+    form(codepoint: number, form: number): number;
+    ligature(first: number, second: number, form: number): number;
+}
+
+type TextWrapStyle = "greedy" | "balance" | "pretty";
+
+interface UiTextMetrics {
+    lines: number;
+    width: number;
+    height: number;
+}
+interface UiMeasureStyle {
+    readonly fontSize?: number;
+    readonly lineHeight?: number;
+    readonly letterSpacing?: number;
+    readonly textWrapStyle?: TextWrapStyle;
+}
+declare class TextMeasurer {
+    private readonly layout;
+    private readonly style;
+    private readonly result;
+    private readonly memo;
+    hits: number;
+    misses: number;
+    private dictionaries;
+    measure(table: FontTable, text: string, style: UiMeasureStyle, width: number, out: UiTextMetrics): UiTextMetrics;
+    clear(): void;
+}
+
+type UiCondition = ":pressed" | ":active" | ":focus" | ":disabled" | "@landscape" | "@portrait" | "@safe" | "@sm" | "@lg";
+type UiConditional<V> = V | null | ({
+    readonly default?: UiConditional<V>;
+} & {
+    readonly [C in UiCondition]?: UiConditional<V>;
+});
+type Num = number | UiVar;
+type Colour = UiColor | UiVar;
+type Len = UiLength | UiVar;
+type Quad<V> = readonly [V, V, V, V];
+type Edges = Num | Quad<Num>;
+interface UiStyleShadow {
+    readonly color: Colour;
+    readonly x?: number;
+    readonly y?: number;
+    readonly blur?: number;
+    readonly spread?: number;
+}
+interface UiStyleGradient {
+    readonly kind?: "linear" | "radial";
+    readonly stops: readonly (readonly [Colour, number])[];
+    readonly from?: readonly [number, number];
+    readonly to?: readonly [number, number];
+}
+interface UiStyleValues {
+    width: Len;
+    height: Len;
+    minWidth: Len;
+    minHeight: Len;
+    maxWidth: Len;
+    maxHeight: Len;
+    basis: Len;
+    flexBasis: Len;
+    inset: Len;
+    insetInline: Len;
+    insetBlock: Len;
+    top: Len;
+    right: Len;
+    bottom: Len;
+    left: Len;
+    padding: Edges;
+    paddingInline: Num;
+    paddingHorizontal: Num;
+    paddingBlock: Num;
+    paddingVertical: Num;
+    paddingTop: Num;
+    paddingRight: Num;
+    paddingBottom: Num;
+    paddingLeft: Num;
+    margin: Edges;
+    marginInline: Num;
+    marginHorizontal: Num;
+    marginBlock: Num;
+    marginVertical: Num;
+    marginTop: Num;
+    marginRight: Num;
+    marginBottom: Num;
+    marginLeft: Num;
+    borderWidth: Edges;
+    borderInlineWidth: Num;
+    borderBlockWidth: Num;
+    borderTopWidth: Num;
+    borderRightWidth: Num;
+    borderBottomWidth: Num;
+    borderLeftWidth: Num;
+    gap: Num | readonly [Num, Num];
+    columnGap: Num;
+    rowGap: Num;
+    grow: Num;
+    flexGrow: Num;
+    shrink: Num;
+    flexShrink: Num;
+    aspect: Num;
+    aspectRatio: Num;
+    direction: "row" | "column" | "row-reverse" | "column-reverse";
+    flexDirection: "row" | "column" | "row-reverse" | "column-reverse";
+    justify: "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly";
+    justifyContent: "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly";
+    alignItems: UiAlign;
+    alignSelf: UiAlign;
+    alignContent: UiAlign;
+    position: "relative" | "absolute";
+    wrap: boolean;
+    display: "flex" | "none";
+    fill: Colour;
+    backgroundColor: Colour;
+    borderColor: Colour | Quad<Colour>;
+    borderInlineColor: Colour;
+    borderBlockColor: Colour;
+    borderTopColor: Colour;
+    borderRightColor: Colour;
+    borderBottomColor: Colour;
+    borderLeftColor: Colour;
+    radius: Edges;
+    borderRadius: Edges;
+    radiusTopLeft: Num;
+    radiusTopRight: Num;
+    radiusBottomRight: Num;
+    radiusBottomLeft: Num;
+    borderTopLeftRadius: Num;
+    borderTopRightRadius: Num;
+    borderBottomRightRadius: Num;
+    borderBottomLeftRadius: Num;
+    opacity: Num;
+    translate: readonly [Num, Num];
+    translateX: Num;
+    translateY: Num;
+    scale: Num | readonly [Num, Num];
+    scaleX: Num;
+    scaleY: Num;
+    rotate: Num;
+    origin: readonly [Num, Num];
+    zIndex: Num;
+    hidden: boolean;
+    clip: boolean;
+    pointerEvents: "auto" | "none";
+    layer: boolean;
+    shadow: UiStyleShadow | null;
+    gradient: UiStyleGradient | null;
+    fontFamily: Num;
+    fontWeight: Num;
+    fontSize: Num;
+    lineHeight: Num;
+    letterSpacing: Num;
+    textAlign: "start" | "end" | "left" | "center" | "right";
+    textColor: Colour;
+    color: Colour;
+    textWrap: boolean;
+    textWrapStyle: "greedy" | "balance" | "pretty";
+    verticalAlign: "top" | "center" | "bottom";
+    placeholderColor: Colour;
+    tint: Colour;
+    uv: Quad<Num>;
+    nineSlice: Edges;
+    nineSliceUv: Edges;
+    shape: "rect" | "ellipse" | "path";
+    stroke: Colour;
+    strokeWidth: Num;
+    scrollAxes: "none" | "x" | "y" | "both";
+}
+type UiStyleProperty = keyof UiStyleValues;
+type UiStyleDefinition = {
+    readonly [K in UiStyleProperty]?: UiConditional<UiStyleValues[K]>;
+};
+type UiWiden<V> = V extends string ? string : V extends readonly (infer E)[] ? readonly UiWiden<E>[] : V extends UiVar ? V : V extends object ? {
+    readonly [K in keyof V]: UiWiden<V[K]>;
+} : V;
+type UiDynamicDefinition = {
+    readonly [K in UiStyleProperty]?: UiConditional<UiWiden<UiStyleValues[K]>>;
+};
+type UiDynamicStyle = (...args: never[]) => UiDynamicDefinition;
+type UiStyleSheet = Readonly<Record<string, UiStyleDefinition | ((...args: never[]) => object)>>;
+type UiConditionKey = "default" | UiCondition;
+type UiExactConditions<V> = V extends readonly unknown[] | UiVar ? V : V extends object ? {
+    readonly [K in keyof V]: K extends UiConditionKey ? UiExactConditions<V[K]> : never;
+} : V;
+type UiExactStyle<S> = {
+    readonly [P in keyof S]: P extends UiStyleProperty ? (P extends "shadow" | "gradient" ? S[P] : UiExactConditions<S[P]>) : never;
+};
+type UiDynamicValue<P extends UiStyleProperty, V> = [V] extends [UiConditional<UiWiden<UiStyleValues[P]>> | undefined] ? P extends "shadow" | "gradient" ? V : UiExactConditions<V> : never;
+type UiExactDynamic<R> = {
+    readonly [P in keyof R]: P extends UiStyleProperty ? UiDynamicValue<P, R[P]> : never;
+};
+type UiExact<T> = {
+    readonly [N in keyof T]: T[N] extends (...args: infer A) => infer R ? (...args: A) => UiExactDynamic<R> : UiExactStyle<T[N]>;
+};
+
+declare class CompiledStyle<K extends string = string> {
+    readonly __keys?: K;
+    readonly first: Int16Array<ArrayBuffer>;
+    readonly count: Uint8Array<ArrayBuffer>;
+    variantKey: Uint8Array<ArrayBuffer>;
+    mask: Uint8Array<ArrayBuffer>;
+    priority: Uint16Array<ArrayBuffer>;
+    empty: Uint8Array<ArrayBuffer>;
+    unit: Uint8Array<ArrayBuffer>;
+    start: Uint16Array<ArrayBuffer>;
+    values: Float64Array<ArrayBuffer>;
+    refKind: Uint8Array<ArrayBuffer>;
+    refId: Int32Array<ArrayBuffer>;
+    stateMask: number;
+    contextMask: number;
+    usesVars: boolean;
+    slots: number;
+    version: number;
+    slotPos: Int32Array<ArrayBuffer>;
+    slotFloat: Uint8Array<ArrayBuffer>;
+    slotRefPos: Int32Array<ArrayBuffer>;
+    slotRefSlot: Int32Array<ArrayBuffer>;
+    slotRefMode: Uint8Array<ArrayBuffer>;
+    constructor(words: ArrayLike<number>);
+    slotBits(slot: number): number;
+    load(words: ArrayLike<number>): void;
+    keySignature(): string;
+    setSlotsFrom(source: Float64Array, offset?: number): this;
+    slotBitsTo(slot: number, out: Uint32Array, at: number): void;
+    setSlot(slot: number, raw: UiVarValue): void;
+}
+declare class UiProps {
+    readonly owner: (CompiledStyle | null)[];
+    readonly wires: Uint8Array;
+    readonly stateMask: number;
+    readonly contextMask: number;
+    readonly usesVars: boolean;
+    readonly theme: UiTheme | null;
+    readonly wireSet: Uint8Array<ArrayBuffer>;
+    readonly styles: readonly CompiledStyle[];
+    readonly dynamics: readonly CompiledStyle[];
+    readonly slotOffsets: Int32Array;
+    readonly slotCount: number;
+    encoded: EncodedRecords | null;
+    encodedVersion: number;
+    version(): number;
+    slotOffset(style: CompiledStyle): number;
+    constructor(parts: readonly (CompiledStyle | UiTheme | UiProps)[]);
+}
+type CompiledWords = readonly number[] | Uint32Array;
+type UiStyleArg = CompiledStyle | UiProps | UiTheme | UiStyle | UiStyleDefinition | string | CompiledWords | false | null | undefined | readonly UiStyleArg[];
+type SlotFactory = (style: CompiledStyle, out: Float64Array) => (...args: never[]) => CompiledStyle;
+type CompiledEntry = CompiledWords | readonly [CompiledWords, readonly ((...args: never[]) => UiVarValue)[]] | readonly [CompiledWords, SlotFactory];
+interface StyleTarget {
+    readonly writer: PatchWriter;
+    readonly cache: StyleCache;
+    readonly id: number;
+    resolveVar(id: number): UiVarValue | undefined;
+    scopedVar(id: number): UiVarValue | undefined;
+    setLayer(on: boolean): void;
+}
+interface EncodedRecords {
+    readonly records: readonly StyleRecord[];
+    readonly wires: Uint8Array;
+    readonly tokenIds: Uint32Array;
+    readonly tokenKinds: Uint8Array;
+    readonly literal: boolean;
+}
+declare const STYLE_RECORD_REFERENCED: number;
+declare const STYLE_RECORD_SAFE_EDGES: number;
+interface StyleRecord {
+    readonly mask: number;
+    readonly words: Uint32Array;
+}
+declare function encodeStyleRecords(props: UiProps): StyleRecord[];
+
+type UiStyleSheetOf<T> = {
+    readonly [N in keyof T]: T[N] extends (...args: infer A) => infer R ? (...args: A) => CompiledStyle<Extract<keyof R, string>> : CompiledStyle<Extract<keyof T[N], string>>;
+};
+type UiStyles<Allowed = UiStyleDefinition> = CompiledStyle<Extract<keyof Allowed, string>> | false | null | undefined;
+declare function styles<const T extends UiStyleSheet>(definition: T & UiExact<T>, compiled?: Readonly<Record<string, CompiledEntry>>): UiStyleSheetOf<T>;
+declare const props: (a?: UiStyleArg, b?: UiStyleArg, c?: UiStyleArg, d?: UiStyleArg, e?: UiStyleArg, f?: UiStyleArg, g?: UiStyleArg, h?: UiStyleArg) => UiProps;
+
+interface GameUiSink {
+    submit(bytes: Uint8Array, length: number): void;
+}
+interface GameUiOptions {
+    readonly max_nodes?: number;
+    readonly reserve?: number;
+    readonly auto_flush?: boolean;
+    readonly capacity?: number;
+    readonly max_slots?: number;
+    readonly dictionaries?: boolean;
+}
+interface RootOptions {
+    anchor?: UiAnchorName;
+    safe_area?: boolean;
+    offset?: readonly [number, number];
+    z?: number;
+}
+interface WorldAnchorOptions {
+    position: readonly [number, number, number];
+    pivot?: readonly [number, number];
+    offset?: readonly [number, number];
+    reference_distance?: number;
+    min_scale?: number;
+    max_scale?: number;
+    hide_when_occluded?: boolean;
+    occluded_opacity?: number;
+    z?: number;
+}
+interface AccessibilityOptions {
+    role?: UiRoleName;
+    label?: string;
+    value?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    live?: boolean;
+    modal?: boolean;
+    actions?: readonly ("activate" | "increment" | "decrement" | "dismiss" | "scroll")[];
+}
+interface TransitionOptions {
+    duration: number;
+    easing?: UiEasingName;
+    bezier?: readonly [number, number, number, number];
+    spring?: {
+        damping: number;
+        cycles: number;
+    };
+}
+interface NumberOptions {
+    format?: UiNumberFormatName;
+    decimals?: number;
+    separator?: string;
+}
+type UiStyleInput = UiStyle | UiStyleArg;
+type UiStateName = "pressed" | "focus" | "disabled";
+type UiExclusion = {
+    readonly element: UiElement;
+    readonly shape?: "rect" | "circle";
+    readonly margin?: number;
+} | {
+    readonly rect: readonly [number, number, number, number];
+    readonly margin?: number;
+} | {
+    readonly circle: readonly [number, number, number];
+    readonly margin?: number;
+} | {
+    readonly polygon: ArrayLike<number>;
+    readonly element?: UiElement;
+    readonly margin?: number;
+};
+interface UiTextOptions {
+    readonly flowAround?: readonly UiExclusion[];
+}
+interface UiTextMeasureStyle extends UiMeasureStyle {
+    readonly fontFamily?: string | number;
+    readonly fontWeight?: number;
+}
+
+interface UiEnvironment {
+    readonly width: number;
+    readonly height: number;
+    readonly safe?: boolean;
+}
+declare const BREAKPOINT_SM = 640;
+declare const BREAKPOINT_LG = 1024;
+type GameUiListener = (event: Readonly<GameUiEventView>, element: UiElement) => void;
+type PassthroughListener = (event: Readonly<GameUiEventView>) => void;
+declare class GameUiError extends Error {
+    constructor(message: string);
+}
+declare class UiElement implements StyleTarget {
+    readonly ui: GameUi;
+    readonly id: number;
+    readonly kind: UiKindName;
+    readonly cache: StyleCache;
+    private flags;
+    private listeners;
+    private alive;
+    private edited;
+    private parentElement;
+    private readonly kids;
+    private current;
+    private sent;
+    private sentVersion;
+    private forced;
+    private focusable;
+    private slotBase;
+    private slotSize;
+    private slotFresh;
+    private slotBits;
+    private stateBits;
+    private scope;
+    get writer(): PatchWriter;
+    get props(): UiProps | null;
+    get state(): number;
+    resolveVar(id: number): UiVarValue | undefined;
+    scopedVar(id: number): UiVarValue | undefined;
+    private scoped;
+    get perElement(): boolean;
+    setLayer(on: boolean): void;
+    private applyProps;
+    private send;
+    private allocateSlots;
+    private writeSlots;
+    active(): number;
+    restyle(): void;
+    restyleVars(): void;
+    setState(state: UiStateName, on: boolean): this;
+    get parent(): UiElement | null;
+    get children(): readonly UiElement[];
+    contains(element: UiElement): boolean;
+    detach(): void;
+    private adopt;
+    constructor(ui: GameUi, id: number, kind: UiKindName);
+    get destroyed(): boolean;
+    style(style: UiStyleInput): this;
+    append(child: UiElement): this;
+    insertBefore(child: UiElement, before: UiElement): this;
+    remove(): this;
+    destroy(): void;
+    get value(): string;
+    accept(value: string): void;
+    text(value: string): this;
+    textPrefix(value: string, length: number): this;
+    textRef(id: number): this;
+    number(value: number, options?: NumberOptions): this;
+    placeholder(value: string): this;
+    image(asset: number, width: number, height: number): this;
+    path(points: ArrayLike<number>): this;
+    vector(asset: number, artboard?: number): this;
+    play(kind: UiVectorPlayKind, index: number): this;
+    seek(kind: UiVectorSeekKind, index: number, seconds: number): this;
+    setInput(input: number | string, value: number | boolean): this;
+    setData(path: string, value: number | boolean): this;
+    setDataColor(path: string, argb: number): this;
+    fireData(path: string): this;
+    detachVector(): this;
+    private requireVector;
+    flowAround(exclusions: readonly UiExclusion[] | null): this;
+    private exclusionRecord;
+    private exclusionTarget;
+    transition(props: readonly UiTransitionName[], options: TransitionOptions): this;
+    accessibility(options: AccessibilityOptions): this;
+    scrollTo(x: number, y: number): this;
+    focus(): this;
+    blur(): this;
+    on(event: UiEventName, listener: GameUiListener): () => void;
+    emit(name: UiEventName, event: Readonly<GameUiEventView>): boolean;
+    private setFlag;
+    dispose(): void;
+}
+declare class GameUi {
+    private readonly sink;
+    readonly writer: PatchWriter;
+    private readonly elements;
+    private readonly free;
+    private next;
+    private readonly maxNodes;
+    private readonly strings;
+    private readonly families;
+    private readonly fontFamilies;
+    private readonly fontWeights;
+    private readonly fontIds;
+    private readonly measurer;
+    private readonly passthrough;
+    private readonly event;
+    private scheduled;
+    private readonly autoFlush;
+    private contextBits;
+    private themeRoot;
+    private readonly tokenIds;
+    private readonly tokenKinds;
+    private readonly tokenSent;
+    private readonly themeBits;
+    private readonly maxSlots;
+    private slotTop;
+    private readonly freeSlotBlocks;
+    get context(): number;
+    get rootTheme(): UiTheme | null;
+    styles<const T extends UiStyleSheet>(definition: T & UiExact<T>, compiled?: Readonly<Record<string, CompiledEntry>>): UiStyleSheetOf<T>;
+    props(a?: UiStyleArg, b?: UiStyleArg, c?: UiStyleArg, d?: UiStyleArg, e?: UiStyleArg, f?: UiStyleArg, g?: UiStyleArg, h?: UiStyleArg): UiProps;
+    environment(environment: UiEnvironment): void;
+    private tokenValue;
+    ensureTokens(ids: Uint32Array, kinds: Uint8Array): void;
+    theme(theme: UiTheme | null): void;
+    allocateSlots(count: number): number;
+    freeSlots(base: number, count: number): void;
+    constructor(sink: GameUiSink, options?: GameUiOptions);
+    textDictionaries(on: boolean): void;
+    check(element: UiElement): void;
+    touched(): void;
+    private readonly flushTask;
+    private allocate;
+    release(element: UiElement): void;
+    private forget;
+    element(id: number): UiElement | undefined;
+    box(style?: UiStyleInput): UiElement;
+    text(content: string, style?: UiStyleInput, options?: UiTextOptions): UiElement;
+    fontFor(family: string | number, weight?: number): number;
+    measureText(text: string, style?: UiTextMeasureStyle, width?: number, out?: UiTextMetrics): UiTextMetrics;
+    get measureStats(): {
+        readonly hits: number;
+        readonly misses: number;
+    };
+    image(asset: number, natural: readonly [number, number], style?: UiStyleInput): UiElement;
+    loadVector(asset: number, bytes: Uint8Array): void;
+    unloadVector(asset: number): void;
+    vector(asset: number, artboard?: number, style?: UiStyleInput): UiElement;
+    shape(style?: UiStyleInput, path?: ArrayLike<number>): UiElement;
+    scroll(style?: UiStyleInput): UiElement;
+    input(placeholder: string, style?: UiStyleInput): UiElement;
+    root(element: UiElement, options?: RootOptions): UiElement;
+    worldRoot(element: UiElement, anchor: WorldAnchorOptions): UiElement;
+    unroot(element: UiElement): void;
+    move(element: UiElement, x: number, y: number, z: number): void;
+    moveFrom(element: UiElement, values: ArrayLike<number>, offset: number): void;
+    occlude(element: UiElement, occluded: boolean): void;
+    intern(text: string): number;
+    family(name: string): number;
+    registerFont(family: string, font: number, weight?: number): number;
+    onPassthrough(listener: PassthroughListener): () => void;
+    flush(): number;
+    dispatch(bytes: Uint8Array, offset?: number): number;
+}
+declare function collectingSink(): GameUiSink & {
+    readonly buffers: Uint8Array[];
+};
+
+export { type AccessibilityOptions as A, BREAKPOINT_LG as B, CompiledStyle as C, type UiStyleShadow as D, type UiStyleSheet as E, FontTable as F, GameUi as G, type UiStyleSheetOf as H, type UiStyleValues as I, type UiTextMeasureStyle as J, type UiTextMetrics as K, type UiTextOptions as L, collectingSink as M, type NumberOptions as N, encodeStyleRecords as O, type PassthroughListener as P, props as Q, type RootOptions as R, STYLE_RECORD_REFERENCED as S, TextMeasurer as T, UiElement as U, styles as V, type WorldAnchorOptions as W, type GameUiOptions as a, type UiStyles as b, UiProps as c, type UiExclusion as d, BREAKPOINT_SM as e, type CompiledEntry as f, type CompiledWords as g, GameUiError as h, type GameUiListener as i, type GameUiSink as j, STYLE_RECORD_SAFE_EDGES as k, type SlotFactory as l, type StyleRecord as m, type TransitionOptions as n, type UiCondition as o, type UiConditional as p, type UiDynamicStyle as q, type UiEnvironment as r, type UiExact as s, type UiMeasureStyle as t, type UiStateName as u, type UiStyleArg as v, type UiStyleDefinition as w, type UiStyleGradient as x, type UiStyleInput as y, type UiStyleProperty as z };