panelui-native 0.46.0 → 0.51.1

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

@@ -0,0 +1,336 @@
+/**
+ * Questionnaire — one question at a time, with progress, validation and a way
+ * back.
+ *
+ * Unlike `Steps`, which reflects a flow the app owns, Questionnaire *owns* the
+ * flow: it holds the answers, decides which question is current, gates the way
+ * forward on the current one being answered, and reports the whole set back
+ * when it is done. The caller supplies the questions and does something with
+ * the answers; everything between those two points belongs here.
+ *
+ * ```tsx
+ * <Questionnaire items={items} onSubmit={(answers) => save(answers)}>
+ *   <Questionnaire.Title>Project setup</Questionnaire.Title>
+ *   <Questionnaire.Progress />
+ *   <Questionnaire.Item name="direction" required>
+ *     <Questionnaire.Question>What should we build next?</Questionnaire.Question>
+ *     <Questionnaire.Description>Choose one, or write your own.</Questionnaire.Description>
+ *     <Questionnaire.Choices>
+ *       <Questionnaire.Choice value="delegation" label="Delegation" />
+ *       <Questionnaire.Choice value="prompts" label="Question prompts" />
+ *       <Questionnaire.Input placeholder="Type another answer…" />
+ *     </Questionnaire.Choices>
+ *     <Questionnaire.Error />
+ *   </Questionnaire.Item>
+ *   <Questionnaire.Footer>
+ *     <Questionnaire.Back />
+ *     <Questionnaire.Next />
+ *     <Questionnaire.Submit />
+ *   </Questionnaire.Footer>
+ * </Questionnaire>
+ * ```
+ *
+ * ## Why it draws its own Frame
+ *
+ * A survey is a widget, not a paragraph: it wants a boundary, a title strip and
+ * a footer that stays put while the middle changes. That is exactly `Frame`, so
+ * the root renders one rather than leaving every caller to assemble the same
+ * shell. `Frame.Panel`'s `overflow-hidden` also does the clipping the sliding
+ * question needs, for free. Pass `frame={false}` to drop it — for a
+ * questionnaire inside a `BottomSheet` or a card that already draws a border.
+ *
+ * ## Why the root reads its children instead of collecting registrations
+ *
+ * Only the active question is mounted, so an unmounted one cannot report that
+ * it exists — and without knowing the full set there is no total to count
+ * against, no "is this the last one", and no way to disable a question the
+ * user has not reached. So the root inspects its children once per render and
+ * reads `name`, `required`, `multiple` and `disabled` straight off the
+ * elements. React elements carry their props before anything renders them,
+ * which makes the whole set knowable without mounting any of it.
+ *
+ * That same pass sorts the parts into the shell: the title and progress go to
+ * the header strip, the footer to a section at the bottom of the panel, and
+ * everything else is a question.
+ *
+ * ## Answers are one record, the way a form would submit them
+ *
+ * `answers[name]` is a string for a single-answer question and an array for a
+ * `multiple` one. A freeform answer lands under the same name — it is another
+ * answer to the same question, not a separate field — which is why the text
+ * input shows whatever value does not match one of the question's own choices.
+ * Picking a choice and typing therefore replace each other, without either one
+ * having to know the other exists.
+ *
+ * ## What blocks the way forward
+ *
+ * A required question blocks until it has an answer. An optional one never
+ * blocks. `Questionnaire.Skip` does not unblock anything, then — it *records*
+ * that the question was deliberately left out, moving its status from
+ * `unanswered` to `skipped` so the app can tell the two apart. Making an
+ * optional question demand an explicit skip would trap anyone who did not
+ * render the Skip button, and a question that cannot be ignored is not
+ * optional.
+ */
+import { type ReactNode } from 'react';
+import { View, type TextInput, type ViewProps } from 'react-native';
+import { type ButtonProps } from '../button/index.js';
+import { type InputProps } from '../input/index.js';
+/** Where a question stands: never touched, answered, or deliberately left out. */
+export type QuestionnaireItemStatus = 'unanswered' | 'answered' | 'skipped';
+/** Which key each answer is badged with. */
+export type QuestionnaireShortcutMode = 'letters' | 'numbers';
+/** Every answer given so far, keyed by question name. */
+export type QuestionnaireAnswers = Record<string, string | string[]>;
+/**
+ * A question, described rather than rendered. Pass these as `items` so the
+ * questionnaire knows its full set before any of it mounts — which is what
+ * makes a conditional question countable and a total meaningful.
+ */
+export interface QuestionnaireItemDefinition {
+    /** Unique name — the key this question's answer is stored under. */
+    name: string;
+    /** Blocks the way forward until it has an answer. */
+    required?: boolean;
+    /** Accepts more than one answer, so its answer is an array. */
+    multiple?: boolean;
+    /** Left out of the count and never navigated to. */
+    disabled?: boolean;
+}
+export interface QuestionnaireProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /**
+     * The full set of questions, in order. Optional: without it the order and
+     * the totals come from the `Questionnaire.Item` children instead. Pass it
+     * when a question is conditional, since a question the user has not reached
+     * still has to be counted — or not counted, if it no longer applies.
+     */
+    items?: readonly QuestionnaireItemDefinition[];
+    /** Controlled active question, by name. */
+    item?: string;
+    /** Which question to open on. Defaults to the first enabled one. */
+    defaultItem?: string;
+    /** Called with the name of the question being moved to. */
+    onItemChange?: (name: string) => void;
+    /** Controlled answers. */
+    answers?: QuestionnaireAnswers;
+    /** Answers to start with — for resuming a part-finished questionnaire. */
+    defaultAnswers?: QuestionnaireAnswers;
+    /** Called with the whole set every time any answer changes. */
+    onAnswersChange?: (answers: QuestionnaireAnswers) => void;
+    /** Called with every answer once the last question validates. */
+    onSubmit?: (answers: QuestionnaireAnswers) => void;
+    /**
+     * Badge every answer with a letter (`A`, `B`, `C`) or a number (`1`, `2`,
+     * `3`). Disabled answers are skipped rather than taking a badge with them.
+     *
+     * The badge is an affordance, not a binding: React Native surfaces hardware
+     * key events only to a focused text field, so nothing here can listen for
+     * the key itself.
+     */
+    shortcuts?: QuestionnaireShortcutMode;
+    /**
+     * Let a horizontal drag move between questions. Going forward is gated on
+     * the same answer the button is, so a swipe off an unanswered required
+     * question springs back and shows its error.
+     */
+    swipeable?: boolean;
+    /**
+     * Draw the surrounding `Frame`. Turn it off to place the questionnaire in a
+     * sheet, a dialog or a card that already draws its own boundary.
+     */
+    frame?: boolean;
+    children?: ReactNode;
+}
+declare function QuestionnaireRoot({ className, items, item: itemProp, defaultItem, onItemChange, answers: answersProp, defaultAnswers, onAnswersChange, onSubmit, shortcuts, swipeable, frame, children, ...props }: QuestionnaireProps): import("react").JSX.Element;
+declare namespace QuestionnaireRoot {
+    var displayName: string;
+}
+export interface QuestionnaireTitleProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * Names the questionnaire as a whole, in the frame's header strip. The
+ * current question's own prompt is `Questionnaire.Question`.
+ */
+declare function QuestionnaireTitle({ className, children, ...props }: QuestionnaireTitleProps): import("react").JSX.Element;
+declare namespace QuestionnaireTitle {
+    var displayName: string;
+}
+/** What a custom progress indicator is told about where the reader is. */
+export interface QuestionnaireProgressState {
+    /** One-based position of the active question. */
+    current: number;
+    /** How many questions are enabled. */
+    total: number;
+    first: boolean;
+    last: boolean;
+}
+/** How the position is drawn. */
+export type QuestionnaireProgressVariant = 'pips' | 'numbers' | 'count';
+export interface QuestionnaireProgressProps {
+    className?: string;
+    /**
+     * `pips` is a bar per question, filled up to the one being asked and widened
+     * on it. `numbers` counts them out instead, which is what you want when the
+     * reader will be sent back to a particular question. `count` is the plain
+     * `Question 2 of 5`.
+     *
+     * `pips` and `numbers` fall back to `count` past eight questions, where
+     * neither is countable at a glance any more.
+     */
+    variant?: QuestionnaireProgressVariant;
+    /**
+     * Replace the indicator entirely. Given a function, it is called with the
+     * position — for a bar, a row of dots, or a percentage.
+     */
+    children?: ReactNode | ((state: QuestionnaireProgressState) => ReactNode);
+}
+/** Where the reader is in the set, announced as a progress bar. */
+declare function QuestionnaireProgress({ className, variant, children, }: QuestionnaireProgressProps): import("react").JSX.Element;
+declare namespace QuestionnaireProgress {
+    var displayName: string;
+}
+export interface QuestionnaireItemProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Unique name — the key this question's answer is stored under. */
+    name: string;
+    /** Blocks the way forward until it has an answer. */
+    required?: boolean;
+    /** Accepts more than one answer, so its answer is an array. */
+    multiple?: boolean;
+    /** Left out of the count and never navigated to. */
+    disabled?: boolean;
+    /** Mark the question at fault from a validator of your own. */
+    invalid?: boolean;
+    /** Called whenever this question moves between unanswered, answered and skipped. */
+    onStatusChange?: (status: QuestionnaireItemStatus) => void;
+    children?: ReactNode;
+}
+/**
+ * One question. Only the active one is mounted, so anything it holds is built
+ * when it is reached and thrown away when it is left.
+ */
+declare function QuestionnaireItem({ className, name, required, multiple, invalid: invalidProp, children, disabled: _disabled, onStatusChange: _onStatusChange, ...props }: QuestionnaireItemProps): import("react").JSX.Element;
+declare namespace QuestionnaireItem {
+    var displayName: string;
+}
+export interface QuestionnaireQuestionProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+/** The question being asked. */
+declare function QuestionnaireQuestion({ className, children, ...props }: QuestionnaireQuestionProps): import("react").JSX.Element;
+declare namespace QuestionnaireQuestion {
+    var displayName: string;
+}
+export interface QuestionnaireDescriptionProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+/** A line under the question — what to consider, or that it can be skipped. */
+declare function QuestionnaireDescription({ className, children, ...props }: QuestionnaireDescriptionProps): import("react").JSX.Element;
+declare namespace QuestionnaireDescription {
+    var displayName: string;
+}
+export interface QuestionnaireChoicesProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * The answers to a question. It hands each choice its shortcut badge, counting
+ * only the ones that can be picked so a disabled answer does not take a letter
+ * out of the sequence with it.
+ */
+declare function QuestionnaireChoices({ className, children, ...props }: QuestionnaireChoicesProps): import("react").JSX.Element;
+declare namespace QuestionnaireChoices {
+    var displayName: string;
+}
+export interface QuestionnaireChoiceProps {
+    className?: string;
+    /** The value recorded when this answer is picked. */
+    value: string;
+    /** The answer itself. */
+    label?: string;
+    /** A line under the label, for an answer that needs explaining. */
+    description?: string;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+export interface QuestionnaireInputProps extends Omit<InputProps, 'value' | 'onChangeText' | 'errorMessage'> {
+    className?: string;
+}
+export interface QuestionnaireErrorProps extends ViewProps {
+    className?: string;
+    /** Replace the default message. */
+    children?: ReactNode;
+}
+/** Why the way forward is closed. Nothing until the question fails to pass. */
+declare function QuestionnaireError({ className, children, ...props }: QuestionnaireErrorProps): import("react").JSX.Element | null;
+declare namespace QuestionnaireError {
+    var displayName: string;
+}
+export interface QuestionnaireFooterProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * The action row, in its own section at the foot of the panel. It stays put
+ * while the question above it changes, which is what keeps the button under
+ * the thumb where it was.
+ */
+declare function QuestionnaireFooter({ className, children, ...props }: QuestionnaireFooterProps): import("react").JSX.Element;
+declare namespace QuestionnaireFooter {
+    var displayName: string;
+}
+/** What a navigation button is told about the question it is acting on. */
+export interface QuestionnaireActionState {
+    /** Whether the action applies to the active question at all. */
+    visible: boolean;
+    /** Where the active question stands. */
+    status: QuestionnaireItemStatus;
+}
+export interface QuestionnaireActionProps extends Omit<ButtonProps, 'children'> {
+    /** Replace the label. Given a function, it is called with the question's state. */
+    children?: ReactNode | ((state: QuestionnaireActionState) => ReactNode);
+}
+/**
+ * A flexible gap for the footer, so the trailing buttons sit against the
+ * trailing edge whether or not `Questionnaire.Back` is showing.
+ */
+declare function QuestionnaireSpacer({ className, ...props }: ViewProps): import("react").JSX.Element;
+declare namespace QuestionnaireSpacer {
+    var displayName: string;
+}
+export declare const Questionnaire: typeof QuestionnaireRoot & {
+    Title: typeof QuestionnaireTitle;
+    Progress: typeof QuestionnaireProgress;
+    Item: typeof QuestionnaireItem;
+    Question: typeof QuestionnaireQuestion;
+    Description: typeof QuestionnaireDescription;
+    Choices: typeof QuestionnaireChoices;
+    Choice: import("react").ForwardRefExoticComponent<QuestionnaireChoiceProps & import("react").RefAttributes<View>>;
+    Input: import("react").ForwardRefExoticComponent<QuestionnaireInputProps & import("react").RefAttributes<TextInput>>;
+    Error: typeof QuestionnaireError;
+    Footer: typeof QuestionnaireFooter;
+    Spacer: typeof QuestionnaireSpacer;
+    Back: {
+        ({ children, variant, className, ...props }: QuestionnaireActionProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Skip: {
+        ({ children, variant, className, ...props }: QuestionnaireActionProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Next: {
+        ({ children, variant, className, ...props }: QuestionnaireActionProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+    Submit: {
+        ({ children, variant, className, ...props }: QuestionnaireActionProps): import("react").JSX.Element | null;
+        displayName: string;
+    };
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,238 @@
+/**
+ * Sortable — a list whose rows can be dragged into a different order.
+ *
+ * The one list interaction nothing else in the library covers. `Swipe` acts on
+ * a row, `Tree` opens one, `Table` sorts every row at once by a column — none
+ * of them let a person say *this one goes above that one*, which is how a
+ * playlist, a task list, a set of form fields or a run of dashboard tiles is
+ * actually arranged.
+ *
+ * ```tsx
+ * const [tasks, setTasks] = useState(TASKS);
+ *
+ * <Sortable
+ *   value={tasks.map((task) => task.id)}
+ *   onReorder={(_, { from, to }) => setTasks((t) => reorderItems(t, from, to))}
+ *   gap={8}
+ * >
+ *   {tasks.map((task) => (
+ *     <Sortable.Item key={task.id} id={task.id}>
+ *       <Item variant="outline">
+ *         <Item.Content>
+ *           <Item.Title>{task.title}</Item.Title>
+ *         </Item.Content>
+ *         <Sortable.Handle />
+ *       </Item>
+ *     </Sortable.Item>
+ *   ))}
+ * </Sortable>
+ * ```
+ *
+ * ## Nothing is ever moved in the tree
+ *
+ * The rows stay exactly where they were laid out and are pushed around with
+ * transforms. A row's offset is the difference between where its slot sits in
+ * the order being dragged and where it sits in the order that was rendered —
+ * one subtraction, on the UI thread, per row per frame. Reordering the
+ * children instead would mean React reconciling the whole list on every slot
+ * the finger crosses, which is the one thing a drag cannot afford.
+ *
+ * It also means the component never owns the order. It reports where a row was
+ * dropped and the list is the caller's to rearrange, because the caller is the
+ * only one who knows what the ids stand for — a `value` that disagreed with
+ * the children would put rows in places their content had not moved to.
+ *
+ * ## Heights are measured, not assumed
+ *
+ * Every row reports its own height, so a list of rows of different sizes lands
+ * in the right slots. A fixed row height would be one number to get wrong in
+ * every list that has a two-line row in it, and the measurement costs one
+ * layout pass on mount.
+ *
+ * ## Where the drop is reported
+ *
+ * `onReorder` fires when the row has finished settling, not when the finger
+ * lifts. Between those two moments the row is animating into a slot that the
+ * layout does not know about yet; re-rendering the list in the middle of that
+ * would relayout every row underneath it and the settling row would jump. By
+ * the time the callback runs the rows are already where the new order puts
+ * them, so the re-render that follows changes nothing on screen.
+ */
+import { type ReactNode } from 'react';
+import { type ViewProps } from 'react-native';
+import Animated, { type AnimatedRef } from 'react-native-reanimated';
+/** What starts a drag. */
+export type SortableActivation = 'handle' | 'longPress';
+/** Where a row ended up, alongside the order it produced. */
+export interface SortableReorderDetails {
+    /** The row that was dragged. */
+    id: string;
+    /** Its index before the drag. */
+    from: number;
+    /** Its index after it. */
+    to: number;
+}
+/**
+ * The same move applied to a list of your own.
+ *
+ * `onReorder` hands back the new order of the ids, but a list is rarely a list
+ * of ids — it is a list of the things they name. This does the move on that
+ * list, and returns a new array rather than sorting in place, because the one
+ * that mutated would be the one React had already decided was unchanged.
+ *
+ * ```tsx
+ * onReorder={(_, { from, to }) => setTasks((tasks) => reorderItems(tasks, from, to))}
+ * ```
+ *
+ * Indices outside the list are returned unchanged rather than throwing: a
+ * reorder is not worth crashing a screen over, and a list that did not move is
+ * the honest result of a move that had nowhere to go.
+ */
+export declare function reorderItems<T>(items: readonly T[], from: number, to: number): T[];
+/**
+ * What the row being rendered knows about itself.
+ *
+ * For a handle of your own, or for a row that looks different while it is
+ * being carried — dimmed neighbours, a border, a shadow. `isActive` is a plain
+ * boolean and changes twice in a drag rather than sixty times a second: it is
+ * set when the row is lifted and cleared when it lands, and nothing between
+ * those two moments touches React at all.
+ */
+export declare function useSortableItem(): {
+    id: string;
+    index: number;
+    isActive: boolean;
+    disabled: boolean;
+};
+export interface SortableProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /**
+     * The ids of the rows, in the order they are rendered below. It is the
+     * caller's array rather than the component's, because only the caller knows
+     * what an id stands for — an order held here that disagreed with the
+     * children would put rows in places their content had not moved to.
+     */
+    value: string[];
+    /**
+     * The rows, one `Sortable.Item` per id in `value` and in the same order.
+     * They may be wrapped in anything; each row registers itself.
+     */
+    children?: ReactNode;
+    /**
+     * Told the new order once the dropped row has settled, and where it came
+     * from and went. Rearrange your own list from `details` — `reorderItems`
+     * does exactly this move.
+     */
+    onReorder?: (order: string[], details: SortableReorderDetails) => void;
+    /**
+     * Space between rows, in points. A prop rather than a `gap` class because
+     * the drag has to know it: the slot a row lands in is measured, and a gap
+     * the component cannot read is a gap it drops rows into the middle of.
+     */
+    gap?: number;
+    /**
+     * What lifts a row. `handle` is the default and the safer one — the rest of
+     * the row stays free to be pressed, and a list of rows with buttons on them
+     * still works. `longPress` gives the whole row to the drag.
+     */
+    activation?: SortableActivation;
+    /** How long `longPress` activation waits, in milliseconds. */
+    longPressDelay?: number;
+    /**
+     * Knock when a row is lifted, tick as it passes each slot. On by default:
+     * a drag with no feedback under the finger is the interaction people give up
+     * on halfway through, unsure whether anything is happening.
+     */
+    haptics?: boolean;
+    /** Turn every row's drag off and leave the list static. */
+    disabled?: boolean;
+    /**
+     * The scroller the list sits in, from `useAnimatedRef`. Given one, a drag
+     * carried to the top or bottom edge scrolls it, so a list longer than the
+     * screen can be reordered end to end. Without it a drag stops at the edge,
+     * which is correct for a list that fits.
+     */
+    scrollRef?: AnimatedRef<Animated.ScrollView>;
+    /** Points from the scroller's edge at which the scrolling begins. */
+    autoscrollThreshold?: number;
+    /** Points per frame at the very edge, tapering to nothing at the threshold. */
+    autoscrollSpeed?: number;
+    /** Told which row was lifted, the moment it is. */
+    onDragStart?: (id: string) => void;
+    /** Told when it lands, whether or not the order changed. */
+    onDragEnd?: (id: string) => void;
+}
+/**
+ * The list, and everything the rows share.
+ *
+ * It renders one plain `View` in a column and nothing else. The rows are the
+ * caller's, laid out by flexbox in the order they were written; the component
+ * only ever adds a transform to them.
+ */
+declare function SortableRoot({ className, value, children, onReorder, gap, activation, longPressDelay, haptics, disabled, scrollRef, autoscrollThreshold, autoscrollSpeed, onDragStart, onDragEnd, ...props }: SortableProps): import("react").JSX.Element;
+declare namespace SortableRoot {
+    var displayName: string;
+}
+export interface SortableItemProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /**
+     * What this row is, and the id that appears in `value` and in the order
+     * handed back. Stable across renders — an id derived from the index changes
+     * the moment the list is reordered, and the rows lose track of themselves.
+     */
+    id: string;
+    children?: ReactNode;
+    /**
+     * Stop this row being picked up. The others still move past it, because a
+     * row that cannot be dragged is not the same as a row that cannot be
+     * displaced — a pinned row is a different feature, and pretending this one
+     * is it would mean silently refusing drops that look like they worked.
+     */
+    disabled?: boolean;
+    /**
+     * Extra classes for the row while it is being carried, applied last. A
+     * lifted row is given an opaque surface and a shadow so it is never drawn
+     * see-through over the rows it is passing; this is what overrides that.
+     */
+    activeClassName?: string;
+}
+/**
+ * One row.
+ *
+ * It measures itself, carries its own transform, and holds the pan — which is
+ * either wrapped around the whole row or handed to a `Sortable.Handle` inside
+ * it, depending on what lifts a row in this list.
+ */
+declare function SortableItem({ className, activeClassName, id, children, disabled, ...props }: SortableItemProps): import("react").JSX.Element;
+declare namespace SortableItem {
+    var displayName: string;
+}
+export interface SortableHandleProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Replaces the grip glyph. Anything at all — the drag is on the box. */
+    children?: ReactNode;
+    /** What a screen reader calls the grip. */
+    accessibilityLabel?: string;
+}
+/**
+ * The part of a row that lifts it.
+ *
+ * A grip exists so the rest of the row does not have to be given up to the
+ * drag: a row with a button, a checkbox or a link on it needs those to stay
+ * pressable, and a long press on the whole row takes all of them. It is sized
+ * to be hit rather than to be seen, which is why the box around the glyph is
+ * larger than the glyph.
+ *
+ * Inert in a list that lifts on a long press — the whole row already carries
+ * the gesture there, and a second one inside it would fight the first.
+ */
+declare function SortableHandle({ className, children, accessibilityLabel, ...props }: SortableHandleProps): import("react").JSX.Element;
+declare namespace SortableHandle {
+    var displayName: string;
+}
+export declare const Sortable: typeof SortableRoot & {
+    Item: typeof SortableItem;
+    Handle: typeof SortableHandle;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -27,6 +27,11 @@
  *
  * Everything that moves runs on the UI thread. A row being dragged does not
  * re-render — the only React work in a swipe is the callback at the end of it.
+ *
+ * Rows in a `Swipe.Group` close each other, so only one of them is ever open.
+ * That is the behaviour of every list on the phone that has this gesture, and
+ * a row cannot arrange it alone: it knows when it opens and has no way to hear
+ * that a sibling did.
  */
 import { type ReactNode } from 'react';
 import { View, type ViewProps } from 'react-native';
@@ -40,6 +45,35 @@ export interface SwipeHandle {
     /** Put the row back. */
     close: () => void;
 }
+export interface SwipeGroupProps extends ViewProps {
+    className?: string;
+    children?: ReactNode;
+    /**
+     * Close the other rows when one opens. On by default — that is the whole
+     * reason to reach for a group. Turning it off keeps the container and the
+     * `useSwipeGroup` handle while letting several rows stand open at once.
+     */
+    exclusive?: boolean;
+}
+/**
+ * Shut every row in the enclosing `Swipe.Group`.
+ *
+ * The one thing a group knows that a single row cannot: a list that scrolls,
+ * navigates away, or has just deleted the row that was open wants all of them
+ * put back, and holding a ref to each row to do it by hand is bookkeeping the
+ * group is already doing.
+ *
+ * ```tsx
+ * const { closeAll } = useSwipeGroup();
+ * <ScrollView onScrollBeginDrag={closeAll}>…</ScrollView>
+ * ```
+ *
+ * Outside a group it is inert rather than an error, so a row that is sometimes
+ * grouped and sometimes not does not need two versions of its parent.
+ */
+export declare function useSwipeGroup(): {
+    closeAll: () => void;
+};
 /**
  * A tile is a filled block of colour with its content laid over it, which
  * settles both halves of how it is coloured:
@@ -198,6 +232,7 @@ export interface SwipeProps extends Omit<ViewProps, 'children'> {
     contentClassName?: string;
 }
 export declare const Swipe: import("react").ForwardRefExoticComponent<SwipeProps & import("react").RefAttributes<SwipeHandle>> & {
+    Group: import("react").ForwardRefExoticComponent<SwipeGroupProps & import("react").RefAttributes<View>>;
     Start: import("react").ForwardRefExoticComponent<SwipePanelProps & import("react").RefAttributes<View>>;
     End: import("react").ForwardRefExoticComponent<SwipePanelProps & import("react").RefAttributes<View>>;
     Action: import("react").ForwardRefExoticComponent<SwipeActionProps & import("react").RefAttributes<View>>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/swipe/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAYL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,IAAI,EAA0B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAU5E,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA0B1D,KAAK,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;AAEjC,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,IAAI,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAChC,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAYD;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAkBlB,CAAC;AAEH,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,MAAM,GACN,aAAa,CAAC;AAelB,MAAM,WAAW,gBACf,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,EACjC,YAAY,CAAC,OAAO,cAAc,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mCAAmC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA0FD,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA+CD,MAAM,WAAW,UAAW,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAC7C,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAkVD,eAAO,MAAM,KAAK;;;;CAIhB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/swipe/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAaL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,IAAI,EAA0B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAU5E,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA0B1D,KAAK,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;AAEjC,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,IAAI,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAChC,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AA2BD,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA2ED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,IAAI;IAAE,QAAQ,EAAE,MAAM,IAAI,CAAA;CAAE,CAIxD;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAkBlB,CAAC;AAEH,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,MAAM,GACN,aAAa,CAAC;AAelB,MAAM,WAAW,gBACf,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,EACjC,YAAY,CAAC,OAAO,cAAc,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mCAAmC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA0FD,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA+CD,MAAM,WAAW,UAAW,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAC7C,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAgXD,eAAO,MAAM,KAAK;;;;;CAKhB,CAAC"}