@octane-xplat/ui 0.6.0 → 0.7.0

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

@@ -0,0 +1,67 @@
+/** Web route store — the browser half of the nav contract. One linear URL
+ *  stack; `stack` names the conceptual outlet ('root' covers the app, a
+ *  named stack is the pane that owns it — parallel stacks map to nested
+ *  routes). URL shape: /<stack>/<path>?query or /<path>?query for root,
+ *  where <path> comes from the route-dir manifest — `app/demo/[id].tsrx`
+ *  pushes as /demo/<id-value>. Names not in the manifest keep the legacy
+ *  /<name>?params shape. Module-scope like every other store — the pane
+ *  that owns `stack` subscribes with useRoute(stack) and swaps content.
+ *
+ *  Modal routes (presentation 'modal' — `+modal` route files or a
+ *  pushRoute override) push a real URL but overlay instead of replacing:
+ *  `current` keeps the underlying route, `modalRoute` carries the modal.
+ *  Back (popstate or popRoute) dismisses it. */
+export type { Route } from './props.js';
+import type { Route, RouteManifest, RouteMeta, ScreenTable } from './props.js';
+/** Register the app's name → screen table. On web the table feeds
+ *  `screenFor` — the fallback outlet resolution in Tabs when no
+ *  `resolveScreen` prop is given; on native `pushRoute` resolves
+ *  `route.name` through it. `manifest` (from deriveRouteManifest) enables
+ *  path-param matching — call once from the shared routes module. */
+export declare function registerScreens(table: ScreenTable, manifest?: RouteMeta[]): void;
+/** One-call registration for route-dir apps — screens + URL patterns +
+ *  layouts all come from deriveRouteManifest. */
+export declare function registerRoutes(manifest: RouteManifest): void;
+/** Layer a programmatic manifest (from `defineRoutes`) over the registered
+ *  routes — same-name entries win over the base with a warn, so a host
+ *  framework can override a file route deliberately. Registered layers
+ *  survive later registerRoutes re-registration (e.g. routes.gen HMR). */
+export declare function addRoutes(manifest: RouteManifest): void;
+export declare function screenFor(name: string): ScreenTable[string] | undefined;
+/** Directory layouts wrapping a route, outermost → innermost — outlets
+ *  wrap their resolved element with these (`_layout.tsrx` files). */
+export declare function layoutsFor(name: string): any[];
+export { layoutsFor as layoutsForRoute };
+export declare function redirect(r: Route): never;
+export declare function pushRoute(r: Route): void;
+/** Web history is one linear stack — back pops whatever route is current;
+ *  per-stack pops aren't expressible, so `stack` is accepted for parity
+ *  and ignored. A pushed modal is the top entry, so back dismisses it. */
+export declare function popRoute(_stack?: string): void;
+/** No-op twin of the native leaf. Browser back is already real history —
+ *  there is no hardware-back event to intercept on web, so registered
+ *  interceptors never fire. Warns once so a mistaken call site isn't
+ *  silently absent. */
+export declare function addBackInterceptor(_fn: () => boolean): () => void;
+/** Current route if it targets `stack`, else null. */
+export declare function routeFor(stack: string): Route | null;
+/** Web has one linear browser history; expose its active route stack for parity. */
+export declare function routeStacks(): string[];
+/** The route active at boot — for deep-link tab selection. */
+export declare function currentRoute(): Route | null;
+/** The modal route overlaying the current one, if any. */
+export declare function currentModalRoute(): Route | null;
+/** Deep-link entry, web half — the URL *is* the route state, so this is a
+ *  plain pushRoute of the matched path (parity with the native leaf, where
+ *  apps wire `onDeepLink(pushDeepLink)`). */
+export declare function pushDeepLink(url: string): boolean;
+/** URL for a Route — Link's href and shareable-path helper. */
+export declare function hrefFor(r: Route): string;
+export declare function useRoute(stack: string): Route | null;
+/** Whether the selected conceptual stack has an in-app route to pop. A
+ * browser's pre-app history is intentionally not counted. */
+export declare function canGoBack(stack?: string): boolean;
+export declare function useCanGoBack(stack?: string): boolean;
+/** The modal route overlaying the shell — outlets render it above their
+ *  normal content (URL preserved underneath). */
+export declare function useModalRoute(): Route | null;

package/types/generated/safeAreaInsets.d.ts

