panelui-native 0.28.1 → 0.32.0

package/lib/typescript/src/components/radio-group/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/radio-group/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAa,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAW/D,KAAK,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;AACnC,KAAK,gBAAgB,GAAG,UAAU,GAAG,YAAY,CAAC;AA2DlD,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB;AA6CD,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA+ED,eAAO,MAAM,UAAU;;CAErB,CAAC;AAEH,YAAY,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/radio-group/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAa,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAW/D,KAAK,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;AACnC,KAAK,gBAAgB,GAAG,UAAU,GAAG,YAAY,CAAC;AA2DlD,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB;AA6CD,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAwFD,eAAO,MAAM,UAAU;;CAErB,CAAC;AAEH,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/lib/typescript/src/components/reasoning/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Reasoning — the model's working, shown while it happens and folded away after.
+ *
+ * A reasoning trace is interesting for exactly as long as it is the only thing
+ * arriving. Once the answer starts, it is a wall of text above the thing the
+ * reader actually asked for. So it opens itself when the trace starts streaming
+ * and closes itself about a second after it stops — once, and only if it ever
+ * streamed, because a trace that arrives complete was never a live thing to
+ * watch and should not perform.
+ *
+ * The trigger changes with it: a shimmering "Thinking…" while the tokens are
+ * coming, and "Thought for 8 seconds" afterwards. The duration is measured from
+ * the first streaming frame rather than taken on trust, so it is the time the
+ * reader actually waited.
+ *
+ * ```tsx
+ * <Reasoning isStreaming={streaming}>
+ *   <Reasoning.Trigger />
+ *   <Reasoning.Content>{text}</Reasoning.Content>
+ * </Reasoning>
+ * ```
+ *
+ * ## Where the props come from
+ *
+ * With the AI SDK, `isStreaming` is whether the last part of the last message
+ * is a reasoning part while the request is still streaming, and the content is
+ * every `reasoning` part joined together. Joined, not one component each:
+ * some models emit a run of separate reasoning parts, and one component per
+ * part is a column of "Thinking…" rows for a single thought.
+ */
+import { type ReactNode } from 'react';
+import { type PressableProps, type ViewProps } from 'react-native';
+export interface ReasoningProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /**
+     * Whether the trace is still arriving. Drives the shimmer on the trigger,
+     * opens the panel on the way in and closes it a beat after it goes false.
+     */
+    isStreaming?: boolean;
+    /**
+     * How long the trace took, in seconds. Measured from the first streaming
+     * frame when it is not given, which is the number worth showing — it is what
+     * the reader actually waited.
+     */
+    duration?: number;
+    /** Controlled open state. */
+    open?: boolean;
+    /**
+     * Initial state when uncontrolled. Defaults to whether it is streaming, so a
+     * live trace is open and a finished one arrives folded. Passing `false`
+     * explicitly also opts out of the auto-open.
+     */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+declare function ReasoningRoot({ className, isStreaming, duration: durationProp, open: openProp, defaultOpen, onOpenChange, children, ...props }: ReasoningProps): import("react").JSX.Element;
+declare namespace ReasoningRoot {
+    var displayName: string;
+}
+export interface ReasoningTriggerProps extends Omit<PressableProps, 'children' | 'style'> {
+    className?: string;
+    /**
+     * What the row says. Given the streaming state and the measured duration, so
+     * a caller can put its own words to both without reimplementing the timing.
+     */
+    label?: (isStreaming: boolean, duration?: number) => ReactNode;
+    /** Replaces the whole row, icon and chevron included. */
+    children?: ReactNode;
+}
+/** The row that says how long it thought, and folds the trace away. */
+declare function ReasoningTrigger({ className, label, children, onPress, ...props }: ReasoningTriggerProps): import("react").JSX.Element;
+declare namespace ReasoningTrigger {
+    var displayName: string;
+}
+export interface ReasoningContentProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** The trace. A string is wrapped for you; anything else is left alone. */
+    children?: ReactNode;
+}
+/**
+ * The trace itself.
+ *
+ * Kept mounted and collapsed to nothing rather than unmounted, because it is
+ * usually still growing while it is folded — and a body that remounts on every
+ * open would drop whatever the reader had scrolled to.
+ */
+declare function ReasoningContent({ className, children, ...props }: ReasoningContentProps): import("react").JSX.Element;
+declare namespace ReasoningContent {
+    var displayName: string;
+}
+export declare const Reasoning: typeof ReasoningRoot & {
+    Trigger: typeof ReasoningTrigger;
+    Content: typeof ReasoningContent;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/reasoning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/reasoning/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAkDpF,MAAM,WAAW,cAAe,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,iBAAS,aAAa,CAAC,EACrB,SAAS,EACT,WAAmB,EACnB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,QAAQ,EACd,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,cAAc,+BAsEhB;kBA/EQ,aAAa;;;AAkFtB,MAAM,WAAW,qBACf,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,CAAC;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,SAAS,CAAC;IAC/D,yDAAyD;IACzD,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,uEAAuE;AACvE,iBAAS,gBAAgB,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,KAAK,EAAE,EAAE,qBAAqB,+BAoDjG;kBApDQ,gBAAgB;;;AAsDzB,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;GAMG;AACH,iBAAS,gBAAgB,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,qBAAqB,+BAWjF;kBAXQ,gBAAgB;;;AAgBzB,eAAO,MAAM,SAAS;;;CAGpB,CAAC"}

package/lib/typescript/src/components/response/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Response — a model's answer, rendered as it arrives.
+ *
+ * An answer is markdown. It has headings and lists and fenced code in it,
+ * because that is what a model writes, and rendering it as one run of plain
+ * text throws away the structure the model went to the trouble of producing.
+ *
+ * So this reads the markdown and renders it through the library's own parts —
+ * `Typography` for prose, `CodeBlock` for fences, `Table` for tables. Nothing
+ * here draws its own type or its own colours: an answer inside a message bubble
+ * should look like the app it is in, not like a document viewer someone
+ * embedded.
+ *
+ * ```tsx
+ * <Response isStreaming={status === 'streaming'}>{text}</Response>
+ * ```
+ *
+ * ## Why it is a whole component and not a `<Text>`
+ *
+ * Because the text is still arriving, and that changes everything about how it
+ * has to be read. A token stream hands you every prefix of the final answer, so
+ * a renderer sees `**bo`, then `**bol`, then `**bold**` — three documents, two
+ * of which have literal asterisks in them. Render each faithfully and the
+ * answer flickers between styles on nearly every frame, which is worse than no
+ * formatting at all: the eye tracks the flicker instead of the words.
+ *
+ * `isStreaming` tells the reader to finish an unterminated construct at the end
+ * of the input rather than escaping it — an open fence is a code block that is
+ * still filling, an open `**` is bold text still being written. The rule it
+ * works to is that no word already on screen may disappear when the next token
+ * arrives; delimiters may vanish as they are recognised, words never do.
+ *
+ * ## Where the props come from
+ *
+ * With the AI SDK, `children` is the text of the assistant message's text parts
+ * joined together, and `isStreaming` is `status === 'streaming'`. Join the
+ * parts — one `Response` per part renders a heading in one component and the
+ * paragraph under it in another, and neither knows about the other.
+ */
+import { type ComponentType } from 'react';
+import { type ViewProps } from 'react-native';
+export type { Block as ResponseBlock, InlineToken as ResponseInline } from './markdown.js';
+export interface ResponseComponents {
+    /** Replaces the whole code block — for a runnable snippet, or a diff viewer. */
+    code?: ComponentType<{
+        code: string;
+        language?: string;
+        streaming: boolean;
+    }>;
+    /** Replaces an image. Nothing is rendered for one by default. */
+    image?: ComponentType<{
+        src: string;
+        alt: string;
+    }>;
+}
+export interface ResponseProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** The markdown. */
+    children?: string;
+    /**
+     * Whether more is still coming. Finishes an unterminated construct at the end
+     * of the text instead of escaping it, so the answer does not flicker between
+     * styles as its delimiters arrive.
+     */
+    isStreaming?: boolean;
+    /** Turns off speculative completion entirely, even while streaming. */
+    parseIncompleteMarkdown?: boolean;
+    /** What a link does. Opens it with the system handler by default. */
+    onLinkPress?: (href: string) => void;
+    /**
+     * Schemes a link is allowed to open. A model can write any URL it likes, and
+     * an answer is not a trusted document — so the default list is the four that
+     * cannot do anything but navigate.
+     */
+    allowedLinkPrefixes?: string[];
+    /** Swap out how a block is drawn. */
+    components?: ResponseComponents;
+    /** Line numbers in fenced code. */
+    showLineNumbers?: boolean;
+}
+declare function ResponseRoot({ className, children, isStreaming, parseIncompleteMarkdown, onLinkPress, allowedLinkPrefixes, components, showLineNumbers, ...props }: ResponseProps): import("react").JSX.Element;
+/**
+ * Re-renders only when the text changes.
+ *
+ * A stream re-renders its parent on every token, and everything else the parent
+ * hands down — the callbacks, the overrides — is usually a fresh object each
+ * time. Comparing the one prop that actually decides the output keeps a long
+ * answer from re-parsing because a sibling moved.
+ */
+export declare const Response: import("react").MemoExoticComponent<typeof ResponseRoot>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/response/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/response/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAiB,KAAK,aAAa,EAAkB,MAAM,OAAO,CAAC;AAC1E,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAa7D,YAAY,EAAE,KAAK,IAAI,aAAa,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,eAAY,CAAC;AAQxF,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC9E,iEAAiE;IACjE,KAAK,CAAC,EAAE,aAAa,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oBAAoB;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uEAAuE;IACvE,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,qEAAqE;IACrE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,qCAAqC;IACrC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,mCAAmC;IACnC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,iBAAS,YAAY,CAAC,EACpB,SAAS,EACT,QAAa,EACb,WAAmB,EACnB,uBAA8B,EAC9B,WAAW,EACX,mBAA2C,EAC3C,UAAU,EACV,eAAuB,EACvB,GAAG,KAAK,EACT,EAAE,aAAa,+BAsBf;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,0DAMpB,CAAC"}

