@octane-xplat/ui 0.7.3 → 0.10.0

package/types/generated/markdown-stream.d.ts

@@ -0,0 +1,61 @@
+import type { MdNode } from './props.js';
+/** Mutable cache for `parseMarkdownIncremental`. Create per logical doc
+ *  (e.g. per message) — a state reused for a wholesale different input
+ *  resets itself, but holding one state per stream is cheaper. */
+export interface MarkdownIncrementalState {
+    /** Last input seen — identical input returns the same output array. */
+    input: string;
+    /** Immutable source prefix: every parsed block here is final. */
+    settledSource: string;
+    /** Blocks parsed from `settledSource`, shared by reference across calls. */
+    settled: MdNode[];
+    /** List continuation key per settled node (loose-list seam merging). */
+    marks: (string | undefined)[];
+    /** Last returned node array (identity reuse for identical input). */
+    output: MdNode[];
+}
+export declare function createMarkdownIncrementalState(): MarkdownIncrementalState;
+/**
+ * Strip trailing incomplete inline syntax from the last line so half-typed
+ * constructs don't render as literal markup: an unclosed `[`/`![` (link or
+ * image), a trailing unclosed backtick run, and unpaired `*`/`_` emphasis
+ * markers. Mid-line unclosed emphasis is auto-closed instead of trimmed, so
+ * `**partial` renders bold immediately rather than flashing raw asterisks.
+ */
+export declare function trimStreamingArtifacts(input: string): string;
+/**
+ * Parse one cumulative snapshot of a streaming Markdown doc. Settled
+ * blocks (everything before the last safe blank line) parse once and are
+ * shared by reference between calls; only the open tail reparses. Incomplete
+ * trailing constructs are withheld or auto-closed, so intermediate output
+ * shows no raw markup — and once the input stops growing, the result equals
+ * `parseMdNodes` on the final text.
+ *
+ * Non-append input (a different doc, an edit) resets the cache and
+ * reparses whole.
+ */
+export declare function parseMarkdownIncremental(input: string, state: MarkdownIncrementalState): MdNode[];
+/** One piece of a text run split at stream boundaries. `key` is stable for
+ *  the segment's lifetime so the fade span mounts once; `fading` marks
+ *  segments that arrived after the oldest tracked boundary. */
+export interface MdTextSegment {
+    key: string;
+    text: string;
+    fading: boolean;
+}
+/**
+ * Push the previous rendered length onto the boundary ring when output grew.
+ * The ring caps at `maxSpans`; evicted boundaries merge into settled text.
+ */
+export declare function computeBoundaries(prevBoundaries: number[], prevRenderedLen: number, maxSpans: number): number[];
+/**
+ * Split one text run at the stream boundaries it crosses. Returns null when
+ * the whole run is settled (no splitting needed). Segment keys never change
+ * once created — `settled-{nodeKey}` for pre-boundary text and
+ * `fade-{nodeKey}-b{offset}` per boundary span — so a fading span stays
+ * mounted until it merges into the settled segment.
+ */
+export declare function computeSegments(content: string, startOffset: number, boundaries: number[], nodeKey: string | number): MdTextSegment[] | null;
+/** Total rendered text length of a node list — the cursor metric fade
+ *  boundaries are computed against. */
+export declare function markdownTextLength(nodes: MdNode[]): number;

package/types/generated/menu-context.d.ts

@@ -0,0 +1,6 @@
+import type { MenuContextValue, MenuRadioGroupProps } from './props.js';
+export declare const DropdownMenuContext: import("octane").Context<MenuContextValue | null>;
+export declare const MenuProvider: any;
+export declare function useDropdownMenuContext(): MenuContextValue | null;
+export declare const MenuRadioContext: import("octane").Context<MenuRadioGroupProps | null>;
+export declare const MenuRadioProvider: any;

package/types/generated/metadata-list-context.d.ts

