@octane-xplat/ui 0.10.0 → 0.11.0

package/types/generated/SideNav.macos.d.ts

@@ -0,0 +1,19 @@
+import type { SideNavCollapseButtonProps, SideNavHeadingProps, SideNavItemProps, SideNavProps, SideNavSectionProps } from './props.js';
+import { SideNavCollapseContext, SideNavRenderContext, useSideNavCollapse, useSideNavRenderMode } from './nav-contexts.js';
+export { SideNavRenderContext, SideNavCollapseContext, useSideNavCollapse, useSideNavRenderMode };
+/**  SideNav — the app's side navigation panel. Header/topContent are pinned,
+ *  children scroll, footer/footerIcons pin to the bottom. Inside AppShell it
+ *  adopts the render mode its context sets (topbar / drawer /
+ *  drawer-content). */
+export declare function SideNav(props: SideNavProps): unknown;
+/**  SideNavSection — titled group of items inside the scrollable area. */
+export declare function SideNavSection(props: SideNavSectionProps): unknown;
+/**  SideNavHeading — identity block at the top of the rail. */
+export declare function SideNavHeading(props: SideNavHeadingProps): unknown;
+/**  SideNavItem — one nav row. Native leaf: Pressable rows; `href` routes
+ *  through `followHref`. Collapsed rail shows the icon and a flyout for
+ *  children via the shared Popover. */
+export declare function SideNavItem(props: SideNavItemProps): unknown;
+/**  SideNavCollapseButton — chevron control bound to the nearest
+ *  SideNavCollapseContext. */
+export declare function SideNavCollapseButton(props: SideNavCollapseButtonProps): unknown;

package/types/generated/Skeleton.macos.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { SkeletonProps } from "./props.js";
+/**  Skeleton — placeholder block while content loads. Sizing via
+ *  `width`/`height` or the app's `vx-skeleton` styling. */
+export declare function Skeleton(props: SkeletonProps): unknown;

package/types/generated/StatusDot.macos.d.ts

@@ -0,0 +1,5 @@
+import type { StatusDotProps } from './props.js';
+/**  StatusDot — macOS leaf. The AppKit host has no `animate` — `isPulsing` is
+ *  a steady dot here (documented). Variant colors come from the scheme
+ *  palette mirror since the host has no CSS layer. */
+export declare function StatusDot(props: StatusDotProps): unknown;

package/types/generated/Stepper.macos.d.ts

@@ -0,0 +1,4 @@
+import type { StepperProps } from "./props.js";
+/**  Stepper — numbered step row with connectors. Steps before `current`
+ *  show a done mark; tapping a non-disabled step calls `onStepChange`. */
+export declare function Stepper(props: StepperProps): unknown;

package/types/generated/TabList.macos.d.ts

@@ -0,0 +1,18 @@
+import type { TabListProps, TabProps, TabMenuProps } from './props.js';
+import { TabListContext } from './nav-contexts.js';
+export { TabListContext };
+export { useTabListContext } from './nav-contexts.js';
+/**  TabList — tab strip providing TabListContext to Tab/TabMenu children.
+ *  Native leaf: a horizontal flexbox row; `overflow` `auto`/`scroll` wraps it
+ *  in a horizontal scroller and the selected tab is scrolled into view. The
+ *  WAI-ARIA tablist pattern carries `tab` semantics to each stop; there's no
+ *  composite-widget arrow model on pointer platforms. `role="tablist"`
+ *  switches item semantics; the strip itself doesn't gain native grouping. */
+export declare function TabList(props: TabListProps): unknown;
+/**  Tab — a single stop in a TabList. Native leaf renders a Pressable;
+ *  `href` activates through the deep-link/route table (`followHref`) in
+ *  addition to reporting selection. */
+export declare function Tab(props: TabProps): unknown;
+/**  TabMenu — overflow trigger inside a TabList. Native leaf opens the
+ *  shared anchored Popover with menuitemradio-style rows. */
+export declare function TabMenu(props: TabMenuProps): unknown;

package/types/generated/Table.macos.d.ts

@@ -0,0 +1,4 @@
+import type { TableProps } from "./props.js";
+/**  Table — self-drawn grid. Bounded and unvirtualized: large datasets
+ *  belong to the platform UITableView/RecyclerView subpaths. */
+export declare function Table(props: TableProps): unknown;