@@ -0,0 +1,8 @@
+export interface SafeAreaInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**  Reads the root view's insets; Android and pre-attachment reads may be zero. */
+export declare function useSafeAreaInsets(): SafeAreaInsets;

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

@@ -0,0 +1,8 @@
+export interface SafeAreaInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**  Approximate CSS safe-area values, measured on mount and viewport resize. */
+export declare function useSafeAreaInsets(): SafeAreaInsets;

package/types/generated/sheet-detents.d.ts

@@ -0,0 +1,23 @@
+export interface SheetDetentsController {
+    /** Slide the panel in from below the screen edge — call once the host
+     *  is inside the RootLayout (the RootLayout open call replaces the
+     *  built-in enter/exit animation, which would fight detent offsets:
+     *  it always animates translateY to 0). */
+    enter: () => void;
+    detach: () => void;
+}
+/** Drag-to-snap detents on a RootLayout sheet host: a self-drawn grabber
+ *  strip (top-aligned grid child — the only drag target, so it never
+ *  fights inner scrolling) drives the host's translateY; the host is
+ *  sized to the largest detent and parked at the offset for the current
+ *  one. `closeNow` fires after the dismiss slide-out — the caller decides
+ *  what closing means (declarative `onDismiss` via RootLayout 'closed',
+ *  or the `openSheet` resolution).
+ *
+ *  In-window on native: the OS detent presentations
+ *  (UISheetPresentationController / BottomSheetBehavior via
+ *  BottomSheetDialogFragment) host a modal VC or a separate dialog
+ *  window — a different surface contract than the RootLayout child this
+ *  sheet is (UIModal/MaterialDialog own the modal path), so the snap
+ *  mechanics are self-drawn and identical to the web leaf. */
+export declare function attachSheetDetents(host: any, detents: readonly number[], closeNow: () => void): SheetDetentsController;

package/types/generated/sheet-detents.web.d.ts

@@ -0,0 +1,13 @@
+export interface SheetDetentsController {
+    detach: () => void;
+}
+/** Drag-to-snap detents on a `.vx-sheet` panel: a self-drawn grabber strip
+ *  (the only drag target — it never fights inner scrolling) drives the
+ *  panel's translateY; the panel is sized to the largest detent and parked
+ *  at the offset for the current one. `closeNow` fires after the dismiss
+ *  slide-out — the caller decides what closing means (declarative
+ *  `onDismiss` or the `openSheet` resolution). In-window on every target —
+ *  the OS detent presentations (UISheetPresentationController /
+ *  BottomSheetDialog) host a modal VC/dialog window, not a RootLayout
+ *  child, so the snap mechanics stay self-drawn for pixel parity. */
+export declare function attachSheetDetents(panel: HTMLElement, detents: readonly number[], closeNow: () => void): SheetDetentsController;

package/types/generated/sheet-service.d.ts

@@ -0,0 +1,11 @@
+import { GridLayout } from '@nativescript/core';
+import type { ModalOpenResult, OpenSheet } from './props.js';
+/** The most recently opened sheet's host view — for harness asserts (view
+ *  identity beats tree search; the owning rootlayout may unload/reload). */
+export declare function sheetHost(): GridLayout | null;
+/** Close the most recently opened sheet (resolve with `result`). */
+export declare function closeSheet(result?: ModalOpenResult): void;
+/** Imperative in-window sheet: a dedicated Octane root on a bottom-docked
+ *  GridLayout host opened on the CURRENT rootlayout (topRootLayout — the
+ *  service has no declaring view). Resolves when the sheet closes. */
+export declare const openSheet: OpenSheet;

package/types/generated/sheet-service.web.d.ts

@@ -0,0 +1,6 @@
+import type { ModalOpenResult, OpenSheet } from './props.js';
+/** Close the most recently opened sheet (resolve with `result`). */
+export declare function closeSheet(result?: ModalOpenResult): void;
+/** Imperative in-window sheet: portal layer at document root, bottom-
+ *  anchored panel, dedicated Octane root. Resolves when the sheet closes. */
+export declare const openSheet: OpenSheet;

package/types/generated/sheet-snap.d.ts