@@ -0,0 +1,9 @@
+/** Resolved layout config a MetadataListItem reads to decide between the
+ *  inline (label+value grid cells) and stacked (one wrapper per item) shape. */
+export interface MetadataListContextValue {
+    labelPosition: 'start' | 'top';
+    labelWidth?: number | string;
+    orientation: 'vertical' | 'horizontal';
+}
+export declare const MetadataListContext: import("octane").Context<MetadataListContextValue | null>;
+export declare const MetadataListProvider: any;

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

@@ -0,0 +1,4 @@
+import './layer-keys.web.js';
+/** 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, depth?: number): () => void;

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

@@ -1,3 +1,3 @@
-export { rootLayoutFor, topRootLayout, findInRootLayouts } from '../root-layout.mobile.js';
+export { rootLayoutFor, topRootLayout, findInRootLayouts } from '../root-layout.js';
 export { layoutsForRoute } from '../route.js';
-export { sheetHost } from '../sheet-service.js';
+export { bottomSheetHost } from '../bottom-sheet-service.js';

package/types/generated/native-color.d.ts

@@ -0,0 +1,2 @@
+/** Fallback for targets without the NativeScript mobile color class. */
+export declare const nativeColor: (value: string) => any;

package/types/generated/native-color.mobile.d.ts

@@ -0,0 +1,4 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import { Color } from '@nativescript/core';
+/**  Construct a NativeScript color for dynamic style values. */
+export declare const nativeColor: (value: string) => Color;

package/types/generated/nav-contexts.d.ts

@@ -0,0 +1,49 @@
+import type { AppShellMobileContextValue, NavHeadingCloseContextValue, NavHeadingMenuContextValue, NavHeadingMenuSize, SideNavCollapseState, SideNavRenderMode, TabListContextValue, TopNavRenderMode, TopNavSlot, ToolbarSize } from './props.js';
+export declare const AppShellMobileContext: import("octane").Context<AppShellMobileContextValue>;
+export declare function useAppShellMobile(): AppShellMobileContextValue;
+/** AppShell sets this so TopNav can switch between the full bar, the
+ *  reduced mobile bar, and drawer rendering below the breakpoint. */
+export declare const TopNavRenderContext: import("octane").Context<TopNavRenderMode>;
+export declare function useTopNavRenderMode(): TopNavRenderMode;
+/** Which TopNav slot an item renders in — items use it for slot-specific
+ *  styling (e.g. drawer layouts stretch items full width). */
+export declare const TopNavSlotContext: import("octane").Context<TopNavSlot>;
+export declare function useTopNavSlot(): TopNavSlot;
+/** Extra drawer content AppShell hands to TopNav's drawer render — the
+ *  SideNav's items travel this way when the drawer is combined. */
+export declare const TopNavMobileContentContext: import("octane").Context<any>;
+export declare function useTopNavMobileContent(): any;
+/** AppShell sets this so SideNav can switch between the full sidebar, the
+ *  horizontal topbar, and the two drawer renderings. */
+export declare const SideNavRenderContext: import("octane").Context<SideNavRenderMode>;
+export declare function useSideNavRenderMode(): SideNavRenderMode;
+/** SideNav collapse state shared with collapse buttons and items. */
+export declare const SideNavCollapseContext: import("octane").Context<SideNavCollapseState | null>;
+export declare function useSideNavCollapse(): SideNavCollapseState | null;
+/** TabList → Tab/TabMenu selection contract. Throws when read outside a
+ *  TabList, matching upstream. */
+export declare const TabListContext: import("octane").Context<TabListContextValue | null>;
+export declare function useTabListContext(): TabListContextValue;
+/** Heading-popover close callback — NavHeadingMenu reads it to dismiss the
+ *  popover on item selection and Escape. */
+export declare const NavHeadingCloseContext: import("octane").Context<NavHeadingCloseContextValue | null>;
+export declare function useNavHeadingCloseContext(): NavHeadingCloseContextValue | null;
+/** NavHeadingMenu → its items: size + the close callback. */
+export declare const NavHeadingMenuContext: import("octane").Context<NavHeadingMenuContextValue | null>;
+export declare function useNavHeadingMenuContext(): NavHeadingMenuContextValue | null;
+export type { NavHeadingMenuSize };
+/** Toolbar → family children that want the resolved size. This is the
+ *  local seam standing in for Astryx's SizeContext until the shared size
+ *  context lands with the forms/layout task. */
+export declare const ToolbarSizeContext: import("octane").Context<import("./props.js").NavElementSize | null>;
+export declare function useToolbarSize(): ToolbarSize | null;
+export declare const AppShellMobileProvider: any;
+export declare const SideNavRenderProvider: any;
+export declare const TopNavRenderProvider: any;
+export declare const TopNavSlotProvider: any;
+export declare const TopNavMobileContentProvider: any;
+export declare const SideNavCollapseProvider: any;
+export declare const NavHeadingCloseProvider: any;
+export declare const NavHeadingMenuProvider: any;
+export declare const TabListProvider: any;
+export declare const ToolbarSizeProvider: any;

