@octane-xplat/ui 0.7.2 → 0.9.0

package/types/generated/index.shared.web.d.ts

@@ -0,0 +1,114 @@
+export { View } from './View.js';
+export { View as Column } from './View.js';
+export { Row } from './Row.js';
+export { Grid } from './Grid.js';
+export { Stack } from './Stack.js';
+export { Absolute } from './Absolute.js';
+export type { PanEvent, SwipeEvent, SetTranslate } from './props.js';
+export { setTranslate } from './translate.web.js';
+export { Spacer } from './Spacer.js';
+export { Text } from './Text.js';
+export { Markdown, MarkdownScreen } from './Markdown.js';
+export type { MdDoc, MdNode, MdInline } from './Markdown.js';
+export { RichText, RichTextSpan } from './RichText.js';
+export { Pressable } from './Pressable.js';
+export { Button } from './Button.js';
+export { Collapsible } from './Collapsible.js';
+export { Accordion } from './Accordion.js';
+export { Checkbox } from './Checkbox.js';
+export { RadioGroup } from './RadioGroup.js';
+export { DropdownMenu } from './DropdownMenu.js';
+export { ContextMenu } from './ContextMenu.js';
+export { Badge } from './Badge.js';
+export { Separator } from './Separator.js';
+export { Skeleton } from './Skeleton.js';
+export { Avatar } from './Avatar.js';
+export { AvatarGroup } from './AvatarGroup.js';
+export type { AccordionItemSpec, AccordionProps, AvatarGroupProps, AvatarProps, BadgeProps, ButtonProps, CheckboxProps, CollapsibleProps, ContextMenuProps, DropdownMenuProps, MenuItem, RadioGroupProps, RadioOption, SegmentedControlProps, SeparatorProps, SkeletonProps, } from './props.js';
+export { FormField } from './FormField.js';
+export { FieldGroup } from './FieldGroup.js';
+export { ListItem } from './ListItem.js';
+export { InputNumber } from './InputNumber.js';
+export { PinInput } from './PinInput.js';
+export { Select } from './Select.js';
+export { SelectMenu, Combobox, InputMenu } from './aliases.js';
+export { InputTags } from './InputTags.js';
+export { InputRating } from './InputRating.js';
+export { CheckboxGroup } from './CheckboxGroup.js';
+export type { CheckboxGroupProps, FieldGroupProps, ListItemComponent, ListItemProps, ListItemSlotProps, FormFieldProps, InputNumberProps, InputRatingProps, InputTagsProps, PinInputProps, SelectOption, SelectProps, } from './props.js';
+export { Breadcrumb } from './Breadcrumb.js';
+export { Pagination } from './Pagination.js';
+export { Stepper } from './Stepper.js';
+export { NavigationMenu } from './NavigationMenu.js';
+export { CommandPalette } from './CommandPalette.js';
+export type { BreadcrumbItem, BreadcrumbProps, CommandPaletteProps, NavigationMenuItem, NavigationMenuProps, PaginationProps, StepperProps, StepperStep, } from './props.js';
+export { Table } from './Table.js';
+export { Timeline } from './Timeline.js';
+export { Tree } from './Tree.js';
+export { Alert } from './Alert.js';
+export { Card } from './Card.js';
+export { Chip } from './Chip.js';
+export { Kbd } from './Kbd.js';
+export { Empty } from './Empty.js';
+export { Banner } from './Banner.js';
+export { User } from './User.js';
+export { ProgressGroup } from './ProgressGroup.js';
+export type { AlertProps, BannerProps, CardProps, ChipProps, EmptyProps, KbdProps, ProgressGroupProps, TableColumn, TableProps, TimelineItem, TimelineProps, TreeNode, TreeProps, UserProps, } from './props.js';
+export { Link } from './Link.js';
+export { NavLink } from './NavLink.js';
+export { TextInput } from './TextInput.js';
+export { TextArea } from './TextArea.js';
+export { SearchInput } from './SearchInput.js';
+export { SegmentedControl } from './SegmentedControl.js';
+export { ScrollBox } from './ScrollBox.js';
+export { ScrollView } from './ScrollView.js';
+export { VirtualList } from './VirtualList.js';
+export type { VirtualListProps } from './props.js';
+export { Image } from './Image.js';
+export { WebView } from './WebView.js';
+export type { WebViewContentSize, WebViewHandle, WebViewLoadEvent, WebViewProps } from './props.js';
+export { Overlay } from './Overlay.js';
+export { Popover } from './Popover.js';
+export { Hoverable } from './Hoverable.js';
+export { Tooltip } from './Tooltip.js';
+export { showToast } from './toast-anchor.js';
+export type { HoverableProps, OverlayProps, PopoverAnchorRef, PopoverProps, PopoverPlacement, ToastContent, ToastOptions, ToastPosition, TooltipProps, } from './props.js';
+export { useAnimation } from './anim.js';
+export type { AnimatedValue } from './anim.js';
+export { useThemeScheme, getThemeScheme, setThemePreference, getThemePreference, themeSchemeClasses, onThemeSchemeChange, applyThemeClasses, } from './theme/theme-scheme.js';
+export { useColorScheme, getColorScheme } from './theme/colorScheme.web.js';
+export type { ColorScheme } from './theme/colorScheme.web.js';
+export { styled } from './styled.js';
+export { openWindow } from './windows.web.js';
+export { Screen } from './Screen.js';
+export { Tabs } from './Tabs.js';
+export type { TabSpec } from './Tabs.js';
+export { Switch } from './Switch.js';
+export { SafeArea } from './SafeArea.js';
+export { KeyboardAvoiding } from './KeyboardAvoiding.js';
+export { Drawer } from './Drawer.js';
+export { useSafeAreaInsets } from './safeAreaInsets.js';
+export type { SafeAreaInsets } from './safeAreaInsets.js';
+export { useMeasure } from './useMeasure.js';
+export type { MeasureBounds, MeasureResult, UseMeasureOptions } from './props.js';
+export { ActivityIndicator } from './ActivityIndicator.js';
+export { Meter } from './Meter.js';
+export { Slider } from './Slider.js';
+export { Icon } from './Icon.js';
+export { Heading } from './Heading.js';
+export { registerIcon, registerIcons } from './icons.js';
+export type { IconGlyph } from './icons.js';
+export type { ActivityIndicatorProps, HeadingProps, IconProps, MeterProps, RefreshProps, SearchInputProps, SliderProps, } from './props.js';
+export { isNative } from './platform.web.js';
+export { registerStack, getStack, stackEntries } from './stacks.web.js';
+export { pushRoute, popRoute, routeStacks, pushDeepLink, routeFor, currentRoute, currentModalRoute, canGoBack, useCanGoBack, useRoute, useModalRoute, redirect, addBackInterceptor, registerScreens, registerRoutes, addRoutes, screenFor, hrefFor, layoutsForRoute, } from './route.web.js';
+export { useBackInterceptor } from './use-back.js';
+export { deriveRouteManifest, defineRoutes, mergeRouteManifests, manifestToJson, } from './route-table.js';
+export type { BeforeLoad, BeforeLoadArgs, LinkProps, NavLinkProps, Route, RouteContext, RouteHead, RouteHeadExport, RouteMeta, RouteManifest, RouteManifestJson, RouteJson, RouteDataMode, RouteNameOfPath, RouteParamsFromSpecs, RoutePathParams, RoutePresentationsFromSpecs, RouteSpec, RouteSpecSet, ManifestRouteNames, ManifestRouteParams, ManifestRoutePresentations, SpecRouteInfo, ScreenTable, ModalOpenResult, OpenWindowOptions, } from './props.js';
+export { createStore } from './store.js';
+export type { Store, ReadableStore } from './store.js';
+export { useStore } from './use-store.js';
+export { Sheet } from './Sheet.js';
+export { openSheet, closeSheet } from './sheet-service.web.js';
+export type { SheetProps, SheetOpenOptions, OpenSheet } from './props.js';
+export type { AbsoluteProps, DrawerProps, GridProps, ImageProps, KeyboardAvoidingProps, LayoutChildProps, PressableProps, RichTextProps, RichTextSpanProps, RowProps, ScreenProps, SafeAreaProps, ScrollBoxProps, ScrollViewProps, SpacerProps, StackProps, SwitchProps, TabsProps, TextAreaProps, TextInputProps, TextProps, ViewProps, } from './props.js';