@@ -0,0 +1,18 @@
+/** Detent math shared by the web/native sheet-detents attachments.
+ *  Detents are viewport-height fractions; the panel is sized to the
+ *  largest detent and parked at the translateY offset for the current
+ *  one, so a snap is just a transform write — no layout thrash. */
+/** Downward/upward finger speed (px/s web, dip/s native) that overrides
+ *  nearest-detent snapping — a fling snaps one detent in its direction. */
+export declare const DETENT_FLICK_VELOCITY = 500;
+/** Sorted, filtered, deduped detent fractions. Empty → the caller keeps
+ *  the content-sized sheet behavior (detents off). */
+export declare function normalizeDetents(input?: readonly number[]): number[];
+/** Resting translateY for a detent: the panel is `max * vh` tall, so the
+ *  portion below the screen edge is `(max - detent) * vh`. */
+export declare function detentOffset(detents: readonly number[], index: number, vh: number): number;
+/** Snap target for a release at translateY `ty` with vertical velocity
+ *  `vy` (positive = dragging down). Returns the detent index, or -1 to
+ *  dismiss: released below half of the smallest detent, or a downward
+ *  fling while at/below it. */
+export declare function snapDetentIndex(ty: number, vy: number, detents: readonly number[], vh: number): number;

package/types/generated/stacks.d.ts

@@ -0,0 +1,9 @@
+import { Frame } from '@nativescript/core';
+export declare function registerStack(name: string, frame: Frame): void;
+export declare function getStack(name: string): Frame | undefined;
+/** All registered stacks in registration order — for hardware-back
+ *  resolution (pop whichever stack is visibly on top). */
+export declare function stackEntries(): IterableIterator<[string, Frame]>;
+/** Internal: route.native attaches frame listeners as stacks appear —
+ *  named frames can register after a useRoute subscription ran. */
+export declare function onStackRegistered(cb: (name: string, frame: Frame) => void): void;

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

@@ -0,0 +1,4 @@
+/** Web twin — one linear URL stack; named stacks don't apply. */
+export declare function registerStack(_name: string, _frame: unknown): void;
+export declare function getStack(_name: string): undefined;
+export declare function stackEntries(): IterableIterator<[string, never]>;

package/types/generated/store.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Module-scope store — the shared-state primitive for this stack.
+ *
+ * Why it exists: the universal (native) renderer RETAINS child components
+ * whose props are shallow-unchanged when a parent re-renders — their render
+ * functions do not re-run, so a bare `store.get()` in a child stays stale
+ * (the DOM renderer re-invokes them, React-style). The portable rule is:
+ * every component that reads shared state subscribes to it. The renderer-owned
+ * `use-store` leaves implement that subscription; this file is the hook-free
+ * half, so plain `.ts` is correct.
+ */
+import type { Store } from './props.js';
+export type { ReadableStore, Store } from './props.js';
+export declare function createStore<T>(initial: T): Store<T>;

package/types/generated/styled.d.ts

@@ -0,0 +1,20 @@
+/**
+ * styled() — decision #7, Tamagui-shaped but CSS-backed. base/variants are
+ * class strings composed into className; the leaf decides what those classes
+ * mean per platform.
+ *
+ *   const DangerBtn = styled(Pressable, { base: 'btn', variants: { danger: 'bg-danger' } });
+ *   <DangerBtn danger />  →  className=['btn','bg-danger']
+ *
+ * Universal constraint (Exp 16): component elements require the
+ * compiler-stamped UNIVERSAL_COMPONENT mark and JSX/`@{ }` only lowers at
+ * module level — so a component factory can't be authored with JSX. This
+ * leaf stamps the mark itself via defineUniversalComponent and returns
+ * universalComponent(...) elements directly. If upstream exposes a blessed
+ * factory path, switch to it (driver-level fix candidate). */
+export declare function styled<P extends {
+    className?: any;
+}, V extends Record<string, any>>(Base: (props: P) => any, def: {
+    base?: any;
+    variants?: V;
+}): import("@nativescript-community/octane").UniversalComponent<P & { [K in keyof V]?: boolean | undefined; }>;

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

