lecodes-sdk 1.2.0 → 2.0.1

package/dist/types/ui/presentable.d.ts

@@ -1,38 +1,45 @@
-/** Built-in transition catalog. `push`/`pop` are the stacked-navigation pair (slide + parallax +
- *  dim + edge shadow); the rest are simple two-view moves. */
+import type { EasingInput } from "../animate/tween/easing";
+/** The built-in transitions (ui/transitions.ts holds what each one is). `push` / `pop` are the
+ *  stacked-navigation pair — the incoming screen slides over the other one, which drifts and dims;
+ *  the rest are two-screen moves. */
 export type TransitionName = "push" | "pop" | "slide-from-left" | "slide-from-right" | "slide-from-top" | "slide-from-bottom" | "zoom" | "zoom-in" | "zoom-out" | "fade" | "none";
-/** Start/end pose of one side of a custom transition. `x`/`y` are logical px, or a percentage of
- *  the destination's size (e.g. `"100%"` = one full width to the right). */
-export type TransitionTransform = {
-    x?: number | `${number}%`;
-    y?: number | `${number}%`;
-    scale?: number;
-    opacity?: number;
+/**
+ * One screen's pose in a transition — the keys of an `animateTo` bag a transition can move, with
+ * the side's own timing. An array is a list of keyframes, as there.
+ */
+export type TransitionPose = {
+    /** A transform list, as in a style — and here a `%` in `translate` is a percent of the screen's
+     *  own box: `"translateX(100%)"` is one width to the right. */
+    transform?: string | string[];
+    opacity?: number | number[];
+    /** Black over this screen, 0..1: how dark the screen UNDER the other one gets. */
+    dim?: number | number[];
+    /** ms (default 300). */
+    duration?: number;
+    /** ms to wait; the screen holds its first pose through it. */
+    delay?: number;
+    /** Any curve `animateTo` takes (default `ease-in-out`). */
+    easing?: EasingInput;
 };
 /**
- * A custom transition: declarative poses for the incoming/outgoing destination, played natively.
- * Serializes onto each platform's existing transition machinery — there is no per-frame JS.
- * Fields omitted keep the identity pose. Interactive back-swipe stays system-native (push/pop
- * only); a spec applies to non-interactive transitions.
+ * A transition between two destinations, described by where each side is when it is NOT at rest:
+ * the incoming one comes FROM `enter`, the outgoing one goes TO `exit`. A side left out stays put.
+ *
+ * ```ts
+ * Router.push(page, { transition: { enter: { transform: "translateY(100%)", duration: 400 }, exit: { dim: 0.3 } } })
+ * ```
+ *
+ * A screen's own `transform` / `opacity` are not seen while a transition moves it (put a lasting
+ * effect on a child). A scene, a native view, a video never move: next to one of them only the
+ * screen's side plays, above it.
  */
 export interface TransitionSpec {
-    /** Duration in ms (default 300). */
-    duration?: number;
-    /** cubic-bezier control points (default ease-out). */
-    easing?: [number, number, number, number];
-    /** The entering destination animates FROM this pose to identity. */
-    incoming?: {
-        from?: TransitionTransform;
-    };
-    /** The leaving destination animates from identity TO this pose. */
-    outgoing?: {
-        to?: TransitionTransform;
-    };
-    /** Scrim alpha (0..1) painted over whichever destination is underneath. */
-    dim?: number;
-    /** Which side stacks on top during the animation (default "incoming"). On Android, transitions
-     *  involving a scene always animate the screen side on top — the scene view itself never moves. */
-    onTop?: "incoming" | "outgoing";
+    /** The incoming destination's start: it moves from this pose to rest. */
+    enter?: TransitionPose;
+    /** The outgoing destination's end: it moves from rest to this pose. */
+    exit?: TransitionPose;
+    /** Which side is above the other while they move (default `"enter"`). */
+    onTop?: "enter" | "exit";
 }
 export type Transition = TransitionName | TransitionSpec;
 export type PresentOptions = {
@@ -41,6 +48,10 @@ export type PresentOptions = {
      *  `replaceTransition` for replace). */
     transition?: Transition;
 };
+/** `close()` / `Router.hide()`: the transition the destination leaves with (default "none"). */
+export type DismissOptions = {
+    transition?: Transition;
+};
 /**
  * Anything that can be shown as the app's current destination: a `UIScreen`, a `Scene` /
  * `ARScene`, a `Scene2D`, a `NativeView`, or a `UIVideo`. One Presentable is visible at a time;
@@ -52,10 +63,13 @@ export type PresentOptions = {
  */
 export interface Presentable {
     open(options?: PresentOptions): void | this | Promise<void>;
-    close(): void;
+    /** Close this destination if it is the one on screen (nothing takes its place). One that is not
+     *  on screen — already replaced by a `Router.init/push/replace` or another `open()` — is left as
+     *  it is, so `Router.init(home); scene.close()` keeps `home` visible. */
+    close(options?: DismissOptions): void;
     onOpen(callback: () => void): this;
     onClose(callback: () => void): this;
-    onBackPressed(callback: () => void): this;
+    onBack(callback: () => void): this;
 }
 /** Runtime companion of the `Presentable` interface (declaration merging): the navigation
  *  state that isn't tied to the Router. */

package/dist/types/ui/router.d.ts

@@ -1,10 +1,21 @@
-import { Presentable, type Transition } from "./presentable";
+import { Presentable, type DismissOptions, type PresentOptions, type Transition } from "./presentable";
 type RouterOptions = {
     showDefaultBackButton?: boolean;
 };
-type NavigateOptions = {
-    /** Transition to play. Defaults: `"push"` for push, `"pop"` for pop; replace follows the
-     *  theme's `replaceTransition` (`"none"` out of the box). */
+export type NavigateOptions = {
+    /** Transition to play. Defaults: `"push"` for push; replace follows the theme's
+     *  `replaceTransition` (`"none"` out of the box); a pop plays the way back the destination it
+     *  pops remembers. */
+    transition?: Transition;
+    /** The way BACK from the destination — what `Router.pop()` without a transition, the edge swipe
+     *  and the system's back play when they take it off the stack. Default: the transition it came
+     *  with, the other way round (a push goes back with a pop, a slide from the bottom leaves
+     *  downwards; a zoom goes back with a fade). A `replace` that names none keeps the way back of
+     *  the destination it replaces: it belongs to the place in the stack. */
+    popTransition?: Transition;
+};
+export type PopOptions = {
+    /** Transition to play instead of the way back the popped destination remembers. */
     transition?: Transition;
 };
 /** Stack navigation over `Presentable` destinations. `init` once with the home page, then
@@ -25,12 +36,12 @@ type Router = {
     replace(page: Presentable, opts?: NavigateOptions): void | Promise<void>;
     /** Pop the top destination (the programmatic twin of the back gesture); `to` unwinds to a
      *  stack index in one step. */
-    pop(to?: number, opts?: NavigateOptions): void;
+    pop(to?: number, opts?: PopOptions): void;
     /** Blank the router's page, keeping the stack — `restore()` brings it back. A destination
      *  opened directly stays visible. */
-    hide(): void;
+    hide(opts?: DismissOptions): void;
     /** Re-present the stack top after `hide()` or a direct `open()` suspended the router. */
-    restore(): void;
+    restore(opts?: PresentOptions): void;
     /** `"change"` fires on every stack change — pushes, pops, and native back gestures — with the
      *  new top destination. */
     addEventListener(channel: "change", callback: (page: Presentable) => void): void;

package/dist/types/ui/styleColor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ui/transitions.d.ts

@@ -0,0 +1,18 @@
+import type { TransitionSpec } from "./presentable";
+/** Wire ids: a registered transition is > 0. */
+export declare const TRANSITION_NONE = 0;
+/** "The caller names none": the runtime plays what the stack entry remembers (a pop), or keeps
+ *  what the replaced entry remembered (a replace's way back). */
+export declare const TRANSITION_UNSET = -1;
+/** Who a track moves. The ALONE roles play next to a destination that cannot move (a scene, a
+ *  native view, a video) or next to nothing (close(), the first open): only the screen plays, above. */
+export declare const ROLE_ENTER = 0;
+export declare const ROLE_EXIT = 1;
+export declare const ROLE_ENTER_ALONE = 2;
+export declare const ROLE_EXIT_ALONE = 3;
+/** `defineTransition` flags. */
+export declare const TRANSITION_ENTER_ON_TOP = 1;
+/** The way back of a spec: the ROLES swap — the screen that came leaves into its `enter` pose, the
+ *  one that left comes back from its `exit` pose, the same screen stays on top — and the timing and
+ *  the curves stay as written. Not a rewind: that would turn an ease-out into a slow start. */
+export declare const mirrored: (s: TransitionSpec) => TransitionSpec;

package/dist/types/ui/tree.d.ts

@@ -0,0 +1,75 @@
+export declare const TREE_EVENT_LAYOUT = 1;
+export declare const TREE_EVENT_TOUCH_START = 2;
+export declare const TREE_EVENT_CLICK = 3;
+export declare const TREE_EVENT_LONG_PRESS = 4;
+export declare const TREE_EVENT_TOUCH_MOVE = 5;
+export declare const TREE_EVENT_TOUCH_END = 6;
+export declare const TREE_EVENT_TOUCH_CANCEL = 7;
+export declare const TREE_EVENT_SCROLL = 8;
+export declare const TREE_EVENT_OVERSCROLL = 9;
+export declare const TREE_EVENT_SCROLL_RELEASE = 10;
+export declare const TREE_EVENT_REFRESH = 11;
+export declare const TREE_EVENT_CHANGE = 12;
+export declare const TREE_EVENT_FOCUS = 13;
+export declare const TREE_EVENT_BLUR = 14;
+export declare const TREE_EVENT_SUBMIT = 15;
+export declare const TREE_EVENT_OVERLAY_TAP = 16;
+export declare const TREE_EVENT_DETENT = 17;
+export declare const TREE_EVENT_OPEN = 18;
+export declare const TREE_EVENT_CLOSE = 19;
+export declare const TREE_EVENT_BACK = 20;
+export declare const TREE_EVENT_PAGER_SELECT = 21;
+export declare const TREE_EVENT_PAGER_POP = 22;
+export declare const TREE_EVENT_VLIST_SYNC = 23;
+export declare const TREE_EVENT_VLIST_EDGE = 24;
+export declare const TREE_EVENT_VIEW_EVENT = 25;
+export declare const TREE_EVENT_RESIZE = 26;
+export declare const TREE_EVENT_ROUTER_CHANGE = 27;
+export declare const TREE_EVENT_SCENE_TOUCH_START = 28;
+export declare const TREE_EVENT_SCENE_CLICK = 29;
+export declare const TREE_EVENT_DETACHED = 30;
+export declare const TREE_EVENT_FREED = 31;
+export declare const TREE_EVENT_HOVER_ENTER = 32;
+export declare const TREE_EVENT_HOVER_MOVE = 33;
+export declare const TREE_EVENT_HOVER_END = 34;
+export declare const TREE_EVENT_HOVER_CANCEL = 35;
+export declare const TREE_FLAG_INTERACTIVE: number;
+export declare const TREE_FLAG_CLICK: number;
+export declare const TREE_FLAG_LONG_PRESS: number;
+export declare const TREE_FLAG_LAYOUT: number;
+export declare const TREE_FLAG_SCROLL: number;
+export declare const TREE_FLAG_OVERSCROLL: number;
+export declare const TREE_FLAG_SCROLL_RELEASE: number;
+export declare const TREE_FLAG_REFRESH: number;
+export declare const TREE_FLAG_CHANGE: number;
+export declare const TREE_FLAG_FOCUS: number;
+export declare const TREE_FLAG_BLUR: number;
+export declare const TREE_FLAG_SUBMIT: number;
+export declare const TREE_FLAG_OVERLAY_TAP: number;
+export declare const TREE_FLAG_DETENT: number;
+export declare const TREE_FLAG_KEEP_ALIVE: number;
+export declare const TREE_FLAG_BACK: number;
+export declare const TREE_FLAG_VLIST_END: number;
+export declare const TREE_FLAG_VLIST_START: number;
+export declare const TREE_FLAG_HOVER: number;
+export declare const TREE_TRACK_CLAIM_MASK = 255;
+export declare const TREE_TRACK_TRACKED: number;
+export declare const TREE_TRACK_MOVE: number;
+export declare const TREE_TRACK_HANDLED: number;
+export declare const TREE_DEST_SCREEN = 0;
+export declare const TREE_DEST_SCENE3D = 1;
+export declare const TREE_DEST_SCENE2D = 2;
+export declare const TREE_DEST_NATIVE = 3;
+export declare const TREE_DEST_VIDEO = 4;
+export declare const TREE_DEST_NONE = 255;
+export declare const OWNED_KIND_TREE = 0;
+export declare const OWNED_KIND_FETCH = 1;
+export declare const OWNED_KIND_GL_MATERIAL = 2;
+export declare const OWNED_KIND_GL_TEXTURE = 3;
+export declare const OWNED_KIND_GL_ENTITY = 4;
+export declare const OWNED_KIND_ENTITY_2D = 5;
+export declare const OWNED_KIND_MEDIA = 6;
+export declare const OWNED_KIND_TWEEN = 7;
+export declare const OWNED_KIND_CANVAS = 8;
+import { DEAD_HANDLE } from "../core/pins";
+export { DEAD_HANDLE };

package/dist/types/version.d.ts

@@ -0,0 +1,10 @@
+export declare const SDK_VERSION = "2.0.1";
+/** The major of a semver string, or null when it is not one. */
+export declare const sdkMajor: (version: string | null | undefined) => number | null;
+/** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from
+ *  its first bytes; null for a bundle compiled before the line existed (SDK 0.x / 1.x — the
+ *  pre-tree contract, which no 2.x host runs). */
+export declare const bundleSdkVersion: (head: string) => string | null;
+/** Whether a host embedding `hostVersion` can run a bundle whose header carries `bundleVersion`
+ *  (null = no line = pre-2.0 contract): the majors must match. */
+export declare const bundleRunsOn: (bundleVersion: string | null, hostVersion: string) => boolean;