package/types/generated/Tabs.macos.d.ts

@@ -0,0 +1,3 @@
+import type { TabsProps } from './props.js';
+export type { TabSpec } from './props.js';
+export declare function Tabs(props: TabsProps): unknown;

package/types/generated/Text.macos.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { RichTextProps, RichTextSpanProps, TextProps } from './props.js';
+export declare function Text(props: TextProps): unknown;
+export declare function RichText(props: RichTextProps): unknown;
+export declare function RichTextSpan(props: RichTextSpanProps): unknown;

package/types/generated/Thumbnail.macos.d.ts

@@ -0,0 +1,7 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { ThumbnailProps } from './props.js';
+/**  Thumbnail — macOS leaf. No image error events on the AppKit host, so a
+ *  failed `src` shows an empty frame (documented gap vs the web/native
+ *  placeholder fallback). Remove button follows the same hover contract —
+ *  the renderer's NSTrackingArea drives it. */
+export declare function Thumbnail(props: ThumbnailProps): unknown;

package/types/generated/TimeInput.macos.d.ts

@@ -0,0 +1,6 @@
+import type { TimeInputProps } from './props.js';
+/**  Time entry field — `HH:MM[:SS]` typed input. On macOS all presentations
+ *  resolve to the typed field (fine pointer; the OS time control is the
+ *  `@octane-xplat/date-picker` AppKit leaf). Hardware-key stepping is not
+ *  bound by this leaf; the field still parses `2:30 PM`/`14:30`/`1430`. */
+export declare function TimeInput(inputProps: TimeInputProps): unknown;

package/types/generated/TimeWheelPanel.macos.d.ts

@@ -0,0 +1,16 @@
+import type { ISOTimeString } from './props.js';
+interface TimeWheelProps {
+    value?: ISOTimeString;
+    hasSeconds?: boolean;
+    hourFormat?: '12h' | '24h';
+    min?: ISOTimeString;
+    max?: ISOTimeString;
+    onCommit: (time: ISOTimeString) => void;
+    onDismiss?: () => void;
+}
+/**  Bottom-sheet time picker — scrollable option columns + commit row.
+ *  Columns are scrollviews of tap-to-select rows (the self-drawn wheel
+ *  equivalent — a NativeScript `listpicker` per column is the alternative,
+ *  but scroll columns keep sizing/theming identical across targets). */
+export declare function TimeWheelPanel(props: TimeWheelProps): unknown;
+export {};

package/types/generated/Timeline.macos.d.ts

@@ -0,0 +1,3 @@
+import type { TimelineProps } from "./props.js";
+/**  Timeline — vertical event list: dot + connector + content per item. */
+export declare function Timeline(props: TimelineProps): unknown;

package/types/generated/Timer.macos.d.ts

@@ -0,0 +1,3 @@
+import type { TimerProps } from './props.js';
+/**  Timer — macOS leaf, same as the mobile leaf (label + ISO duration). */
+export declare function Timer(props: TimerProps): unknown;

package/types/generated/Timestamp.macos.d.ts

@@ -0,0 +1,5 @@
+import type { TimestampProps } from './props.js';
+/**  Timestamp — macOS leaf. The AppKit host's HoverCard carries the tooltip
+ *  card (labels + copyable values as plain rows; the copy affordance is
+ *  pointer-web only). */
+export declare function Timestamp(props: TimestampProps): unknown;

package/types/generated/Toast.macos.d.ts

@@ -0,0 +1,3 @@
+import type { ToastProps } from './props.js';
+/**  Timed notification card shared by inline and presented stacks. */
+export declare function Toast(props: ToastProps): unknown;

package/types/generated/ToggleButton.macos.d.ts

@@ -0,0 +1,3 @@
+import type { ToggleButtonProps, ToggleButtonGroupProps } from './props.js';
+export declare function ToggleButton(props: ToggleButtonProps): unknown;
+export declare function ToggleButtonGroup(props: ToggleButtonGroupProps): unknown;

package/types/generated/Token.macos.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { TokenProps } from "./props.js";
+/**  Token — inline entity chip. macOS leaf: `href` routes through
+ *  pushDeepLink like Link; chrome is inlined (no CSS layer). */
+export declare function Token(props: TokenProps): unknown;

package/types/generated/Tokenizer.macos.d.ts