package/types/generated/nav-href.d.ts

@@ -0,0 +1 @@
+export declare function followHref(href: string): void;

package/types/generated/nav-href.web.d.ts

@@ -0,0 +1,4 @@
+/** Web fallback for programmatic href activation (non-anchor surfaces such
+ *  as menu items rendered as buttons). Anchors navigate natively, so this
+ *  path is only for elements that asked to handle activation themselves. */
+export declare function followHref(href: string): 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/outline-dom.d.ts

@@ -0,0 +1,8 @@
+import type { OutlineFromDOMOptions, OutlineItem } from './props.js';
+/**  `useOutlineFromDOM` — native form. The DOM API name is kept for API
+ *  parity; the argument is a `ref`/`ref`-style object holding the scroll
+ *  container's (or page's) root view. There is no mutation observation on
+ *  the NS view tree, so the outline is collected once after mount and again
+ *  whenever `containerRef.current` changes — use `useOutlineFromMarkdown`
+ *  (or pass `items` directly) when the heading set is dynamic. */
+export declare function useOutlineFromDOM(containerRef?: unknown, _options?: OutlineFromDOMOptions): OutlineItem[];

package/types/generated/outline-dom.web.d.ts

@@ -0,0 +1,8 @@
+import type { OutlineFromDOMOptions, OutlineItem } from './props.js';
+/**  Read the heading tree from a container (or the document) — each entry
+ *  carries the element's id (or a slug of its text) and its tag level. */
+export declare function outlineItemsFromDOM(container?: ParentNode | null, selector?: string): OutlineItem[];
+/**  `useOutlineFromDOM` — keeps the item list in sync with the container's
+ *  heading nodes via MutationObserver. The container may be a ref object
+ *  (`{current}`) or a DOM node. */
+export declare function useOutlineFromDOM(containerRef?: unknown, options?: OutlineFromDOMOptions): OutlineItem[];

package/types/generated/outline-hooks.d.ts

@@ -0,0 +1,9 @@
+import type { MdDoc } from './Markdown.js';
+import type { OutlineItem } from './props.js';
+/**  Heading outline items derived from Markdown source — one entry per ATX or
+ *  Setext heading, labelled by the inline text, id'd by the deduplicated
+ *  slug (same slugify/uniqueSlug contract as upstream). */
+export declare function useOutlineFromMarkdown(markdown: string): OutlineItem[];
+/**  Outline items from a baked `MdDoc` (the `xplat routes`/`Markdown` AST) —
+ *  the portable form of "outline the document I'm rendering". */
+export declare function useOutlineFromDoc(doc: MdDoc): OutlineItem[];

package/types/generated/outline-utils.d.ts

