panelui-native 0.53.0 → 0.56.0

package/lib/typescript/src/components/hex-chart/index.d.ts

@@ -0,0 +1,277 @@
+/**
+ * HexChart — a whole broken into parts, counted out in cells.
+ *
+ * ```tsx
+ * <HexChart data={attribution}>
+ *   <HexChart.Header title="Attributed revenue" value="$6,750" />
+ *   <HexChart.Cells />
+ *   <HexChart.Legend />
+ * </HexChart>
+ * ```
+ *
+ * ## What it is, against the pie beside it
+ *
+ * Both divide one total. The difference is what the reader has to do to read a
+ * share off it. A pie asks them to compare angles, which is the hardest
+ * quantity there is to judge by eye; this asks them to compare *counts*, and a
+ * count is something anyone can check by looking. A series holding a tenth of
+ * the cells looks like a tenth and can be confirmed as one, which is why this
+ * is the better shape for a split someone is going to quote.
+ *
+ * What it gives up is precision at the small end. Every cell is a whole unit,
+ * so a series worth half a cell either rounds up to a full one or vanishes. It
+ * is a chart for shares of a few percent and up, not for a long tail.
+ *
+ * ## The field
+ *
+ * The cells are pointy-top hexagons on an offset grid, so each row nests half a
+ * cell into the one above it. The unfilled cells are drawn too, in the muted
+ * token: the field is the denominator made visible, and a honeycomb floating on
+ * nothing gives the eye no total to read the coloured part against.
+ *
+ * `shape` decides how the filled cells are arranged. `grid` is reading order,
+ * which is the arrangement a reader can actually count off. `blob` grows the
+ * series out from the middle of the field instead — the smallest in the centre,
+ * each larger one wrapped around it — which counts for nothing but shows the
+ * shape of the split at a glance. The blob's edge is ragged by design, and
+ * ragged the *same way* every time: the nudge that roughens it is a hash of
+ * each cell's own coordinates rather than a random number, so a re-render is
+ * not an animation and the same data screenshots twice.
+ *
+ * Cell counts are apportioned by largest remainder, so they add up to the
+ * budget exactly. A honeycomb whose parts came to one less than the whole would
+ * have a cell in it that nothing in the data accounts for.
+ *
+ * ## Drawing and animating
+ *
+ * Two hundred cells is two hundred nodes if each one is drawn on its own, which
+ * is more than this needs to spend. Every cell belonging to a series is
+ * concatenated into a *single* path instead, so the whole chart is one node per
+ * series plus one for the unfilled field — six or seven, whatever the cell
+ * count.
+ *
+ * That is also why the reveal is a clip rather than a per-cell stagger: the
+ * cells are no longer separate things to stagger. An ellipse grows from the
+ * centre of the field, in the field's own proportions, so the honeycomb is
+ * uncovered in the order the blob grew in — which is the same effect a stagger
+ * would have given, for one animated value instead of two hundred. A `grid`
+ * wipes across instead, because that is the order its cells were filled in.
+ *
+ * Touch, not hover: a series is selected by pressing one of its cells, and
+ * pressing it again clears the selection. There is no equivalent of a pointer
+ * resting somewhere without committing, so a chart that only revealed its
+ * numbers on hover would never reveal them at all.
+ *
+ * Colours come from the `--color-chart-*` tokens, so a chart follows the active
+ * theme and is put on brand by overriding those five. Nothing here hardcodes a
+ * hex.
+ */
+import { type ReactNode } from 'react';
+import { type ViewProps } from 'react-native';
+import { type HexShape } from '../../utils/chart.js';
+/** Whether the chart is showing data or waiting for it. */
+export type HexChartStatus = 'loading' | 'ready';
+export type { HexShape };
+/** One series. Its share is worked out from the others, so there is no maximum. */
+export interface HexDatum {
+    /** Name for the legend, the readout and the accessibility label. */
+    label: string;
+    /** How much of the whole this series is. Negatives are treated as zero. */
+    value: number;
+    /** Explicit colour, overriding the `--color-chart-*` token. */
+    color?: string;
+}
+/** The selected series and its share, for something rendered inside the chart. */
+export declare function useHexChart(): {
+    activeIndex: number;
+    activeSeries: HexDatum | null;
+    /** Its share of the whole, 0 to 1. */
+    activeFraction: number;
+    /** How many cells it was given, which is what the reader can count. */
+    activeCells: number;
+};
+export interface HexChartProps extends ViewProps {
+    className?: string;
+    /** One entry per series. */
+    data: HexDatum[];
+    /**
+     * Cells across the field. The cell size follows from it and the measured
+     * width, so this is the one knob for how fine the honeycomb is.
+     *
+     * More cells resolve a smaller share — twenty-one across a phone is around
+     * two hundred and fifty in the field, so roughly a half a percent each — at
+     * the cost of every cell getting smaller and harder to press.
+     */
+    columns?: number;
+    /** Width over height of the field. */
+    aspectRatio?: number;
+    /**
+     * How much of the field the series fill, 0 to 1.
+     *
+     * Only meaningful with `shape="blob"`, where the unfilled cells are the
+     * margin the blob is read against; a `grid` fills every cell, because a
+     * waffle with a ragged last row is a waffle that has stopped being countable.
+     */
+    density?: number;
+    /** How the filled cells are arranged. */
+    shape?: HexShape;
+    /**
+     * The gap between cells, as a share of the cell radius. Given as a share so
+     * the field keeps its proportions at whatever size it is measured at.
+     */
+    cellGap?: number;
+    /** Milliseconds for the honeycomb to fill in. */
+    animationDuration?: number;
+    /** `loading` draws the field with nothing divided up yet. */
+    status?: HexChartStatus;
+    /** Selected series. Leave unset to let the chart track it. */
+    activeIndex?: number;
+    /** Fires with the selected series, or `-1` when the selection is cleared. */
+    onActiveIndexChange?: (index: number) => void;
+    children?: ReactNode;
+}
+/** Imperative handle: re-run the fill, for a "replay" control. */
+export interface HexChartHandle {
+    replay: () => void;
+}
+export interface HexChartCellsProps {
+    /** Colour of the cells no series took. Defaults to the muted token. */
+    emptyColor?: string;
+    /** Opacity of the series that are not selected, once one is. */
+    dimOpacity?: number;
+}
+/**
+ * The honeycomb: the unfilled field, and one path per series over it.
+ *
+ * One part rather than one per series. Every cell shares a radius, a gap and a
+ * grid by definition — a chart where one series' cells could be given a size of
+ * their own would be a chart drawing a lie, since the whole claim of the shape
+ * is that one cell means the same thing wherever it appears.
+ *
+ * The field is drawn outside the reveal's clip and the series inside it, so the
+ * total is there from the first frame and what fills in against it is the
+ * split. Uncovering both together would animate the denominator, which is not
+ * something that changed.
+ */
+declare function HexChartCells({ emptyColor, dimOpacity }: HexChartCellsProps): import("react").JSX.Element | null;
+declare namespace HexChartCells {
+    var displayName: string;
+    var slot: "svg";
+}
+export interface HexChartSkeletonProps {
+    color?: string;
+}
+/**
+ * The loading state: the field, with nothing divided up yet.
+ *
+ * Deliberately undivided. Placeholder shares would be a made-up split, and a
+ * reader has no way to tell an invented one from a real one until it changes
+ * under them — which is worse than showing nothing, because it is showing
+ * something wrong.
+ */
+declare function HexChartSkeleton({ color }: HexChartSkeletonProps): import("react").JSX.Element | null;
+declare namespace HexChartSkeleton {
+    var displayName: string;
+    var slot: "svg";
+}
+export interface HexChartTooltipProps {
+    /** Format the selected series' value. Defaults to a compact number. */
+    formatValue?: (value: number, series: HexDatum) => string;
+    /** Show the count of cells beside the share. */
+    showCells?: boolean;
+    className?: string;
+}
+/**
+ * The press target over the honeycomb, and the label that names what was
+ * pressed.
+ *
+ * The label hangs *above* the selected series rather than on it: it is centred
+ * across that series' cells and sits clear of the highest one, so the cells
+ * being read are never underneath the thing reading them. Two other places it
+ * could go are both worse — under the finger is the one part of the chart
+ * nobody can see, and on the middle of the series covers the mass the reader
+ * just asked about.
+ *
+ * A series reaching the top of the field pushes the label back inside it, which
+ * is the one case it does overlap. That series is the largest one, and its
+ * topmost cells are the part of it a reader is least likely to be counting.
+ *
+ * A press on an unfilled cell clears the selection, the same as pressing the
+ * selected series again. Everything outside the honeycomb is "none of them",
+ * and making that gesture do nothing would leave a chart you can select in but
+ * not out of.
+ */
+declare function HexChartTooltip({ formatValue, showCells, className }: HexChartTooltipProps): import("react").JSX.Element | null;
+declare namespace HexChartTooltip {
+    var displayName: string;
+    var slot: "overlay";
+}
+export interface HexChartLegendProps extends ViewProps {
+    className?: string;
+    /** Show each series' share of the whole beside its name. */
+    showValue?: boolean;
+}
+/**
+ * A swatch, a name and a share per series, under the chart and across the width
+ * of it. Pressable in the same way the cells are — the legend is usually the
+ * easier target of the two, and a series worth a couple of percent is a handful
+ * of cells that may not be adjacent.
+ *
+ * It wraps rather than stacking, so five or six entries take two lines instead
+ * of six. A key is a lookup table, and a lookup table read down a column of one
+ * word each is a column the eye has to walk.
+ */
+declare function HexChartLegend({ className, showValue, ...props }: HexChartLegendProps): import("react").JSX.Element | null;
+declare namespace HexChartLegend {
+    var displayName: string;
+    var slot: "footer";
+}
+export interface HexChartHeaderProps extends ViewProps {
+    className?: string;
+    /** Small line above the value — what the chart is of. */
+    title?: string;
+    /** The readout. The largest thing on the card, and the first thing read. */
+    value?: string;
+    /** One muted line under the value — a period, a comparison, a caveat. */
+    caption?: string;
+    /** Prettier names for the series, keyed by their `label`. */
+    labels?: Record<string, string>;
+    /**
+     * Draw a swatch and a name per series along the trailing edge.
+     *
+     * For two or three short names. Past that use `HexChart.Legend`, which runs
+     * under the chart across the full width: a key of five long names crammed
+     * into the trailing corner of a header wraps to a column and leaves the title
+     * beside it a few points wide.
+     */
+    legend?: boolean;
+    /** Trailing slot — a control, a badge, a range picker. Wins over `legend`. */
+    children?: ReactNode;
+}
+/**
+ * The strip above the honeycomb: what the chart is of, what it reads, and what
+ * the colours mean.
+ *
+ * It belongs to the chart rather than to the card around it because it is about
+ * the *series* — the number changes as one is selected, and the legend is the
+ * list the chart itself is holding. The card's header is a caption on the tray
+ * the chart sits in; this is the chart introducing itself.
+ *
+ * The value is not derived here even though there is a total to derive it from,
+ * because the formatting is not the chart's to guess: a total of 6750 is a
+ * count, a currency or a percentage depending on what was counted, and only the
+ * caller knows which.
+ */
+declare function HexChartHeader({ className, title, value, caption, labels, legend, children, ...props }: HexChartHeaderProps): import("react").JSX.Element;
+declare namespace HexChartHeader {
+    var displayName: string;
+    var slot: "header";
+}
+export declare const HexChart: import("react").ForwardRefExoticComponent<HexChartProps & import("react").RefAttributes<HexChartHandle>> & {
+    Header: typeof HexChartHeader;
+    Cells: typeof HexChartCells;
+    Tooltip: typeof HexChartTooltip;
+    Legend: typeof HexChartLegend;
+    Skeleton: typeof HexChartSkeleton;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/hex-chart/index.d.ts.map

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

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

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

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

@@ -14,6 +14,18 @@
  * Steps does not own your flow: it reflects whatever step your app says is
  * active. Pass `value` to control it, or `defaultValue` to let it manage
  * its own.
+ *
+ * The connectors are the component's job, not yours. The root counts the items
+ * it holds and each one draws the connector to the next, so a stepper is just
+ * its steps — there is no separator to forget, mis-order, or leave dangling
+ * past the last stop. An item that contains its own `Steps.Separator` keeps it
+ * and gets no second one, so hand-placed connectors still work; `separators`
+ * turns the automatic ones off wholesale.
+ *
+ * Knowing the count is also what lets a step say where it sits. A screen reader
+ * reaching the middle of a wizard hears "Payment, step 2 of 3, completed" —
+ * the position and the state, which are the two things the circle and its fill
+ * convey to everyone else.
  */
 import { type ReactNode } from 'react';
 import { View, type Text as RNText, type ViewProps } from 'react-native';
@@ -28,6 +40,13 @@ export interface StepsProps extends ViewProps {
     value?: number;
     onValueChange?: (value: number) => void;
     orientation?: StepsOrientation;
+    /**
+     * Draw the connector between one item and the next. On by default — an item
+     * that holds its own `Steps.Separator` is left alone either way, so this is
+     * for a stepper that wants no connectors at all rather than for one that
+     * places them by hand.
+     */
+    separators?: boolean;
     children?: ReactNode;
 }
 export interface StepsItemProps extends ViewProps {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/steps/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAa,IAAI,EAAE,KAAK,IAAI,IAAI,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAIpF,OAAO,EAAQ,KAAK,SAAS,EAAgB,MAAM,0BAAuB,CAAC;AAG3E,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AACxE,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,UAAU,CAAC;AAuFzD,MAAM,WAAW,UAAW,SAAQ,SAAS;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA6CD,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAqCD,MAAM,WAAW,iBAAkB,SAAQ,SAAS;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA0BD,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAoDD,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA4BD,eAAO,MAAM,KAAK;;;;;;;CAOhB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/steps/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EASL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAa,IAAI,EAAE,KAAK,IAAI,IAAI,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAIpF,OAAO,EAAQ,KAAK,SAAS,EAAgB,MAAM,0BAAuB,CAAC;AAG3E,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AACxE,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,UAAU,CAAC;AAuGzD,MAAM,WAAW,UAAW,SAAQ,SAAS;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmED,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmDD,MAAM,WAAW,iBAAkB,SAAQ,SAAS;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AA8CD,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAoDD,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA8BD,eAAO,MAAM,KAAK;;;;;;;CAOhB,CAAC"}

package/lib/typescript/src/components/tag-input/index.d.ts

@@ -0,0 +1,240 @@
+/**
+ * TagInput — a field whose value is a list of tokens rather than a string.
+ *
+ * The value is whatever gets typed. That is the whole distinction from a
+ * `Combobox` in `multiple` mode: a Combobox picks from a set of options you
+ * supply, so it needs a list, a filter and a surface to float that list on. A
+ * tag field has no options and no list — labels on a task, recipients on a
+ * message, keywords on a post — so it carries none of that machinery and never
+ * opens a portal.
+ *
+ * ```tsx
+ * <TagInput
+ *   label="Topics"
+ *   defaultValue={['expo', 'reanimated']}
+ *   placeholder="Add a topic"
+ * />
+ * ```
+ *
+ * ## Three ways a tag gets committed
+ *
+ * Return commits what has been typed. So does any of `delimiters` — a comma by
+ * default — which is what makes pasting `design, research, ops` land as three
+ * tags instead of one long one. And `blurBehavior` decides what a field that
+ * loses focus mid-word does with the leftover.
+ *
+ * ## Backspace asks first
+ *
+ * Backspace on an empty field marks the last tag rather than taking it: the
+ * tag turns destructive, and a second backspace removes it. A held backspace
+ * repeats, and a field that deleted on the first one would empty itself in the
+ * time it takes to notice — the mark is the beat that lets you stop.
+ */
+import { type ReactNode } from 'react';
+import { TextInput, type TextInputProps } from 'react-native';
+import { type VariantProps } from 'tailwind-variants';
+import { type ChipVariant } from '../chip/index.js';
+declare const tagInputVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        outline: {
+            field: string;
+        };
+        filled: {
+            field: string;
+        };
+    };
+    size: {
+        sm: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        md: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        lg: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+    };
+    disabled: {
+        true: {
+            field: string;
+        };
+    };
+}, {
+    container: string;
+    field: string;
+    input: string;
+    clear: string;
+    description: string;
+    error: string;
+    count: string;
+}, undefined, {
+    variant: {
+        outline: {
+            field: string;
+        };
+        filled: {
+            field: string;
+        };
+    };
+    size: {
+        sm: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        md: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        lg: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+    };
+    disabled: {
+        true: {
+            field: string;
+        };
+    };
+}, {
+    container: string;
+    field: string;
+    input: string;
+    clear: string;
+    description: string;
+    error: string;
+    count: string;
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        outline: {
+            field: string;
+        };
+        filled: {
+            field: string;
+        };
+    };
+    size: {
+        sm: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        md: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+        lg: {
+            field: string;
+            input: string;
+            clear: string;
+        };
+    };
+    disabled: {
+        true: {
+            field: string;
+        };
+    };
+}, {
+    container: string;
+    field: string;
+    input: string;
+    clear: string;
+    description: string;
+    error: string;
+    count: string;
+}, undefined, unknown, unknown, undefined>>;
+type TagInputVariantProps = VariantProps<typeof tagInputVariants>;
+export type TagInputVariant = NonNullable<TagInputVariantProps['variant']>;
+export type TagInputSize = NonNullable<TagInputVariantProps['size']>;
+/** Why a tag was turned away, for a caller that wants to say so. */
+export type TagRejection = 'duplicate' | 'max' | 'invalid';
+/** What a field that loses focus mid-word does with the leftover text. */
+export type TagBlurBehavior = 'add' | 'clear' | 'keep';
+export interface TagInputProps extends Omit<TextInputProps, 'value' | 'defaultValue' | 'onChangeText' | 'editable' | 'multiline' | 'children'>, Omit<TagInputVariantProps, 'disabled'> {
+    /** Classes for the field box — the bordered container the tags sit in. */
+    className?: string;
+    /** Classes for the outer column that also holds the label and the error. */
+    containerClassName?: string;
+    /** The tags, controlled. Pair it with `onValueChange`. */
+    value?: string[];
+    /** The tags to start with, when the field keeps its own value. */
+    defaultValue?: string[];
+    /** Called with the whole list whenever a tag is added or removed. */
+    onValueChange?: (tags: string[]) => void;
+    /**
+     * The text being typed, controlled. Only needed to drive the draft from
+     * outside — the tags themselves are `value`.
+     */
+    inputValue?: string;
+    /** Called as the draft text changes, before it becomes a tag. */
+    onInputValueChange?: (text: string) => void;
+    /** The label above the field, and what the input is announced as. */
+    label?: string;
+    /** A line under the field, replaced by `errorMessage` when there is one. */
+    description?: string;
+    /** Error message. When set, the field renders in its invalid state. */
+    errorMessage?: string;
+    /** Marks the field required — an asterisk on the label, and the a11y state. */
+    isRequired?: boolean;
+    /** Dims the field and stops it being reached at all. */
+    disabled?: boolean;
+    /** Shows the tags but takes away the input and the ✕ on each one. */
+    readOnly?: boolean;
+    /**
+     * The most tags the field accepts. Past it nothing more is committed and
+     * `onReject` is called with `'max'`, unless `allowOverflow` is set.
+     */
+    max?: number;
+    /**
+     * Let the list go past `max` anyway. The field reports itself invalid while
+     * it is over, which is the point: some forms want the count shown as wrong
+     * rather than the typing refused.
+     */
+    allowOverflow?: boolean;
+    /** Accept a tag the list already holds. Off by default. */
+    allowDuplicates?: boolean;
+    /**
+     * Characters that end a tag as they are typed. A comma by default, which is
+     * what makes a pasted `a, b, c` land as three tags rather than one.
+     */
+    delimiters?: string[];
+    /**
+     * What happens to text still in the field when it loses focus. `add` commits
+     * it and clears it if it was accepted, leaving it in place if it was not, so
+     * a rejected word is still there to fix. `clear` drops it. `keep` leaves it
+     * exactly as typed.
+     */
+    blurBehavior?: TagBlurBehavior;
+    /**
+     * Decide whether a tag may be added, given the list it would join. Return
+     * `false` to turn it away — `onReject` is then called with `'invalid'`.
+     */
+    validate?: (tag: string, tags: string[]) => boolean;
+    /** Called when a tag was turned away, with the reason it was. */
+    onReject?: (tag: string, reason: TagRejection) => void;
+    /** Which Chip variant the tags are drawn as. */
+    chipVariant?: ChipVariant;
+    /** Draw the tag yourself — an avatar before the label, a count after it. */
+    renderTag?: (tag: string, index: number) => ReactNode;
+    /** A ✕ at the end of the field that empties it. */
+    clearable?: boolean;
+    /** Shows `3 / 8` under the field. Needs `max`. */
+    showCount?: boolean;
+    /**
+     * A tick under the finger as a tag lands or leaves. Off by default — needs
+     * the optional `expo-haptics`, and is silent without it.
+     */
+    haptics?: boolean;
+}
+export declare const TagInput: import("react").ForwardRefExoticComponent<TagInputProps & import("react").RefAttributes<TextInput>>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/tag-input/index.d.ts.map

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