@@ -0,0 +1,6 @@
+import type { SearchableItem, TokenizerProps } from "./props.js";
+/**  Multi-select field: Token chips + a BaseTypeahead input. Native leaf —
+ *  Backspace-removes-last-token needs key events native text fields don't
+ *  emit, so removal is the token ✕ (and the clear-all lane); truncation is
+ *  measured off native layout (`layoutChanged`), not ResizeObserver. */
+export declare function Tokenizer<T extends SearchableItem>(props: TokenizerProps<T>): unknown;

package/types/generated/Toolbar.macos.d.ts

@@ -0,0 +1,6 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { ToolbarProps } from './props.js';
+/**  Toolbar — named contextual action region with start / optional center /
+ *  end slots. Native leaf: the same slot layout minus keyboard roving
+ *  (pointer platforms carry the composite-widget arrow navigation). */
+export declare function Toolbar(props: ToolbarProps): unknown;

package/types/generated/TopNav.macos.d.ts

@@ -0,0 +1,25 @@
+import type { TopNavHeadingProps, TopNavItemProps, TopNavMenuProps, TopNavMegaMenuProps, TopNavMegaMenuItemProps, TopNavMegaMenuFeaturedCardProps, TopNavProps } from './props.js';
+import { TopNavMobileContentContext, TopNavRenderContext, TopNavSlotContext, useTopNavMobileContent, useTopNavRenderMode, useTopNavSlot } from './nav-contexts.js';
+export { TopNavRenderContext, TopNavSlotContext, TopNavMobileContentContext, useTopNavRenderMode, useTopNavSlot, useTopNavMobileContent };
+/**  TopNav — the app's top navigation bar. Native leaf: the same three
+ *  render modes — `default` full bar, `mobile-bar` (heading + end +
+ *  toggle), `drawer` (content inside MobileNav). Hover-driven menus open on
+ *  tap on pointer platforms. */
+export declare function TopNav(props: TopNavProps): unknown;
+/**  TopNavHeading — the brand block: logo + heading link with optional
+ *  super/subheading lines and an optional heading menu popover. */
+export declare function TopNavHeading(props: TopNavHeadingProps): unknown;
+/**  TopNavItem — one nav link in the bar. Native leaf: Pressable rows;
+ *  `href` routes through `followHref`. */
+export declare function TopNavItem(props: TopNavItemProps): unknown;
+/**  TopNavMenu — trigger that opens a list popover on press (hover platforms
+ *  get hover intent in the web leaf). */
+export declare function TopNavMenu(props: TopNavMenuProps): unknown;
+/**  TopNavMegaMenu — trigger opening a wide panel with an items grid plus an
+ *  optional featured panel. Native leaf: a press-opened anchored popover. */
+export declare function TopNavMegaMenu(props: TopNavMegaMenuProps): unknown;
+/**  TopNavMegaMenuItem — one link in the mega menu items grid. */
+export declare function TopNavMegaMenuItem(props: TopNavMegaMenuItemProps): unknown;
+/**  TopNavMegaMenuFeaturedCard — the marketing card inside a mega menu's
+ *  featured panel. */
+export declare function TopNavMegaMenuFeaturedCard(props: TopNavMegaMenuFeaturedCardProps): unknown;

package/types/generated/Tree.macos.d.ts

@@ -0,0 +1,4 @@
+import type { TreeProps } from "./props.js";
+/**  Tree — recursive indent + collapse. `defaultExpanded` seeds the open
+ *  set (uncontrolled); `onToggle`/`onSelect` report changes. */
+export declare function Tree(props: TreeProps): unknown;

package/types/generated/Typeahead.macos.d.ts

@@ -0,0 +1,8 @@
+import type { SearchableItem, TypeaheadProps } from "./props.js";
+/**  Single-selection search-as-you-type field. macOS leaf: the AppKit
+ *  textfield exposes no focus/return events, so the list opens when results
+ *  exist and options are click-selected; the selected value still renders as
+ *  a Token with click-to-edit and clear. `disabledMessage` surfaces through
+ *  the AppKit tooltip bridge. */
+export declare function Typeahead<T extends SearchableItem>(props: TypeaheadProps<T>): unknown;
+export { BaseTypeahead } from './BaseTypeahead.macos.js';