package/types/generated/index.web.d.ts

@@ -1 +1 @@
-export * from './index.shared.js';
+export * from './index.shared.web.js';

package/types/generated/modal-focus.web.d.ts

@@ -0,0 +1,3 @@
+/** Own keyboard focus only for a modal body portal. Inert preserves the
+ * background's state while hiding it from both focus and the browser AX tree. */
+export declare function isolateModalFocus(layer: HTMLElement, panel: HTMLElement, dismiss: () => void): () => void;

package/types/generated/navigation-request.d.ts

@@ -0,0 +1,10 @@
+/** A redirect shares its request with the original stack. Claiming another
+ * stack supersedes its pending navigation without reviving a stale request. */
+export interface NavigationRequest {
+    isCurrent(): boolean;
+    claim(stack: string): boolean;
+}
+export declare function createNavigationRequests(): {
+    invalidate: (stack: string) => number;
+    begin(stack: string): NavigationRequest;
+};

package/types/generated/overlay-lifetime.mobile.d.ts

@@ -0,0 +1,10 @@
+import type { GridLayout, RootLayout, RootLayoutOptions } from '@nativescript/core';
+/** Own the resources of one independently mounted overlay. RootLayout emits
+ * closed before removing the host, so that notification must never reenter close. */
+export declare function createOverlayLifetime(owner: RootLayout, host: GridLayout, root: {
+    unmount(): void;
+}, label: string, onFinish: (dismissed: boolean) => void): {
+    own(cleanup: () => void): void;
+    close(): void;
+    open(options?: RootLayoutOptions, afterOpen?: () => void | Promise<void>): void;
+};

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/tap-to-blur.ios.d.ts