@@ -0,0 +1,36 @@
+import type { OutlineItem } from './props.js';
+export type { OutlineItem } from './props.js';
+import type { MdDoc } from './Markdown.js';
+/** Slug a heading label the same way upstream's parser does: lowercase,
+ *  quotes dropped, non-alphanumerics collapse to '-', edges trimmed. */
+export declare function slugify(value: string): string;
+/** Disambiguate repeated slugs with a numeric suffix (`setup`, `setup-1`, …).
+ *  Empty slugs fall back to `section`. The caller owns the counts map. */
+export declare function uniqueSlug(baseSlug: string, counts: Map<string, number>): string;
+/** Strip the inline constructs the local Markdown AST supports (code spans,
+ *  emphasis, links, images, escapes), leaving the visible text — matching
+ *  what `markdownAstText` produces upstream. */
+export declare function inlineMarkdownText(source: string): string;
+interface ParsedHeading {
+    label: string;
+    level: number;
+}
+/**
+ * Scan markdown source for headings. Not a general parser — it exists to
+ * produce outline labels that agree with what the Markdown component renders
+ * for the same source. Fenced code blocks (```/~~~) and 4-space-indented
+ * lines are never headings; Setext underlines promote the previous
+ * non-blank line.
+ */
+export declare function markdownHeadings(markdown: string): ParsedHeading[];
+/**
+ * Extract outline items from a Markdown string: heading text becomes the
+ * label, its slug (with per-document dedup) becomes the id. For
+ * `useOutlineFromMarkdown` parity on MdDoc-shaped data see
+ * {@link outlineFromDoc}.
+ */
+export declare function parseOutlineFromMarkdown(markdown: string): OutlineItem[];
+/** Outline items from a baked `MdDoc` (the AST `xplat routes` produces and
+ *  the `Markdown` component renders) — the portable equivalent of deriving
+ *  an outline from rendered markdown content. */
+export declare function outlineFromDoc(doc: MdDoc): OutlineItem[];

package/types/generated/outline-view-tree.d.ts

@@ -0,0 +1,7 @@
+import type { OutlineItem } from './props.js';
+export declare function outlineChildViews(view: any): Generator<any>;
+/** Depth-first heading collection — matches document order. */
+export declare function outlineItemsFromViewTree(root: any): OutlineItem[];
+/** Locate a view by `id` inside a subtree — used by Outline's native
+ *  activation to find the heading it should scroll to. */
+export declare function findViewById(root: any, id: string): any;

package/types/generated/overflow-math.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure overflow fit math for OverflowList — a 1:1 port of Astryx's
+ * computeOverflow (single-line greedy fit + bounded multi-row packing).
+ * No platform code; consumed by every leaf's measurement pass.
+ */
+export interface ComputeOverflowInput {
+    /** Measured widths of each item, in original order. */
+    widths: number[];
+    /** Gap between items, in px/dips. */
+    gap: number;
+    /** Width available to lay items out, in px/dips. */
+    availableWidth: number;
+    /** Measured width of the overflow indicator (0 if none). */
+    indicatorWidth: number;
+    /** Floor — always show at least this many items. */
+    minVisibleItems: number;
+    /** Ceiling — never show more than this many items. `undefined` = no cap. */
+    maxVisibleItems?: number;
+    /** Bounded multi-row: wrap items across up to this many rows, then
+     *  collapse the rest into the overflow indicator. `undefined`/`1` =
+     *  single line. */
+    maxRows?: number;
+    collapseFrom: 'start' | 'end';
+}
+export interface ComputeOverflowResult {
+    /** Number of items that should be rendered in the visible container. */
+    visibleCount: number;
+    /** Number of rows the visible items occupy (always 1 single-line). */
+    rows: number;
+}
+export declare function computeOverflow(input: ComputeOverflowInput): ComputeOverflowResult;

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