package/types/generated/TypeaheadItem.macos.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { SearchableItem, TypeaheadItemProps } from "./props.js";
+/**  Default option content for typeahead dropdowns — label with an optional
+ *  leading icon and supporting description. `item.element` wins when set. */
+export declare function TypeaheadItem<T extends SearchableItem>(props: TypeaheadItemProps<T>): unknown;

package/types/generated/User.macos.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { UserProps } from "./props.js";
+/**  User — avatar + name/description row. `onSelect` makes the row
+ *  tappable. */
+export declare function User(props: UserProps): unknown;

package/types/generated/VStack.macos.d.ts

@@ -0,0 +1,4 @@
+/**  @jsxImportSource @octane-xplat/macos-renderer */
+import type { VStackProps } from './props.js';
+/**  Vertical flow stack — `Stack` with `direction="vertical"`. */
+export declare function VStack(props: VStackProps): unknown;

package/types/generated/View.macos.d.ts

@@ -0,0 +1,3 @@
+import type { ViewProps } from './props.js';
+export declare function View(props: ViewProps): unknown;
+export declare const Column: typeof View;

package/types/generated/VirtualList.macos.d.ts

@@ -0,0 +1,6 @@
+import type { VirtualListProps } from './props.js';
+/**  Windowed vertical virtualization for the AppKit host. Rows outside the
+ *  visible window + one viewport of overscan stay unmounted; row heights are
+ *  measured through `onLayoutChanged` frame notifications and prefix-summed
+ *  by the shared VirtualListSizeIndex. */
+export declare function VirtualList<T = any>(props: VirtualListProps<T>): unknown;

package/types/generated/VisuallyHidden.macos.d.ts

@@ -0,0 +1,5 @@
+import type { VisuallyHiddenProps } from './props.js';
+/**  VisuallyHidden — 1pt opacity-0 container; keeps content in the a11y
+ *  tree while rendering invisible (AppKit hidden views drop from
+ *  VoiceOver; transparent ones stay). */
+export declare function VisuallyHidden(props: VisuallyHiddenProps): unknown;

package/types/generated/WebView.macos.d.ts

@@ -0,0 +1,2 @@
+import type { WebViewProps } from './props.js';
+export declare function WebView(props: WebViewProps): unknown;

package/types/generated/aliases.macos.d.ts

@@ -0,0 +1,3 @@
+import type { MultiSelectorProps } from './props.js';
+/**  SelectMenu — multi-select anchored listbox (Select with `multiple`). */
+export declare function SelectMenu(props: MultiSelectorProps): unknown;

package/types/generated/anim.macos.d.ts

@@ -0,0 +1,3 @@
+import type { AnimatedValue } from './props.js';
+export type { AnimatedValue } from './props.js';
+export declare function useAnimation(initial?: number, property?: string): AnimatedValue;

package/types/generated/animation-host.macos.d.ts

@@ -0,0 +1,3 @@
+export declare function readReducedMotion(): boolean;
+/** Refs are NSViews, not NativeScript views. Keep the renderer's y-down convention. */
+export declare function writeAnimatedProperty(view: any, property: string, value: number): void;

package/types/generated/bottom-sheet-panel.macos.d.ts

@@ -0,0 +1,7 @@
+/**  Imperative content gets the same handle, scrolling and live theme as a
+ * declaration. Context stays inside this detached root. */
+export declare function ImperativeSheetPanel(props: {
+    component: any;
+    params: any;
+    close: (result?: any) => void;
+}): unknown;

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

@@ -0,0 +1,5 @@
+import type { ModalOpenResult, OpenBottomSheet } from './props.js';
+export declare function closeBottomSheet(result?: ModalOpenResult): void;
+/** Dedicated root in the key window's bottom-docked AppKit surface. */
+export declare const openBottomSheet: OpenBottomSheet;
+export declare function bottomSheetHost(): null;

package/types/generated/clipboard-write.macos.d.ts

@@ -0,0 +1,3 @@
+/** Write text to the macOS pasteboard via the __xplatAppKit bridge
+ *  (NSPasteboard). Resolves false when the bridge is absent. */
+export declare function copyText(text: string): Promise<boolean>;

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

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

package/types/generated/command-palette-keys.macos.d.ts