@@ -0,0 +1,13 @@
+/** Tap-outside-to-blur: iOS keeps a focused UITextField/UITextView as first
+ *  responder until something else takes it, so a tap on blank chrome never
+ *  dismisses the keyboard on its own.
+ *
+ *  iOS: a single window-level UITapGestureRecognizer (ref-counted across
+ *  attach calls) sees every touch in the app window — popups/sheets included —
+ *  where a recognizer on an intermediate container proved unreliable. On each
+ *  tap we hit-test and resign first responder unless the hit view is an
+ *  editable text view (otherwise the field would focus-then-blur in the same
+ *  tap — recognizers fire on touch-up, after the field's touch-down focus).
+ *  Keyboard taps live in a separate UIWindow, so they never reach it.
+ *  `cancelsTouchesInView` stays false so taps still reach buttons. */
+export declare function attachTapToBlur(view: any): () => void;

package/types/generated/tap-to-blur.mobile.d.ts

@@ -1,16 +1,2 @@
-/** Tap-outside-to-blur: iOS keeps a focused UITextField/UITextView as first
- *  responder until something else takes it, so a tap on blank chrome never
- *  dismisses the keyboard on its own.
- *
- *  iOS: a single window-level UITapGestureRecognizer (ref-counted across
- *  attach calls) sees every touch in the app window — popups/sheets included —
- *  where a recognizer on an intermediate container proved unreliable. On each
- *  tap we hit-test and resign first responder unless the hit view is an
- *  editable text view (otherwise the field would focus-then-blur in the same
- *  tap — recognizers fire on touch-up, after the field's touch-down focus).
- *  Keyboard taps live in a separate UIWindow, so they never reach it.
- *  `cancelsTouchesInView` stays false so taps still reach buttons.
- *
- *  Android: hides the soft keyboard from the currently focused view when a
- *  tap lands on the attached container. */
+/** Hide the Android soft keyboard when the user taps the attached view. */
 export declare function attachTapToBlur(view: any): () => void;

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