panelui-native 0.46.0 → 0.51.1

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

@@ -0,0 +1,285 @@
+/**
+ * Fab — the floating action button: one screen, one thing it is mostly for.
+ *
+ * ```tsx
+ * <Fab icon={<PlusIcon size={24} />} accessibilityLabel="New note" onPress={compose} />
+ * ```
+ *
+ * ## It floats, which is the whole problem with it
+ *
+ * A button pinned over the content is a button covering some of it, and the
+ * bottom-right corner of a scrolling list is exactly where the last row goes. So
+ * a Fab is right when a screen has *one* action worth that trade and wrong when
+ * it has three — a corner with three buttons in it is a toolbar that has been
+ * put in the wrong place. Where a screen has several, the honest shapes are a
+ * `ButtonGroup` in a bar or, if one of them really does lead, this with a
+ * `Fab.Group` behind it.
+ *
+ * It positions itself absolutely against its nearest positioned ancestor, which
+ * on a screen means the screen. Give the content below it enough bottom padding
+ * to scroll clear — this cannot know how tall your list is, and a Fab sitting on
+ * the last row forever is the failure people actually hit.
+ *
+ * ## Extended, and when to bother
+ *
+ * ```tsx
+ * <Fab extended icon={<PencilIcon size={20} />}>Write</Fab>
+ * ```
+ *
+ * A lone glyph is a guess unless the glyph is a plus. `extended` spells the
+ * action out, costs the width, and is worth it for anything a plus would not
+ * have said.
+ *
+ * ## The speed dial
+ *
+ * ```tsx
+ * <Fab.Group icon={<PlusIcon size={24} />} accessibilityLabel="Add">
+ *   <Fab.Action icon={<ImageIcon size={18} />} label="Photo" onPress={addPhoto} />
+ *   <Fab.Action icon={<FileIcon size={18} />} label="File" onPress={addFile} />
+ * </Fab.Group>
+ * ```
+ *
+ * The actions come out of the button one after another rather than together —
+ * a stagger of a few frames each, which is enough to read as a list unfolding
+ * instead of a menu appearing. Every action carries its label beside it, because
+ * a column of unlabelled circles is a quiz.
+ *
+ * Opening also drops a scrim over the screen. Not for looks: an open dial is
+ * modal — the next tap either picks something or closes it — and a scrim is what
+ * says so, as well as what catches the tap that closes it.
+ *
+ * A group draws itself through a portal, above everything else — the scrim and
+ * the buttons together, so the backdrop cannot end up on top of the dial it is
+ * behind. That means its `offset` is measured from the screen's edges rather
+ * than from whatever it is written inside, which is what lets it be declared
+ * next to the content it belongs to instead of at the root of the screen.
+ */
+import { type ReactNode } from 'react';
+import { View, type ViewProps } from 'react-native';
+import { type VariantProps } from 'tailwind-variants';
+/** Which corner the button sits in. */
+export type FabPlacement = 'bottom-right' | 'bottom-center' | 'bottom-left';
+declare const fabVariants: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            root: string;
+            label: string;
+        };
+        md: {
+            root: string;
+            label: string;
+        };
+        lg: {
+            root: string;
+            label: string;
+        };
+    };
+    extended: {
+        true: {};
+        false: {};
+    };
+    variant: {
+        primary: {
+            root: string;
+            label: string;
+        };
+        secondary: {
+            root: string;
+            label: string;
+        };
+        surface: {
+            root: string;
+            label: string;
+        };
+        destructive: {
+            root: string;
+            label: string;
+        };
+    };
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+}, undefined, {
+    size: {
+        sm: {
+            root: string;
+            label: string;
+        };
+        md: {
+            root: string;
+            label: string;
+        };
+        lg: {
+            root: string;
+            label: string;
+        };
+    };
+    extended: {
+        true: {};
+        false: {};
+    };
+    variant: {
+        primary: {
+            root: string;
+            label: string;
+        };
+        secondary: {
+            root: string;
+            label: string;
+        };
+        surface: {
+            root: string;
+            label: string;
+        };
+        destructive: {
+            root: string;
+            label: string;
+        };
+    };
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            root: string;
+            label: string;
+        };
+        md: {
+            root: string;
+            label: string;
+        };
+        lg: {
+            root: string;
+            label: string;
+        };
+    };
+    extended: {
+        true: {};
+        false: {};
+    };
+    variant: {
+        primary: {
+            root: string;
+            label: string;
+        };
+        secondary: {
+            root: string;
+            label: string;
+        };
+        surface: {
+            root: string;
+            label: string;
+        };
+        destructive: {
+            root: string;
+            label: string;
+        };
+    };
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+}, undefined, unknown, unknown, undefined>>;
+type FabVariantProps = VariantProps<typeof fabVariants>;
+/** How big the button is. */
+export type FabSize = NonNullable<FabVariantProps['size']>;
+/** What the button is drawn in. */
+export type FabVariant = NonNullable<FabVariantProps['variant']>;
+export interface FabProps extends Omit<ViewProps, 'children'>, FabVariantProps {
+    className?: string;
+    /** The glyph. Sized by you — this is the one thing that should not guess. */
+    icon?: ReactNode;
+    /**
+     * The label, which turns the circle into a stadium. Needs `extended`; a
+     * label with nowhere to go is a label that gets clipped by the circle.
+     */
+    children?: ReactNode;
+    /** Spell the action out beside the glyph. */
+    extended?: boolean;
+    /**
+     * Pin it over the content, in a corner.
+     *
+     * Left out, it is an ordinary button in the flow — which is what you want
+     * inside a `Fab.Group`, or when the screen already has somewhere for it to
+     * sit.
+     */
+    placement?: FabPlacement;
+    /** Distance from the edges when `placement` is set, in points. */
+    offset?: number;
+    onPress?: () => void;
+    disabled?: boolean;
+    /**
+     * A tick on press. Off by default — needs the optional `expo-haptics`, and
+     * is silent without it.
+     */
+    haptics?: boolean;
+    /** Required for an icon-only button. A lone glyph reads out as nothing. */
+    accessibilityLabel?: string;
+}
+export interface FabGroupProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** The glyph on the trigger. */
+    icon?: ReactNode;
+    /** The trigger's label, if it should be extended while closed. */
+    label?: string;
+    /** `Fab.Action` children, in the order they should unfold. */
+    children?: ReactNode;
+    /** Controlled open state. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Which corner of the *screen* the whole dial parks in. */
+    placement?: FabPlacement;
+    /** Distance from the screen's edges, in points. Add your safe-area inset. */
+    offset?: number;
+    size?: FabSize;
+    variant?: FabVariant;
+    disabled?: boolean;
+    haptics?: boolean;
+    /** Frost the screen behind the open dial instead of dimming it. */
+    blur?: boolean;
+    /** Required — the trigger is a lone glyph until it is opened. */
+    accessibilityLabel?: string;
+    /**
+     * Turn the trigger's glyph a quarter circle while the dial is open.
+     *
+     * On by default, and it is doing real work when the glyph is a plus: the
+     * same mark becomes a cross, which says "this closes now" without a second
+     * icon that has to be swapped in. Turn it off for a glyph that means
+     * something at one angle only.
+     */
+    rotateOnOpen?: boolean;
+}
+export interface FabActionProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** The glyph. */
+    icon?: ReactNode;
+    /** What it does, beside the glyph. A column of unlabelled circles is a quiz. */
+    label?: string;
+    onPress?: () => void;
+    disabled?: boolean;
+    /** Draws it in the destructive colour, for the one that removes something. */
+    destructive?: boolean;
+    /** Extra classes for the label chip. */
+    labelClassName?: string;
+}
+export declare const Fab: import("react").ForwardRefExoticComponent<FabProps & import("react").RefAttributes<View>> & {
+    Group: import("react").ForwardRefExoticComponent<FabGroupProps & import("react").RefAttributes<View>>;
+    Action: import("react").ForwardRefExoticComponent<FabActionProps & import("react").RefAttributes<View>>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/fab/index.tsx"],"names":[],"mappings":"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"}

package/lib/typescript/src/components/markdown-editor/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * MarkdownEditor — a field for writing markdown, and a way to see it rendered.
+ *
+ * ```tsx
+ * const [draft, setDraft] = useState('');
+ *
+ * <MarkdownEditor value={draft} onValueChange={setDraft} rows={12} />
+ * ```
+ *
+ * ## Writing and reading are two modes, not two panes
+ *
+ * Side by side is how this is done on a desktop, and it does not survive the
+ * trip to a phone: two columns of a phone's width are two columns too narrow to
+ * read, and the keyboard covers the bottom half of the screen exactly when the
+ * writer is using it. So there is one pane and a switch — write, or read what
+ * you wrote. The toolbar carries the switch, because the toolbar is the one
+ * thing on screen in both modes.
+ *
+ * ## The toolbar edits the selection
+ *
+ * Every button here is a function of the text and where the caret is in it, and
+ * the answer that matters is not which characters get inserted but where the
+ * caret lands afterwards. Bolding a selected phrase leaves it selected, so it
+ * can be italicised next; bolding nothing puts the caret between the new
+ * markers, where the writing is about to go; and pressing the same button again
+ * takes the markers off. Those rules live in `markdown-transforms.ts` as pure
+ * functions over `(text, selection)`, away from anything to do with a field.
+ *
+ * ## Why it renders through Response
+ *
+ * The preview is `Response`, the same reader that renders a model's answer, so
+ * markdown means the same thing everywhere in the library and there is one
+ * parser to be right rather than two to keep in step. It renders through
+ * `Typography`, `CodeBlock` and `Table`, which is to say through the app's own
+ * type and colours — a preview that looked like a document viewer would be
+ * showing the writer something they are not going to ship.
+ *
+ * Nothing here reaches for a platform markdown renderer. `Text` in SwiftUI can
+ * parse markdown and Jetpack Compose's cannot, so a platform-backed editor
+ * would render on one of the two and be a plain string on the other.
+ *
+ * Works controlled (`value` + `onValueChange`) or uncontrolled (`defaultValue`).
+ */
+import { type ReactNode } from 'react';
+import { View, type TextInput, type ViewProps } from 'react-native';
+import { type TextareaProps } from '../textarea/index.js';
+export type { EditorSelection, EditResult } from './markdown-transforms.js';
+/** Which pane the editor is showing. */
+export type MarkdownEditorMode = 'write' | 'preview';
+/** A formatting action the toolbar can offer. */
+export type MarkdownEditorAction = 'bold' | 'italic' | 'heading' | 'quote' | 'code' | 'bulletList' | 'orderedList' | 'link';
+export interface MarkdownEditorProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Controlled text. Leave unset and pass `defaultValue` to run uncontrolled. */
+    value?: string;
+    /** Starting text when uncontrolled. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Controlled pane. */
+    mode?: MarkdownEditorMode;
+    /** Starting pane when uncontrolled. */
+    defaultMode?: MarkdownEditorMode;
+    onModeChange?: (mode: MarkdownEditorMode) => void;
+    /** Stop the field being edited and the toolbar being pressed. */
+    disabled?: boolean;
+    /**
+     * The parts, in the order they should stack. Left out, the editor draws its
+     * toolbar, its field and its preview in that order — which is the whole
+     * component, and the reason it usually needs no children.
+     */
+    children?: ReactNode;
+    /** Forwarded to the field when the editor draws its own. */
+    placeholder?: string;
+    /** Height of the field, in lines. Forwarded to the field the editor draws. */
+    rows?: number;
+}
+export interface MarkdownEditorToolbarProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Which formatting actions to offer, in the order given. */
+    actions?: MarkdownEditorAction[];
+    /**
+     * Show the write/preview switch. On by default — a preview nobody can reach
+     * is a pane that does not exist.
+     */
+    showModeSwitch?: boolean;
+    /** Anything else to put on the row: a word count, a save state, a submit. */
+    children?: ReactNode;
+}
+export interface MarkdownEditorInputProps extends Omit<TextareaProps, 'value' | 'onChangeText' | 'defaultValue'> {
+    className?: string;
+}
+export interface MarkdownEditorPreviewProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** What to show when there is nothing written yet. */
+    emptyText?: string;
+}
+export declare const MarkdownEditor: import("react").ForwardRefExoticComponent<MarkdownEditorProps & import("react").RefAttributes<View>> & {
+    Toolbar: import("react").ForwardRefExoticComponent<MarkdownEditorToolbarProps & import("react").RefAttributes<View>>;
+    Input: import("react").ForwardRefExoticComponent<MarkdownEditorInputProps & import("react").RefAttributes<TextInput>>;
+    Preview: import("react").ForwardRefExoticComponent<MarkdownEditorPreviewProps & import("react").RefAttributes<View>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/markdown-editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/markdown-editor/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EACL,IAAI,EAEJ,KAAK,SAAS,EAEd,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAmBtB,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,sBAAa,CAAC;AAW3D,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,0BAAuB,CAAC;AAEzE,wCAAwC;AACxC,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,YAAY,GACZ,aAAa,GACb,MAAM,CAAC;AAwGX,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,uBAAuB;IACvB,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,uCAAuC;IACvC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAClD,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA0HD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACjC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmED,MAAM,WAAW,wBACf,SAAQ,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,cAAc,GAAG,cAAc,CAAC;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAoDD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA+BD,eAAO,MAAM,cAAc;;;;CAIzB,CAAC"}

package/lib/typescript/src/components/markdown-editor/markdown-transforms.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The edits a formatting toolbar makes, as functions of the text and where the
+ * caret is in it.
+ *
+ * Pure, and deliberately so. Every one of these takes `(text, selection)` and
+ * returns the text that should replace it together with where the selection
+ * should end up — no component, no ref, no input. What makes a formatting
+ * toolbar feel broken is never the characters it inserts; it is where the caret
+ * lands afterwards, and that is a property of these functions rather than of
+ * the field they are wired to.
+ *
+ * Three rules they all keep:
+ *
+ * - **Applying twice undoes it.** A toolbar button that only ever adds is a
+ *   button you can press once, and every press after that damages the text.
+ * - **A selection stays selected.** Bolding three words and then italicising
+ *   the same three has to be two presses, not a press and a re-selection.
+ * - **With nothing selected, the caret lands where the writing goes** — between
+ *   the new markers rather than after them.
+ */
+export interface EditorSelection {
+    start: number;
+    end: number;
+}
+export interface EditResult {
+    text: string;
+    selection: EditorSelection;
+}
+/**
+ * Wraps the selection in `marker`, or unwraps it if it is already wrapped.
+ *
+ * "Already wrapped" is checked both ways round: the markers may be inside the
+ * selection (the writer selected `**bold**`) or immediately outside it (they
+ * selected `bold` in the middle of `**bold**`). Both are the same intent, and a
+ * toolbar that only recognised one of them would add a second pair of asterisks
+ * to text that already had them.
+ */
+export declare function toggleWrap(text: string, selection: EditorSelection, marker: string): EditResult;
+/**
+ * Puts `prefix` on the front of every line the selection touches, or takes it
+ * off if every one of them already has it.
+ *
+ * Every one, not any one: a mixed block is a block the writer is trying to make
+ * uniform, so the useful answer there is to add rather than to remove.
+ */
+export declare function toggleLinePrefix(text: string, selection: EditorSelection, prefix: string): EditResult;
+/**
+ * Numbers the lines the selection touches, or unnumbers them.
+ *
+ * Counted from one within the block rather than continuing whatever came above
+ * it: the numbers a writer types are not the numbers that get rendered — every
+ * markdown reader renumbers an ordered list from its first item — so the useful
+ * thing is for the source to read the way the output will.
+ */
+export declare function toggleOrderedList(text: string, selection: EditorSelection): EditResult;
+/** Placeholder left where a link's target goes. */
+export declare const LINK_PLACEHOLDER = "url";
+/**
+ * Turns the selection into a link, and selects the part that still needs
+ * filling in.
+ *
+ * Which part that is depends on what was selected. With text selected, the
+ * label is written and the target is not, so the placeholder target is left
+ * selected and typing replaces it. With nothing selected there is neither, and
+ * the label comes first because it is the half the writer is thinking about.
+ */
+export declare function insertLink(text: string, selection: EditorSelection): EditResult;
+/**
+ * Puts the selected lines in a fence, or takes them out of one.
+ *
+ * A fence is the one construct that has to sit on lines of its own, so this
+ * makes room for itself: a blank line before it when it is not already at the
+ * start of a paragraph, and one after it at the end.
+ */
+export declare function toggleFence(text: string, selection: EditorSelection): EditResult;
+//# sourceMappingURL=markdown-transforms.d.ts.map

package/lib/typescript/src/components/markdown-editor/markdown-transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-transforms.d.ts","sourceRoot":"","sources":["../../../../../src/components/markdown-editor/markdown-transforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,eAAe,CAAC;CAC5B;AAaD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,MAAM,GACb,UAAU,CAmCZ;AAiCD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,MAAM,GACb,UAAU,CASZ;AAKD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,GACzB,UAAU,CAQZ;AAMD,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AAEtC;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,UAAU,CAY/E;AAMD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,UAAU,CAiBhF"}