@@ -0,0 +1,2 @@
+/** Scope AppKit key monitoring to the palette field's editor and owning window. */
+export declare function bindCommandPaletteKeys(input: any, keyDown: (event: any) => void, autoFocus: boolean, queryChanged: (query: string) => void): () => void;

package/types/generated/command-palette-scroll.macos.d.ts

@@ -0,0 +1,2 @@
+/** AppKit converts a row's local bounds through its enclosing clip view. */
+export declare function scrollCommandPaletteHighlight(row: any): void;

package/types/generated/controls.macos.d.ts

@@ -0,0 +1,8 @@
+import type { ActivityIndicatorProps, ButtonProps, CheckboxProps, SearchInputProps, SegmentedControlProps, SliderProps, SwitchProps } from './props.js';
+export declare function Button(props: ButtonProps): unknown;
+export declare function Checkbox(inputProps: CheckboxProps): unknown;
+export declare function Switch(inputProps: SwitchProps): unknown;
+export declare function Slider(props: SliderProps): unknown;
+export declare function SegmentedControl(_props: SegmentedControlProps): unknown;
+export declare function SearchInput(props: SearchInputProps): unknown;
+export declare function ActivityIndicator(props: ActivityIndicatorProps): unknown;

package/types/generated/date-composition.macos.d.ts

@@ -0,0 +1,5 @@
+/** AppKit field editor owns marked text; action callbacks are committed text. */
+export declare function hasDateComposition(view: any, event?: {
+    isComposing?: boolean;
+    keyCode?: number;
+}): boolean;

package/types/generated/escape-props.macos.d.ts

@@ -0,0 +1,5 @@
+/** AppKit doesn't have NativeScript's attached-property bridge. Platform
+ * escape bags are therefore intentionally ignored by this experimental leaf. */
+export declare function applyEscapeProps(_view: unknown, _props: unknown): void;
+export declare function nativeAccessibilityRole(role: unknown): unknown;
+export declare function nativeAccessibilityState(state: unknown): unknown;

package/types/generated/hash-image.d.ts

@@ -0,0 +1,13 @@
+/** Placeholder-hash decoders shared by the Image leaves: `blurhash:` and
+ *  `thumbhash:` URIs decode to a PNG in pure JS so a placeholder is a real
+ *  image on every platform — ImageSource.fromBase64Sync on native, a
+ *  data:image/png URL on web. Decode sizes stay small (~32px); the view's
+ *  own fit/stretch scales the result, same as the final image.
+ *
+ *  blurhash decode is a port of the Wolt reference decoder (MIT);
+ *  thumbHashToRGBA and rgbaToPng are ports of Evan Wallace's thumbhash.js
+ *  (MIT), with the data-URL/btoa tail replaced by byte output so this file
+ *  carries no DOM or platform APIs. */
+export declare function isHashPlaceholder(src: string): boolean;
+/** `blurhash:<hash>` / `thumbhash:<base64>` → PNG bytes as base64, or null. */
+export declare function hashToPngBase64(src: string): string | null;

package/types/generated/hosted-unsupported.macos.d.ts

@@ -0,0 +1 @@
+export declare function CameraView(_props: any): unknown;

package/types/generated/image-content-binding.d.ts