package/lib/typescript/src/components/response/markdown.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A small Markdown reader, written for text that is still arriving.
+ *
+ * No parser library. What a chat answer actually contains is headings,
+ * paragraphs, lists, fenced code, blockquotes, tables, rules and a handful of
+ * inline marks — and every general-purpose parser worth using assumes it has
+ * been handed the whole document. That assumption is the one thing that is
+ * never true here.
+ *
+ * ## Half-arrived markdown
+ *
+ * A token stream shows you every prefix of the final text, so the reader sees
+ * `**bo`, then `**bol`, then `**bold**`. Treated naively that is three
+ * documents: two with literal asterisks in them and one with a bolded word. The
+ * text would flash between styles on nearly every frame, which is worse than no
+ * formatting at all — the eye tracks the flicker instead of the words.
+ *
+ * So an unterminated construct at the very end of the input is *completed
+ * speculatively* rather than escaped: an open fence becomes a code block that
+ * is still filling, an open `**` becomes bold text that is still being written.
+ * Anything unterminated anywhere else is literal, because a document that has
+ * stopped arriving means what it says.
+ *
+ * The two rules that follow from this:
+ *
+ * - **Only the tail is speculative.** An asterisk in the middle of a finished
+ *   paragraph is an asterisk.
+ * - **A speculative construct never removes visible text.** The characters that
+ *   opened it are hidden, and everything after them stays on screen. Otherwise
+ *   the last word of the answer disappears and reappears as its delimiter
+ *   arrives.
+ */
+export type Align = 'left' | 'center' | 'right';
+export interface InlineToken {
+    kind: 'text' | 'code' | 'link' | 'image';
+    value: string;
+    /** For links and images. */
+    href?: string;
+    bold?: boolean;
+    italic?: boolean;
+    strike?: boolean;
+}
+export type Block = {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    inline: InlineToken[];
+} | {
+    type: 'paragraph';
+    inline: InlineToken[];
+} | {
+    type: 'code';
+    code: string;
+    language?: string;
+    open: boolean;
+} | {
+    type: 'quote';
+    blocks: Block[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: Block[][];
+} | {
+    type: 'table';
+    head: InlineToken[][];
+    rows: InlineToken[][][];
+    align: (Align | null)[];
+} | {
+    type: 'rule';
+};
+/**
+ * Splits a document into blocks.
+ *
+ * `streaming` is what turns speculative completion on. With it off — a stored
+ * answer, a message that has finished — an unterminated fence is just a
+ * paragraph starting with three backticks, which is what it literally is.
+ */
+export declare function parseMarkdown(source: string, streaming?: boolean): Block[];
+/**
+ * Splits a run of text into styled spans.
+ *
+ * `tail` says this run is the end of a stream, which is what licenses closing
+ * an open delimiter speculatively. It is deliberately narrow: only the *last*
+ * unterminated opener on the line is completed, and only when nothing after it
+ * could still turn out to be the closer.
+ */
+export declare function parseInline(source: string, tail: boolean): InlineToken[];
+//# sourceMappingURL=markdown.d.ts.map

package/lib/typescript/src/components/response/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../../src/components/response/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,KAAK,GACb;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,GACxE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC;IAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,GAC1F;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAUrB;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,KAAK,EAAE,CAGxE;AA0QD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,WAAW,EAAE,CA+HxE"}

package/lib/typescript/src/components/select/index.d.ts

@@ -20,15 +20,27 @@
  *   <Select.Item value="eu" label="Europe" />
  * </Select>
  * ```
+ *
+ * Past a couple of dozen options, scrolling stops being a way of finding
+ * anything: pass `searchable` and the list gets a filter above it, matching on
+ * the option labels. The filter narrows what is *shown* — the declared options
+ * are still the source of truth, so nothing has to be lifted into state to make
+ * it work.
  */
 import { type ReactNode } from 'react';
 export type SelectPresentation = 'sheet' | 'inline' | 'overlay';
 export interface SelectItemProps {
     value: string;
     label: string;
+    /**
+     * Shows the option but refuses it — a plan above the current tier, a region
+     * with nothing in stock. Kept in the list rather than dropped from it, because
+     * an option that vanishes reads as one that never existed.
+     */
+    disabled?: boolean;
 }
 /** Declarative option. Rendered inside whichever surface is presenting. */
-declare function SelectItem({ value, label }: SelectItemProps): import("react").JSX.Element;
+declare function SelectItem({ value, label, disabled }: SelectItemProps): import("react").JSX.Element;
 export interface SelectProps {
     className?: string;
     value?: string;
@@ -52,6 +64,19 @@ export interface SelectProps {
     offset?: number;
     /** Called when the options open or close. */
     onOpenChange?: (open: boolean) => void;
+    /**
+     * Put a filter above the options, matching case-insensitively on any part of
+     * an option's label. For a list long enough that scrolling it is not finding
+     * anything — countries, currencies, a repository's branches.
+     *
+     * The field is not focused on open: on a phone that would throw the keyboard
+     * over the very list you are trying to look at.
+     */
+    searchable?: boolean;
+    /** Placeholder for the filter field. `searchable` only. */
+    searchPlaceholder?: string;
+    /** Shown in place of the list when the filter matches nothing. */
+    emptyMessage?: string;
     /**
      * Render the platform's own picker instead of the trigger-and-list pair.
      * Requires the optional `@expo/ui` package; without it this prop does
@@ -69,7 +94,7 @@ export interface SelectProps {
     nativeAppearance?: 'menu' | 'wheel';
     children: ReactNode;
 }
-declare function SelectRoot({ className, value, onValueChange, placeholder, disabled, presentation, title, contentWidth, offset, onOpenChange, native, nativeAppearance, children, }: SelectProps): import("react").JSX.Element;
+declare function SelectRoot({ className, value, onValueChange, placeholder, disabled, presentation, title, contentWidth, offset, onOpenChange, searchable, searchPlaceholder, emptyMessage, native, nativeAppearance, children, }: SelectProps): import("react").JSX.Element;
 export declare const Select: typeof SelectRoot & {
     Item: typeof SelectItem;
 };

package/lib/typescript/src/components/select/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/select/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EASL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAuDf,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAShE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,2EAA2E;AAC3E,iBAAS,UAAU,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,eAAe,+BA4BpD;AAUD,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAC9C,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,iBAAS,UAAU,CAAC,EAClB,SAAS,EACT,KAAK,EACL,aAAa,EACb,WAAgC,EAChC,QAAQ,EACR,YAAsB,EACtB,KAAK,EACL,YAAwB,EACxB,MAAU,EACV,YAAY,EACZ,MAAM,EACN,gBAAyB,EACzB,QAAQ,GACT,EAAE,WAAW,+BAsOb;AAED,eAAO,MAAM,MAAM;;CAEjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/select/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EASL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AA2Df,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAShE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,2EAA2E;AAC3E,iBAAS,UAAU,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,eAAe,+BAgC9D;AAUD,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAC9C,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,iBAAS,UAAU,CAAC,EAClB,SAAS,EACT,KAAK,EACL,aAAa,EACb,WAAgC,EAChC,QAAQ,EACR,YAAsB,EACtB,KAAK,EACL,YAAwB,EACxB,MAAU,EACV,YAAY,EACZ,UAAkB,EAClB,iBAA4B,EAC5B,YAA2B,EAC3B,MAAM,EACN,gBAAyB,EACzB,QAAQ,GACT,EAAE,WAAW,+BA0Tb;AAED,eAAO,MAAM,MAAM;;CAEjB,CAAC"}

package/lib/typescript/src/components/sources/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Sources — where an answer came from, folded under a count.
+ *
+ * A cited answer usually cites more places than anyone wants listed above it,
+ * so the list opens from a single line: "Used 6 sources". Folded is the resting
+ * state, unlike `Reasoning`, because a citation list is a thing you go and
+ * check rather than a thing you watch arrive.
+ *
+ * ```tsx
+ * <Sources>
+ *   <Sources.Trigger count={sources.length} />
+ *   <Sources.Content>
+ *     {sources.map((source) => (
+ *       <Sources.Source key={source.url} href={source.url} title={source.title} />
+ *     ))}
+ *   </Sources.Content>
+ * </Sources>
+ * ```
+ *
+ * ## Where the props come from
+ *
+ * With the AI SDK these are the `source-url` parts of an assistant message:
+ * `part.url` is the `href` and `part.title` the `title`. A part carries no
+ * title of its own when the model did not supply one, in which case the host
+ * of the URL is a better label than the whole of it.
+ */
+import { type ReactNode } from 'react';
+import { type PressableProps, type ViewProps } from 'react-native';
+export interface SourcesProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Initial state when uncontrolled. Folded, which is where a citation list belongs. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+declare function SourcesRoot({ className, open: openProp, defaultOpen, onOpenChange, children, ...props }: SourcesProps): import("react").JSX.Element;
+declare namespace SourcesRoot {
+    var displayName: string;
+}
+export interface SourcesTriggerProps extends Omit<PressableProps, 'children' | 'style'> {
+    className?: string;
+    /** How many sources the list holds. Reads "Used 6 sources". */
+    count?: number;
+    /** Replaces the whole row. */
+    children?: ReactNode;
+}
+declare function SourcesTrigger({ className, count, children, onPress, ...props }: SourcesTriggerProps): import("react").JSX.Element;
+declare namespace SourcesTrigger {
+    var displayName: string;
+}
+export interface SourcesContentProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    children?: ReactNode;
+}
+declare function SourcesContent({ className, children, ...props }: SourcesContentProps): import("react").JSX.Element;
+declare namespace SourcesContent {
+    var displayName: string;
+}
+export interface SourcesSourceProps extends Omit<PressableProps, 'children' | 'style'> {
+    className?: string;
+    /** Where the row goes. Opened with the platform's own handler. */
+    href?: string;
+    /**
+     * What the row says. Falls back to the URL's host, which is a better label
+     * than a hundred characters of path — and models often send no title at all.
+     */
+    title?: string;
+    /** Leading glyph. A link by default; a favicon suits a real citation list. */
+    icon?: ReactNode;
+    children?: ReactNode;
+}
+/** One citation. */
+declare function SourcesSource({ className, href, title, icon, children, onPress, ...props }: SourcesSourceProps): import("react").JSX.Element;
+declare namespace SourcesSource {
+    var displayName: string;
+}
+export declare const Sources: typeof SourcesRoot & {
+    Trigger: typeof SourcesTrigger;
+    Content: typeof SourcesContent;
+    Source: typeof SourcesSource;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/sources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/sources/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAwCtB,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uFAAuF;IACvF,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,IAAI,EAAE,QAAQ,EACd,WAAmB,EACnB,YAAY,EACZ,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,YAAY,+BAuBd;kBA9BQ,WAAW;;;AAiCpB,MAAM,WAAW,mBACf,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,CAAC;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,iBAAS,cAAc,CAAC,EACtB,SAAS,EACT,KAAS,EACT,QAAQ,EACR,OAAO,EACP,GAAG,KAAK,EACT,EAAE,mBAAmB,+BAyCrB;kBA/CQ,cAAc;;;AAiDvB,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,iBAAS,cAAc,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,mBAAmB,+BAS7E;kBATQ,cAAc;;;AAWvB,MAAM,WAAW,kBACf,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,CAAC;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,oBAAoB;AACpB,iBAAS,aAAa,CAAC,EACrB,SAAS,EACT,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,GAAG,KAAK,EACT,EAAE,kBAAkB,+BAgCpB;kBAxCQ,aAAa;;;AA2DtB,eAAO,MAAM,OAAO;;;;CAIlB,CAAC"}