@octane-xplat/ui 0.7.3 → 0.9.0

package/types/generated/props.d.ts

@@ -319,7 +319,8 @@ export interface TextAreaProps extends TextInputProps {
      *  minHeight at the widget's measured line height. With `autoGrow` it
      *  becomes the starting height instead of a fixed one. */
     rows?: number;
-    /** Grow to fit content, capped by `maxRows`. Native TextView grows by
+    /** Grow on input and value updates, capped by `maxRows`, including when
+     *  `value` is omitted. Native TextView grows by
      *  default — this prop exists so web (<textarea> is fixed-rows) matches;
      *  without it, native gets a fixed `rows`-high box like web. */
     autoGrow?: boolean;
@@ -917,14 +918,23 @@ export interface RouteMeta {
     /** Optional `loader` named export — a prefetch hook, not a data layer.
      *  pushRoute fires it (fire-and-forget) before navigating so the
      *  screen's `query$` reads hit a warm cache; boot/deep-link routes
-     *  skip it (the screen mounts in the same tick anyway). */
+     *  skip it (the screen mounts in the same tick anyway). Ignored when
+     *  `dataMode: 'baked'` — baked routes resolve from `manifest.baked`. */
     loader?: (params: Record<string, unknown>) => unknown;
+    /** Data provenance: 'live' (default) runs `loader` at navigation;
+     *  'baked' reads build-time output from the manifest's `baked` map —
+     *  for file routes the loader lives in a `<route>.loader.ts` sibling
+     *  that `xplat routes`/`xplat build` executes and never bundles. */
+    dataMode?: RouteDataMode;
     /** Optional guard awaited before a push commits. A thrown `redirect(...)`
      * short-circuits the attempted route. */
     beforeLoad?: BeforeLoad;
     /** Optional route title/meta declaration, or a params-only function. */
     head?: RouteHeadExport;
 }
+/** How a route's data is produced — `'live'` runs the loader at navigation,
+ *  `'baked'` freezes loader output into the bundle at build time. */
+export type RouteDataMode = 'live' | 'baked';
 /** Output of `deriveRouteManifest` — `screens` feeds `registerScreens`
  *  (native pushRoute + web outlet fallback), `routes` feeds web URL
  *  matching, `layouts` catalogs `_layout` files by directory ('' = root). */
@@ -933,6 +943,10 @@ export interface RouteManifest {
     routes: RouteMeta[];
     layouts: Record<string, any>;
     loaders?: Record<string, (params: Record<string, unknown>) => unknown | Promise<unknown>>;
+    /** Build-time loader output for `dataMode: 'baked'` routes — the
+     *  generated `routes.gen.*` glue assigns it from `routes.gen.data`;
+     *  programmatic hosts pass it on `RouteSpecSet`/`addRoutes` directly. */
+    baked?: Record<string, unknown>;
 }
 /** One programmatic route entry for `defineRoutes` — the manifest fields a
  *  route file would have produced, supplied directly. `path` uses the
@@ -944,6 +958,7 @@ export interface RouteSpec {
     /** Default presentation, like a `+modal`/`+fade` filename suffix. */
     presentation?: 'push' | 'modal' | 'fade';
     loader?: RouteMeta['loader'];
+    dataMode?: RouteDataMode;
     beforeLoad?: BeforeLoad;
     head?: RouteHeadExport;
     /** Diagnostics label recorded on `RouteMeta.file` (warn strings). */
@@ -951,11 +966,103 @@ export interface RouteSpec {
 }
 /** Input to `defineRoutes`: the route list plus optional path-keyed layouts
  *  — `layouts: { docs: Shell }` plays the `_layout.tsrx` role for every
- *  route under `docs/*`. */
+ *  route under `docs/*`. `baked` carries build-time data for
+ *  `dataMode: 'baked'` specs — the host computes it (a content dir read, a
+ *  build step) and ships it in the manifest. */
 export interface RouteSpecSet {
     routes: readonly RouteSpec[];
     layouts?: Record<string, any>;
+    baked?: Record<string, unknown>;
+}
+/** The host-consumable route schema — what `xplat routes` writes to
+ *  `routes.gen.manifest.json` and `manifestToJson` produces from any
+ *  RouteManifest. Same shape whether the routes came from the file dir
+ *  or `defineRoutes`, so an external host (e.g. a web SSR tier) consumes
+ *  one normalized list. `loader`/`guard`/`head` are presence flags — the
+ *  functions don't cross the JSON boundary. */
+export interface RouteManifestJson {
+    version: 1;
+    /** Layout dirs present, '' = the root `_layout` — sorted. */
+    layouts: string[];
+    /** Registered screen names, including any without a URL pattern. */
+    screens: string[];
+    routes: RouteJson[];
+}
+export interface RouteJson {
+    name: string;
+    /** Colon-syntax path — 'docs/:slug', '' for the root index. */
+    path: string;
+    params: string[];
+    presentation?: 'push' | 'modal' | 'fade';
+    dataMode?: RouteDataMode;
+    /** Layout dirs applying to this route, root '' first, innermost last. */
+    layouts: string[];
+    /** Source label — file path or `programmatic:<path>`. */
+    source: string;
+    loader: boolean;
+    guard: boolean;
+    head: boolean;
+}
+/** Phantom key carrying a `defineRoutes` manifest's spec-derived route
+ *  types — type-level only, never present at runtime. Module-private so the
+ *  published declarations carry no value binding for it. */
+declare const specRouteTypes: unique symbol;
+/** ':id' or '[id]' segment → 'id'; a static segment contributes nothing. */
+type RouteParamOf<S extends string> = S extends `:${infer P}` ? P : S extends `[${infer P}]` ? P : never;
+type TrimSlashes<P extends string> = P extends `/${infer R}` ? TrimSlashes<R> : P extends `${infer R}/` ? TrimSlashes<R> : P;
+/** Route-dir vocabulary at the type level: '[id]' normalizes to ':id'. */
+type NormSegment<S extends string> = S extends `[${infer P}]` ? `:${P}` : S;
+type NormPath<P extends string> = P extends `${infer Head}/${infer Tail}` ? `${NormSegment<Head>}/${NormPath<Tail>}` : NormSegment<P>;
+/** The route name a spec `path` produces — `''`/`'index'` and a trailing
+ *  'index' segment normalize like `specSegments` does at runtime. */
+export type RouteNameOfPath<P extends string> = NormPath<TrimSlashes<P>> extends infer N extends string ? N extends '' | 'index' ? 'index' : N extends `${infer R}/index` ? R : N : never;
+/** Param names in a spec path — `'docs/[slug]'` and `'docs/:slug'` both
+ *  give `'slug'`; static-only paths give `never`. */
+export type RoutePathParams<Path extends string> = TrimSlashes<Path> extends infer P extends string ? P extends `${infer Head}/${infer Tail}` ? RouteParamOf<Head> | RoutePathParams<Tail> : RouteParamOf<P> : never;
+type RouteParamRecord<Path extends string> = {
+    [K in RoutePathParams<Path>]: string;
+};
+type SpecPaths<Specs extends readonly RouteSpec[]> = Specs[number] extends infer S ? S extends {
+    path: infer P extends string;
+} ? P : never : never;
+type SpecsToParamMap<P extends string> = P extends string ? {
+    [N in RouteNameOfPath<P>]: RouteParamRecord<P>;
+} : never;
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+/** name → params map for a spec list — same shape `routes.gen.types.ts`
+ *  emits for file routes, so the two merge with `&`/`|`. */
+export type RouteParamsFromSpecs<Specs extends readonly RouteSpec[]> = UnionToIntersection<SpecsToParamMap<SpecPaths<Specs>>>;
+type SpecPresentations<S> = S extends {
+    path: infer P extends string;
+    presentation: infer Pr;
+} ? {
+    [N in RouteNameOfPath<P>]: Pr;
+} : {};
+export type RoutePresentationsFromSpecs<Specs extends readonly RouteSpec[]> = UnionToIntersection<SpecPresentations<Specs[number]>>;
+/** The spec-derived typing record `defineRoutes` brands onto its manifest
+ *  return — read it with the `ManifestRoute*` helpers, never directly. */
+export interface SpecRouteInfo<Specs extends readonly RouteSpec[]> {
+    readonly [specRouteTypes]: {
+        params: RouteParamsFromSpecs<Specs>;
+        presentations: RoutePresentationsFromSpecs<Specs>;
+    };
 }
+/** Pull the `{name: params}` map out of a `defineRoutes` manifest's type —
+ *  `RouteParams & ManifestRouteParams<typeof manifest>` merges file and
+ *  programmatic routes into one typed navigation surface. A plain
+ *  `RouteManifest` (untagged) extracts to `{}`, so `ManifestRouteNames`
+ *  is `never` and unions degrade to the file-derived names. */
+export type ManifestRouteParams<M> = M extends {
+    readonly [specRouteTypes]: {
+        params: infer P;
+    };
+} ? P : {};
+export type ManifestRouteNames<M> = keyof ManifestRouteParams<M> & string;
+export type ManifestRoutePresentations<M> = M extends {
+    readonly [specRouteTypes]: {
+        presentations: infer P;
+    };
+} ? P : {};
 export interface OpenWindowOptions {
     /** Data made available to the native window content resolver. */
     data?: Record<string, unknown>;
@@ -1624,3 +1731,4 @@ export interface ReadableStore<T> {
 export interface Store<T> extends ReadableStore<T> {
     set(next: T | ((prev: T) => T)): void;
 }
+export {};

package/types/generated/route-table.d.ts

@@ -29,7 +29,7 @@
  *  platform's file and is skipped entirely; unsuffixed files are the
  *  fallback (rank = prefer.length). Web callers pass ['web']; mobile
  *  callers pass the running OS first. */
-import type { Route, RouteManifest, RouteMeta, RouteSpec, RouteSpecSet } from './props.js';
+import type { Route, RouteManifest, RouteManifestJson, RouteMeta, RouteSpec, RouteSpecSet, SpecRouteInfo } from './props.js';
 /** Internal error carrier used by the public `redirect()` helper. Keeping
  * this in the shared route table gives both platform leaves the same guard
  * behavior without importing a platform runtime. */
@@ -43,8 +43,15 @@ export declare function deriveRouteManifest(files: Record<string, any>, prefer:
  *  from their own sources, e.g. `readdirSync` over a content dir). Each
  *  spec's `path` uses the route-dir vocabulary; `layouts` keys are path
  *  prefixes playing the `_layout` role. Same-name duplicates inside the
- *  set keep the later entry with a warn, matching merge precedence. */
-export declare function defineRoutes(input: readonly RouteSpec[] | RouteSpecSet): RouteManifest;
+ *  set keep the later entry with a warn, matching merge precedence.
+ *
+ *  The return is branded with the spec-derived route types — read them
+ *  with `ManifestRouteParams`/`ManifestRouteNames`/
+ *  `ManifestRoutePresentations` to merge programmatic names into the
+ *  app's typed navigation surface (`RouteName | …`, `RouteParams & …`). */
+export declare function defineRoutes<const Specs extends readonly RouteSpec[]>(input: Specs | (Omit<RouteSpecSet, 'routes'> & {
+    routes: Specs;
+})): RouteManifest & SpecRouteInfo<Specs>;
 /** Compose manifests into one — file-derived base plus any number of
  *  programmatic sets (`registerRoutes(mergeRouteManifests(fromDir, dynamic))`).
  *  Registration order is precedence: on a same-name collision the later
@@ -52,6 +59,10 @@ export declare function defineRoutes(input: readonly RouteSpec[] | RouteSpecSet)
  *  a warn fires once per colliding name. `layouts` merge key-wise the same
  *  way. `matchRoute` order is rebuilt by specificity after the merge. */
 export declare function mergeRouteManifests(...manifests: RouteManifest[]): RouteManifest;
+/** Serialize a manifest to the normalized `RouteManifestJson` shape — the
+ *  same list `xplat routes` emits for file routes, produced here for
+ *  programmatic/merged manifests so hosts consume one schema. */
+export declare function manifestToJson(manifest: RouteManifest): RouteManifestJson;
 /** Match URL path segments against a manifest — returns the winning meta
  *  plus extracted params, or null. First hit wins (routes are pre-sorted
  *  by specificity). */

package/types/generated/svg.mobile.d.ts

@@ -1,8 +1,8 @@
-import { SVGView } from './vendor/ui-svg/index.js';
+import { SVGView } from './vendor/ui-svg/src/index.js';
 import type { IconGlyph } from './props.js';
 declare module '@nativescript-community/octane/intrinsics' {
     interface NativeScriptElements {
-        svgview: Omit<Attributes<typeof SVGView>, 'src'> & {
+        svgview: Omit<import('@nativescript-community/octane/intrinsics').Attributes<typeof SVGView>, 'src'> & {
             /** SVGView awaits promise srcs — remote .svg URLs arrive as fetched markup. */
             src?: string | Promise<string>;
             stretch?: 'none' | 'fill' | 'aspectFit' | 'aspectFill';

package/types/generated/text-focus.d.ts

@@ -0,0 +1,3 @@
+/** Dismiss the keyboard and release native editing focus. NativeScript's
+ * dismissSoftInput returns void; its return value is not a fallback signal. */
+export declare function blurText(view: any): void;

package/types/generated/text-write.d.ts

@@ -1,4 +1,6 @@
-/** Controlled `text` write for TextInput/TextArea leaves. The driver's
+/** Whether a textChange is the synchronous echo of our controlled write. */
+export declare function isWritingText(view: object): boolean;
+/** Controlled `text` write for TextInput/TextArea/SearchInput leaves. The driver's
  *  generic prop path writes view.text verbatim; on Android the EditText
  *  setText resets the cursor to 0 on every controlled write. Park and
  *  restore the selection around the write (clamped to the new length so an

package/types/generated/theme/colorScheme.web.d.ts

@@ -0,0 +1,5 @@
+export type { ColorScheme } from '../props.js';
+import type { ColorScheme } from '../props.js';
+export declare function getColorScheme(): ColorScheme;
+export declare function subscribeSystemScheme(cb: () => void): () => void;
+export declare function useColorScheme(): ColorScheme;

package/types/generated/virtual-list-cell-pool.d.ts

@@ -0,0 +1,18 @@
+import type { VirtualListEntry } from './virtual-list-layout.js';
+export interface VirtualListCell<T> {
+    id: number;
+    typeKey: string;
+    generation: number;
+    entry: VirtualListEntry<T> | null;
+    rows: readonly VirtualListEntry<T>[];
+}
+/** Reuse physical hosts without retaining an off-window logical row subtree. */
+export declare class VirtualListCellPool<T> {
+    private cells;
+    private byId;
+    private nextId;
+    update(entries: readonly VirtualListEntry<T>[]): readonly VirtualListCell<T>[];
+    get(id: number): VirtualListCell<T> | undefined;
+    isCurrent(id: number, rowKey: string, generation: number): boolean;
+    clear(): void;
+}

package/types/index.macos.d.ts

@@ -67,7 +67,10 @@ export declare const SegmentedControl: Component<P.SegmentedControlProps>
 export declare const ScrollBox: Component<P.ScrollViewProps>
 export declare const ScrollView: Component<P.ScrollViewProps>
 /** AppKit fallback with keyed rows and one nonvirtualized scroll view. */
-export declare function VirtualList<T = any>(props: P.VirtualListProps<T> & { children?: any }): unknown
+export declare function VirtualList<T = any>(
+	props: P.VirtualListProps<T> & { children?: any },
+): unknown
+
 export declare const Image: Component<P.ImageProps>
 export declare const WebView: Component<P.WebViewProps>
 export declare const CameraView: Component
@@ -75,6 +78,7 @@ export declare const Overlay: Component<P.OverlayProps>
 export declare const Popover: Component<P.PopoverProps>
 export declare const Hoverable: Component<P.HoverableProps>
 export declare const Tooltip: Component<P.TooltipProps>
+export { Markdown, MarkdownScreen } from './generated/Markdown.js'
 export declare const Sheet: Component<P.SheetProps>
 export declare const Tabs: Component<P.TabsProps>
 export declare const Screen: Component<P.ScreenProps>
@@ -132,8 +136,16 @@ export declare function addRoutes(manifest: P.RouteManifest): void
 export declare function screenFor(name: string): P.ScreenTable[string] | undefined
 export declare function hrefFor(route: P.Route): string
 export declare function layoutsForRoute(name: string): any[]
-export declare function deriveRouteManifest(files: Record<string, any>, prefer: readonly string[], dir?: string): P.RouteManifest
-export declare function defineRoutes(input: readonly P.RouteSpec[] | P.RouteSpecSet): P.RouteManifest
+export declare function deriveRouteManifest(
+	files: Record<string, any>,
+	prefer: readonly string[],
+	dir?: string,
+): P.RouteManifest
+
+export declare function defineRoutes(
+	input: readonly P.RouteSpec[] | P.RouteSpecSet,
+): P.RouteManifest
+
 export declare function mergeRouteManifests(...manifests: P.RouteManifest[]): P.RouteManifest
 export declare function createStore<T>(initial: T): P.Store<T>
 export declare function useStore<T>(store: P.ReadableStore<T>): T