@@ -0,0 +1,19 @@
+/** Own the resources of one independently mounted overlay. RootLayout emits
+ * closed before removing the host, so that notification must never reenter close. */
+type OverlayHost = {
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+};
+type OverlayOwner = {
+    close(host: any): Promise<unknown>;
+    open(host: any, options?: any): Promise<unknown>;
+    removeChild(host: any): void;
+};
+export declare function createOverlayLifetime(owner: OverlayOwner, host: OverlayHost, root: {
+    unmount(): void;
+}, label: string, onFinish: (dismissed: boolean) => void): {
+    own(cleanup: () => void): void;
+    close(): void;
+    open(options?: any, afterOpen?: () => void | Promise<void>): void;
+};
+export {};

package/types/generated/popover-position.d.ts

@@ -1,4 +1,4 @@
-import type { PopoverPlacement } from './props.js';
+import type { LayerPlacement, PopoverAlignment, PopoverPlacement } from './props.js';
 export interface PopoverRect {
     left: number;
     top: number;
@@ -10,5 +10,19 @@ export interface PopoverPosition {
     top: number;
     placement: PopoverPlacement;
 }
-/** Place beside the anchor, flip once when the requested side overflows, then clamp. */
-export declare function positionPopover(anchor: PopoverRect, panel: Pick<PopoverRect, 'width' | 'height'>, viewport: PopoverRect, requested?: PopoverPlacement, gap?: number): PopoverPosition;
+/** Place beside the anchor, flip once when the requested side overflows,
+ *  then clamp. `alignment` positions along the cross axis — 'start' keeps
+ *  the panel's start edge flush with the anchor's (the historical
+ *  behavior), 'center' centers, 'end' aligns the end edges. */
+export declare function positionPopover(anchor: PopoverRect, panel: Pick<PopoverRect, 'width' | 'height'>, viewport: PopoverRect, requested?: PopoverPlacement, gap?: number, alignment?: PopoverAlignment): PopoverPosition;
+/** Resolve a `useLayer` placement — logical (`above`/`below`/`start`/`end`)
+ *  or physical — to a physical side for `positionPopover`. `rtl` mirrors the
+ *  logical inline sides. */
+export declare function resolveLayerSide(placement: LayerPlacement | PopoverPlacement | undefined, rtl?: boolean): PopoverPlacement;
+/** Normalize a `useLayer` render-prop offset to a dip clearance. A number is
+ *  taken as-is; native accepts numeric or px strings and rejects other CSS units. Defaults to flush (0). */
+export declare function layerOffset(offset: number | string | undefined): number;
+/** Horizontal cross-axis alignment follows the anchor's inline direction. */
+export declare function resolveLayerAlignment(alignment: PopoverAlignment | undefined, side: PopoverPlacement, rtl?: boolean): PopoverAlignment;
+/** Read the effective OS direction, with inherited author direction as a fallback. */
+export declare function nativeLayerRTL(view: any): boolean;

package/types/generated/power-search-config.d.ts

@@ -0,0 +1,57 @@
+import type { DateTimeRangePart, FieldDefinition, FilterValue, InferData, OperatorValue, PowerSearchConfig, PowerSearchField, PowerSearchFilter, PowerSearchItem, PowerSearchOperator, SearchSource } from './props.js';
+import { type PowerSearchTranslate } from './power-search-strings.js';
+/** Display string for an operator: `label` verbatim, `i18nKey` through the
+ *  catalog (`powerSearchTranslate` by default — pass an app translator to
+ *  localize). */
+export declare function resolveOperatorLabel(operator: PowerSearchOperator, t?: PowerSearchTranslate): string;
+/** Resolves a range part against one caller-supplied instant. */
+export declare function resolveDateTimeRangePart(part: DateTimeRangePart, nowSeconds?: number): number;
+export interface PowerSearchInternalConfig {
+    readonly config: PowerSearchConfig;
+    getField(key: string): PowerSearchField | undefined;
+    getOperator(fieldKey: string, operatorKey: string): PowerSearchOperator | undefined;
+    getDefaultOperator(fieldKey: string): PowerSearchOperator | undefined;
+    getVisibleFields(): ReadonlyArray<PowerSearchField>;
+    getVisibleOperators(fieldKey: string): ReadonlyArray<PowerSearchOperator>;
+}
+/** Pure factory — components wrap it in `useMemo` when they want stability. */
+export declare function createInternalConfig(config: PowerSearchConfig): PowerSearchInternalConfig;
+export declare function useInternalConfig(config: PowerSearchConfig): PowerSearchInternalConfig;
+export declare function formatDateAbsolute(unixSeconds: number, locale?: string, timezoneID?: string): string;
+/** Compact date-only rendering for token pills (no time-of-day). */
+export declare function formatDateAbsoluteCompact(unixSeconds: number, locale?: string): string;
+/** String form of a filter value for token pills and summaries. */
+export declare function formatFilterValue(_config: PowerSearchInternalConfig, operatorValue: OperatorValue, filterValue: FilterValue, maxLength: number, t?: PowerSearchTranslate, locale?: string, timezoneID?: string): string;
+/** The field/operator/value suggestion source behind the main input —
+ *  `search(query)` ranks field labels, field+operator combos, value matches,
+ *  and the free-text content-search entry; `bootstrap()` lists every field. */
+export declare function createPowerSearchSource(config: PowerSearchInternalConfig, maxTypedResults: number, t?: PowerSearchTranslate): SearchSource<PowerSearchItem>;
+export declare function usePowerSearchSource(config: PowerSearchInternalConfig, maxTypedResults: number, t?: PowerSearchTranslate): SearchSource<PowerSearchItem>;
+/** Whether one record satisfies one filter — client-side matching used by
+ *  `applyFilters`. Types without a local predicate (time, date_relative,
+ *  entity_list, custom, nested) pass through like upstream. */
+export declare function matchesFilter(row: Record<string, unknown>, filter: PowerSearchFilter): boolean;
+/**
+ * Build a `PowerSearchConfig` and a matching `applyFilters` from simplified
+ * field definitions.
+ *
+ * @example
+ * ```
+ * const defs = [
+ *   { key: 'name', type: 'string', label: 'Name' },
+ *   { key: 'age', type: 'number', label: 'Age' },
+ *   { key: 'active', type: 'boolean', label: 'Active' },
+ * ] as const;
+ * const { config, applyFilters } = createPowerSearchConfig(defs);
+ * const filtered = applyFilters(filters, data);
+ * ```
+ */
+export declare function createPowerSearchConfig<const D extends ReadonlyArray<FieldDefinition>>(definitions: D, configName?: string): {
+    config: PowerSearchConfig;
+    applyFilters: <T extends InferData<D>>(filters: ReadonlyArray<PowerSearchFilter>, data: ReadonlyArray<T>) => T[];
+};
+/** Memoized `createPowerSearchConfig` for component bodies. */
+export declare function usePowerSearchConfig<const D extends ReadonlyArray<FieldDefinition>>(definitions: D, configName?: string): {
+    config: PowerSearchConfig;
+    applyFilters: <T extends InferData<D>>(filters: ReadonlyArray<PowerSearchFilter>, data: readonly T[]) => T[];
+};

package/types/generated/power-search-strings.d.ts

@@ -0,0 +1,12 @@
+/** Default English strings for the PowerSearch family — the portable stand-in
+ *  for Astryx's `@astryx.powersearch.*` / `@astryx.moreMenu.*` catalog keys.
+ *  There is no i18n provider seam in this build: `label` operator variants are
+ *  verbatim, `i18nKey` variants resolve through this map, and an unknown key
+ *  falls back to its final path segment. `{count}` plurals collapse to the
+ *  English one/other rule. */
+export type PowerSearchTranslate = (key: string, params?: {
+    count?: number;
+}) => string;
+/** Catalog lookup with a `{count, plural, ...}` subset. Not exported as a
+ *  general i18n facility — PowerSearch internals only. */
+export declare const powerSearchTranslate: PowerSearchTranslate;