@@ -0,0 +1,64 @@
+import type { ImageContentFit, ImageContentPositionObject, ImageSourceLike } from './props.js';
+export interface ImageContentEnv {
+    /** Platform gate for the intrinsic-size unit conversion — the leaf
+     *  supplies it so this module stays free of '@nativescript/core'. */
+    isAndroid: boolean;
+    /** Device pixel ratio for the L8 pixel-count target. */
+    screenScale: () => number;
+    /** Src write seam — the sized-decode binding (image-sizing.ts) owns WHEN
+     *  a source lands on the view: first-layout gate, decode dims, resize
+     *  reload. `stretchForDecode` overrides the view's stretch for those
+     *  gates on the computed path, whose inner image draws stretch='fill'
+     *  under a different semantic fit ('none' needs the full-resolution
+     *  source to find the natural size). */
+    issue: (view: any, source: any, stretchForDecode?: string) => void;
+}
+export interface ImageContentUpdate {
+    /** The resolved single source (string or ImageSource), null when
+     *  `sources` carries the request. */
+    source: any;
+    /** Resolution-qualified sources (L8) — the binding defers selection
+     *  until a real layout exists, picks the closest pixel count, then
+     *  hands the winner to `issue`. */
+    sources: readonly ImageSourceLike[] | null;
+    /** Resolved CSS fit/position for the computed path. */
+    fit: ImageContentFit;
+    position: ImageContentPositionObject;
+    /** True when the image view lives in a clip host and is laid out by the
+     *  binding (width/height/left/top in dips) — needed for 'none',
+     *  'scale-down', and non-center positions no platform scaleType has. */
+    computed: boolean;
+}
+/** Measure → compute → apply for Image's content contract (study L7).
+ *  NS's stock widget owns its draw path — the widgets ImageView computes
+ *  its own matrix in onDraw and honors only the four stretch scaleTypes —
+ *  so the drawable-level matrix expo-image uses is engine internals. What
+ *  the leaf can own is the view-level equivalent: measure the box
+ *  (`layoutChanged` → `getActualSize`, dips), compute the content rect
+ *  with the same math as object-fit/object-position, and lay out the
+ *  inner <image stretch="fill"> to that rect inside a clipped host. One
+ *  code path produces identical rects on iOS and Android.
+ *
+ *  This binding never writes `src` itself — it resolves WHICH source the
+ *  view should load and hands it to `env.issue`, the sized-decode binding
+ *  (study L1). That seam composes both contracts: the L8 array pick waits
+ *  on the same first real layout the decode gate needs, and the computed
+ *  path passes the semantic fit as the decode gate so 'none' still
+ *  decodes at source resolution while 'fill' would have been
+ *  view-sampled.
+ *
+ *  Before the bitmap's intrinsic size is known the computed path sizes
+ *  the inner image to the host box: a real rect is what lets the decode
+ *  gate's first-layout check pass, and the placeholder is the CSS 'fill'
+ *  answer until imageSourceChange refines it.
+ *
+ *  `update` re-runs on every render (ref identity churn); all writes are
+ *  idempotent. Null refs on detach are ignored — a dead listener is a
+ *  self-contained cycle GC collects with the view. */
+export declare function createImageContentBinding(env: ImageContentEnv): {
+    /** (Re)bind views + intent. `sizeView` is the measured box (the image
+     *  itself on the stretch path, the clip host on the computed path);
+     *  `imageView` is the <image> that draws. */
+    update(nextSizeView: any, nextImageView: any, next: ImageContentUpdate): void;
+    dispose(): void;
+};

package/types/generated/image-content.d.ts