@@ -0,0 +1,10 @@
+/** @jsxImportSource octane */
+/**
+ * styled() — decision #7. Web side: DOM codegen lowers JSX in nested
+ * functions fine, so the factory is a plain component. */
+export declare function styled<P extends {
+    className?: any;
+}, V extends Record<string, any>>(Base: (props: P) => any, def: {
+    base?: any;
+    variants?: V;
+}): (props: P & { [K in keyof V]?: boolean; }) => import("octane/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { SVGView } from './vendor/ui-svg/index.js';
+import type { IconGlyph } from './props.js';
+declare module '@nativescript-community/octane/intrinsics' {
+    interface NativeScriptElements {
+        svgview: Omit<Attributes<typeof SVGView>, 'src'> & {
+            /** SVGView awaits promise srcs — remote .svg URLs arrive as fetched markup. */
+            src?: string | Promise<string>;
+            stretch?: 'none' | 'fill' | 'aspectFit' | 'aspectFill';
+        };
+    }
+}
+/** True when an `src` carries SVG: inline markup, an svg data URI, or an
+ *  .svg path/URL. Anything else stays on the raster <image> path. */
+export declare function isSvgSrc(src: string): boolean;
+/** Normalize an svg-shaped src into SVGView's grammar: file/resource paths and
+ *  markup pass through, data URIs decode to markup, remote URLs fetch to
+ *  markup (SVGView has no fetch of its own — it awaits promise srcs). */
+export declare function svgSource(src: string): string | Promise<string>;
+/** IconGlyph → a full `<svg>` string for SVGView. `svg` path data gets a
+ *  `<path>` with the requested fill; `markup` wraps inside a viewBox shell
+ *  with `color`/`fill` set on the root so `currentColor` and default-fill
+ *  children pick up the tint. */
+export declare function glyphSvgMarkup(glyph: IconGlyph, color?: string): string | undefined;

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

@@ -0,0 +1,16 @@
+/** 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. */
+export declare function attachTapToBlur(view: any): () => void;

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

@@ -0,0 +1,9 @@
+/** Controlled `text` write for TextInput/TextArea 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
+ *  append-shrink can't throw). iOS keeps the plain write — UITextField's
+ *  text setter preserves the selected text range already.
+ *  Returns without writing when the value already matches — the textChange
+ *  echo of the user's own typing must not bounce back through setText. */
+export declare function writeText(view: any, value: string | undefined | null): void;

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

@@ -0,0 +1,6 @@
+export type { ColorScheme } from '../props.js';
+import type { ColorScheme } from '../props.js';
+export declare function getColorScheme(): ColorScheme;
+export declare function subscribeSystemScheme(cb: () => void): () => void;
+/** Reactive system appearance — 'light' | 'dark', re-renders on OS change. */
+export declare function useColorScheme(): ColorScheme;

package/types/generated/theme/colorScheme.linux.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/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/theme/status-bar-scheme.mobile.d.ts

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

package/types/generated/theme/theme-scheme.d.ts

@@ -0,0 +1,20 @@
+export type ThemePreference = 'light' | 'dark' | 'system';
+/** App-level theme override. 'system' clears the override and follows the OS. */
+export declare function setThemePreference(p: ThemePreference): void;
+export declare function getThemePreference(): ThemePreference;
+/** The effective scheme: explicit override if set, else system appearance. */
+export declare function getThemeScheme(): 'light' | 'dark';
+/** Reactive effective scheme — re-renders on override or OS change. */
+export declare function useThemeScheme(): 'light' | 'dark';
+/** Class string to stamp on independently-mounted roots (portal hosts,
+ *  overlay/sheet/modal/toast containers): 'ns-dark dark' when effective
+ *  dark, '' otherwise. Both names because tokens.css publishes both
+ *  selectors and hosts may render either vocabulary. */
+export declare function themeSchemeClasses(): string;
+/** Subscribe imperative hosts to effective-scheme changes; returns an
+ *  unsubscribe. Use for hosts that live outside any render cycle. */
+export declare function onThemeSchemeChange(cb: () => void): () => void;
+/** Stamp `base + themeSchemeClasses()` onto an imperative host (NS view or
+ *  DOM element) and keep it live — returns an unsubscribe to call when the
+ *  host closes. Works on both leaves since both honor `.className`. */
+export declare function applyThemeClasses(view: any, base: string): () => void;

package/types/generated/toast-anchor.d.ts

@@ -0,0 +1,4 @@
+import type { ToastContent, ToastOptions } from './props.js';
+/**  FIFO queue. Anchored options use Popover; unanchored options use the
+ * RootLayout with top/bottom start/end alignment. */
+export declare function showToast(content: ToastContent, options?: ToastOptions): void;

package/types/generated/toast-anchor.web.d.ts

@@ -0,0 +1,4 @@
+import type { ToastContent, ToastOptions } from './props.js';
+/**  FIFO queue. `anchor` uses the same portal positioning as Popover; without
+ * one, top/bottom and their start/end alignment variants use the viewport. */
+export declare function showToast(content: ToastContent, options?: ToastOptions): void;

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

@@ -0,0 +1,8 @@
+/** Per-element transform composition for imperative writes. The DOM has a
+ *  single `transform` string where native has discrete view props, so web
+ *  keeps the last-written value per transform prop and re-joins them —
+ *  an AnimatedValue on `rotate` and a setTranslate drag on the same
+ *  element don't clobber each other. */
+/** Write one transform prop without disturbing the element's other
+ *  transform components (or its stylesheet/base transform). */
+export declare function writeTransformProp(el: HTMLElement, prop: string, value: number): void;

package/types/generated/translate.d.ts

@@ -0,0 +1,5 @@
+import type { SetTranslate } from './props.js';
+/** Imperative translate write on a bound view — the gesture seam. NS
+ *  views carry real translateX/translateY properties (dips), so the write
+ *  is a direct prop set — synchronous on the UI thread. */
+export declare const setTranslate: SetTranslate;

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

@@ -0,0 +1,6 @@
+import type { SetTranslate } from './props.js';
+/** Imperative translate write on a bound view — the gesture seam. Called
+ *  per frame from pan handlers (docs/animation-gestures.md: animation
+ *  writes imperative, state stays declarative). Composes with other
+ *  transform writes on the same element via ./transform.web. */
+export declare const setTranslate: SetTranslate;

package/types/generated/use-back.d.ts

@@ -0,0 +1,6 @@
+/**  Component-scoped back interceptor — mounted screens register in
+ *  render order, so the topmost screen's handler wins (interceptors run
+ *  most-recent-first) before the framework's default stack pop. Return
+ *  true to consume the press. Android-only: iOS has no hardware back,
+ *  so the handler simply never fires there. */
+export declare function useBackInterceptor(fn: () => boolean): void;

package/types/generated/use-back.web.d.ts

@@ -0,0 +1,7 @@
+/**  Component-scoped back interceptor — mounted screens register in
+ *  render order, so the topmost screen's handler wins (interceptors run
+ *  most-recent-first) before the framework's default stack pop. Return
+ *  true to consume the press. On web there is nothing to intercept —
+ *  the browser owns back — so this registers a never-firing handler and
+ *  addBackInterceptor warns once. */
+export declare function useBackInterceptor(fn: () => boolean): void;

package/types/generated/use-store.d.ts

@@ -0,0 +1,9 @@
+import type { ReadableStore } from './props.js';
+/**
+ * Subscribe the calling component to a module-scope store — the portable
+ * shared-state read. On the universal renderer a re-rendering parent retains
+ * unchanged-prop children, so a component that reads store state must carry
+ * its own subscription; on web this is equally correct (and costs nothing).
+ * `select` must return an Object.is-stable value per store state. */
+export declare function useStore<T>(store: ReadableStore<T>): T;
+export declare function useStore<T, S>(store: ReadableStore<T>, select: (state: T) => S): S;

package/types/generated/use-store.web.d.ts

@@ -0,0 +1,9 @@
+import type { ReadableStore } from './props.js';
+/**
+ * Subscribe the calling component to a module-scope store — the portable
+ * shared-state read. On the universal renderer a re-rendering parent retains
+ * unchanged-prop children, so a component that reads store state must carry
+ * its own subscription; on web this is equally correct (and costs nothing).
+ * `select` must return an Object.is-stable value per store state. */
+export declare function useStore<T>(store: ReadableStore<T>): T;
+export declare function useStore<T, S>(store: ReadableStore<T>, select: (state: T) => S): S;

package/types/generated/useMeasure.d.ts

@@ -0,0 +1,3 @@
+import type { MeasureResult, UseMeasureOptions } from './props.js';
+/**  Binds to a NativeScript view and observes screen-relative DIP bounds by default. */
+export declare function useMeasure(options?: UseMeasureOptions): MeasureResult;

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

@@ -0,0 +1,3 @@
+import type { MeasureResult, UseMeasureOptions } from './props.js';
+/**  Binds to a web element and observes its viewport-relative bounds by default. */
+export declare function useMeasure(options?: UseMeasureOptions): MeasureResult;

package/types/generated/vendor/ui-svg/index.common.d.ts

@@ -0,0 +1,7 @@
+import { File, ImageAsset, Property, View } from '@nativescript/core';
+export type Stretch = 'none' | 'fill' | 'aspectFill' | 'aspectFit';
+export declare const srcProperty: Property<SVGView, string | ImageAsset | File>;
+export declare const stretchProperty: Property<SVGView, Stretch>;
+export declare class SVGView extends View {
+    src: string;
+}

package/types/generated/vendor/ui-svg/index.d.ts

@@ -0,0 +1 @@
+export { SVGView } from './index.common.js';

package/types/generated/vendor/ui-svg/index.ios.d.ts

@@ -0,0 +1,13 @@
+import { File, ImageAsset } from '@nativescript/core';
+import { SVGView as SVGViewBase, srcProperty, stretchProperty } from './index.common.js';
+export declare function getSVGKImage(src: string | ImageAsset | File): SVGKImage | null;
+export declare class SVGView extends SVGViewBase {
+    [srcProperty.setNative]: (value: any) => void;
+    [stretchProperty.setNative]: (value: "none" | "aspectFill" | "aspectFit" | "fill") => void;
+    aspectRatio: number;
+    _imageSourceAffectsLayout: boolean;
+    createNativeView(): SVGKFastImageView;
+    _setNativeClipToBounds(): void;
+    onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void;
+    handleSrc(src: any): Promise<void>;
+}

package/types/generated/virtual-list-layout.d.ts

@@ -0,0 +1,44 @@
+export type VirtualListKey = string | number;
+export interface VirtualListRange {
+    start: number;
+    end: number;
+    top: number;
+    bottom: number;
+}
+export interface VirtualListEntry<T> {
+    item: T;
+    index: number;
+    key: VirtualListKey;
+    rowKey: string;
+    type: VirtualListKey;
+    typeKey: string;
+}
+export interface VirtualListSizeRecord {
+    width: number;
+    height: number;
+}
+export declare const VIRTUAL_LIST_ESTIMATED_ROW_SIZE = 48;
+export declare const VIRTUAL_LIST_MIN_TYPE_SAMPLES = 4;
+export declare function createVirtualListEntries<T>(items: readonly T[], keyExtractor: (item: T, index: number) => VirtualListKey, getItemType?: (item: T, index: number) => VirtualListKey): VirtualListEntry<T>[];
+export declare function virtualListMeasurementKey(rowKey: string, hasSeparator: boolean): string;
+export declare function estimateVirtualListSizes<T>(entries: readonly VirtualListEntry<T>[], hasSeparator: boolean, width: number, measurements: ReadonlyMap<string, VirtualListSizeRecord>): number[];
+/** Prefix-size index for variable-height rows. Updates and offset lookups are
+ *  logarithmic, so measuring a row does not scan the whole data set. */
+export declare class VirtualListSizeIndex {
+    private sizes;
+    private tree;
+    get length(): number;
+    get total(): number;
+    reset(sizes: readonly number[]): void;
+    get(index: number): number;
+    set(index: number, size: number): number;
+    /** Sum of the first `count` row heights. */
+    prefix(count: number): number;
+    /** Index of the row containing `offset`; exact row boundaries select the
+     *  row that starts at that boundary. */
+    indexAt(offset: number): number;
+}
+export declare function virtualListRange(sizes: VirtualListSizeIndex, scrollOffset: number, viewportSize: number, overscanSize?: number): VirtualListRange;
+/** Renderer keys include the item type so changing a key's type remounts its
+ *  row instead of carrying component state into an incompatible template. */
+export declare function virtualListRowKey(key: VirtualListKey, type: VirtualListKey): string;

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

@@ -0,0 +1,3 @@
+export { Hoverable } from '../Hoverable.web.js';
+export { Tooltip } from '../Tooltip.web.js';
+export type { HoverableProps, TooltipProps } from '../props.js';

package/types/generated/windows.d.ts

@@ -0,0 +1,3 @@
+import type { OpenWindowOptions } from './props.js';
+/** Open another NativeScript window and pass app-owned data to its resolver. */
+export declare function openWindow(options?: OpenWindowOptions): void;

package/types/generated/windows.linux.d.ts

@@ -0,0 +1,15 @@
+import type { OpenWindowOptions } from './props.js';
+export interface LinuxWindowHandle {
+    readonly id: string;
+    readonly closed: Promise<void>;
+    close(): void;
+    setTitle(title: string): void;
+}
+export declare function openWindow(options?: OpenWindowOptions & {
+    kind?: 'regular' | 'dialog';
+    title?: string;
+    size?: {
+        width: number;
+        height: number;
+    };
+}): LinuxWindowHandle | Window | null;

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

@@ -0,0 +1,3 @@
+import type { OpenWindowOptions } from './props.js';
+/** Open a browser window using the current route unless a URL is supplied. */
+export declare function openWindow(options?: OpenWindowOptions): Window | null;