@@ -0,0 +1,56 @@
+import type { ImageContentFit, ImageContentPosition, ImageContentPositionObject, ImageContentPositionValue, ImageSourceLike } from './props.js';
+/** Shared `contentFit`/`contentPosition` + multi-source math for `Image` —
+ *  pure functions used by every leaf (docs/notes/expo-image-study.md L7/L8).
+ *  Semantics mirror CSS `object-fit`/`object-position`, which is also
+ *  expo-image's contract: the leaves compute the drawn-content rect
+ *  themselves instead of delegating to platform scaleType/contentMode,
+ *  so all platforms get the same answer.
+ *
+ *  The default fit is 'cover' everywhere (the expo/RN default). Today's
+ *  platform defaults disagree — web <img> is 'fill' and NS stretch is
+ *  'aspectFit' — so an un-propped Image was silently divergent. */
+export declare const DEFAULT_CONTENT_FIT: ImageContentFit;
+export declare function resolveContentFit(fit?: ImageContentFit): ImageContentFit;
+export declare function resolveContentPosition(position?: ImageContentPosition): ImageContentPositionObject;
+/** Offset of the drawn content's start edge inside the view along one axis.
+ *  expo-image `calcTranslation`: percentages run over the free space
+ *  (view − content), absolute dips measure from the named edge, and the
+ *  reverse edge (right/bottom) counts back from the far side. */
+export declare function contentAxisOffset(viewSize: number, contentSize: number, start: ImageContentPositionValue | undefined, end: ImageContentPositionValue | undefined): number;
+export declare function isCenteredContentPosition(position: ImageContentPositionObject): boolean;
+/** The rect the bitmap occupies inside the view box, in the same units the
+ *  caller measures with (native: dips; web: CSS px via object-fit anyway —
+ *  only the native leaf calls this). Every length unit is dips except the
+ *  intrinsic size, which the leaf must supply in dips too. */
+export declare function contentRect(fit: ImageContentFit, position: ImageContentPositionObject, viewWidth: number, viewHeight: number, imageWidth: number, imageHeight: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** True when no platform stretch/scaleType can express the request and the
+ *  leaf must measure + lay out the image itself: 'none' (iOS maps NS
+ *  stretch='none' to TopLeft, not CSS centered), 'scale-down' (needs the
+ *  intrinsic-vs-view compare), or any non-center position. 'fill' is
+ *  exempt — its rect is always the whole box, so position can't matter. */
+export declare function needsContentRect(fit: ImageContentFit, position: ImageContentPositionObject): boolean;
+/** NS `stretch` for the fast path — only reached for fits the platform
+ *  vocabulary expresses identically (contain/cover/fill centered). */
+export declare function contentFitToStretch(fit: ImageContentFit): 'aspectFit' | 'aspectFill' | 'fill';
+/** L8 — expo `getBestSource`: the source whose declared pixel count
+ *  (`width·height·scale²`, dips × density) is closest to the view's pixel
+ *  count. Needs a real measured size; one source or no size picks nothing
+ *  to decide. Unsized sources score worst and are skipped when any sized
+ *  candidate exists. */
+export declare function bestImageSource(sources: readonly ImageSourceLike[], viewWidth: number, viewHeight: number, screenScale: number): ImageSourceLike | null;
+/** Browser `object-position` for a resolved position — mirrors expo-image
+ *  web's `getObjectPositionFromContentPositionObject`. */
+export declare function objectPositionCSSValue(position: ImageContentPositionObject): string;
+/** Browser `srcset` candidates for a source array: `w` descriptors (real
+ *  file px = width·scale) when every source is sized, `x` descriptors when
+ *  every source only carries density. `src` falls back to the largest
+ *  declared pixel count — guaranteed coverage where srcset is ignored. */
+export declare function imageSrcSet(sources: readonly ImageSourceLike[]): {
+    src: string;
+    srcSet?: string;
+};

package/types/generated/image-sizing.d.ts

@@ -0,0 +1,37 @@
+/** View-sized decode for the native <image> leaf.
+ *
+ *  NS Android reads decodeWidth/decodeHeight only when `src` is written —
+ *  `srcProperty.setNative` → `_createImageSourceFromSrc` →
+ *  `imageView.setUri(value, decodeWidth, decodeHeight, …)` — and the
+ *  properties default to 0 → `Fetcher.calculateInSampleSize` maps
+ *  reqWidth ≤ 0 to the source dims → inSampleSize 1 → a full-resolution
+ *  decode (~48 MB ARGB_8888 per 12 MP photo; docs/notes/expo-image-study.md
+ *  L1). So the leaf holds `src` until the view's first real layout, writes
+ *  the decode dims in device pixels, then assigns src. A later resize
+ *  re-issues at the new size — the same reload expo-image runs from
+ *  onSizeChanged — under the same gate: 'fill'/'none' stretches keep the
+ *  existing decode because a resize can't change the ideal sample there
+ *  ('none' additionally never downsamples — its contract is source
+ *  pixels). iOS ignores the decode dims entirely; the deferred assignment
+ *  is behavior-identical there, so one path serves both platforms.
+ *
+ *  The ref callback re-fires on every render (identity change), so
+ *  `update` must be idempotent: same view + same src + same size is a
+ *  no-op. Null ref calls on detach are ignored by the leaf — re-attaching
+ *  the same view must not lose `applied`, or each render would re-issue
+ *  setUri. The dead-view listener left behind on real unmount is a
+ *  self-contained cycle the GC collects with the component record.
+ *
+ *  `afterIssue` runs right after every `src` write — including a same-src
+ *  resize re-issue mid-load, which fires no `isLoadingChange` (isLoading is
+ *  already true). The Image placeholder hooks this to re-apply its bitmap
+ *  after the write has nulled `imageSource` (L5, decision #103). */
+export declare function createSizedImageBinding(options?: {
+    afterIssue?: (view: any) => void;
+}): {
+    /** (Re)bind source → view; issues once the view reports a real layout.
+     *  `stretchForDecode` overrides view.stretch for the decode/reload
+     *  gates — see `issue`. */
+    update(next: any, source: any, stretchForDecode?: string): void;
+    dispose(): void;
+};