@xaui/native 0.9.1-alpha.9 → 0.9.1-alpha.90

package/dist/utils/mask.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The four shapes `MaskField` ships ready-made. Anything else is a **pattern string** —
+ * `#` a digit, `A` a letter, `*` either, every other character a literal put back in as the
+ * parts fill.
+ */
+export type MaskFieldMask = 'date' | 'time' | 'datetime' | 'credit-card';
+export declare const MASK_FIELD_MASKS: readonly ["date", "time", "datetime", "credit-card"];
+/**
+ * Which of the three parts of a date comes first, and which second.
+ *
+ * Three orders rather than every permutation, because these are the three the world writes:
+ * day-first across most of Europe, month-first in the United States, year-first in East
+ * Asia and in ISO 8601.
+ */
+export type DateOrder = 'DMY' | 'MDY' | 'YMD';
+/** What a placeholder calls each date part. The letters are a language's, so they are given. */
+export type SegmentLabels = {
+    day: string;
+    month: string;
+    year: string;
+};
+/** The class of input a fill position accepts. */
+type Fill = 'digit' | 'letter' | 'alnum';
+/**
+ * One run of a resolved mask: a `fill` of positions that accept input, or a `literal` that
+ * is typed back in once the parts before it have something in them.
+ *
+ * A completed fill may `clamp` — a month at 12, a day at the length of its month — reading
+ * the parts already written to do it. A fill is never *raised*: a reader halfway through
+ * `01` has typed a zero, and moving it under them loses the keystroke.
+ */
+type Part = {
+    kind: 'fill';
+    fill: Fill;
+    width: number;
+    name: string;
+    clamp?: (raw: string, written: Record<string, string>) => string;
+} | {
+    kind: 'literal';
+    text: string;
+};
+/** A mask resolved to the parts a keystroke is walked through. */
+export type Mask = {
+    parts: readonly Part[];
+    /** The shape shown when the box is empty — `DD/MM/YYYY`, `#### #### #### ####`. */
+    placeholder: string;
+    /** The full rendered length, so the field can cap the caret at the end of the shape. */
+    length: number;
+    /** `number-pad` when every fill is digits, `default` otherwise. */
+    keyboard: 'number-pad' | 'default';
+};
+/**
+ * The order that locale writes a date in.
+ *
+ * Read out of `Intl` rather than off a table of countries: the platform already ships the
+ * answer for every locale it supports, and a table here would be a second one, shorter and
+ * out of date. A locale `Intl` does not know falls back to day-first, which is what most of
+ * the world writes.
+ */
+export declare function dateOrderFor(locale: string): DateOrder;
+/**
+ * The separator that locale writes between the date parts.
+ *
+ * The same argument as the order, and the same fallback. A locale that writes its date with
+ * a word between the parts — some do — has no single separator, so anything that is not one
+ * character comes back as a slash.
+ */
+export declare function dateSeparatorFor(locale: string): string;
+export type ResolveMaskOptions = {
+    /** The order and the separator come from here for `date` / `datetime` when neither is set. */
+    locale?: string;
+    /** Give it when the order is a decision rather than a locale — an ISO field is `YMD`. */
+    order?: DateOrder;
+    /** Between the date parts. Unset, it is the one the locale writes. */
+    separator?: string;
+    /** What the placeholder calls each date part. */
+    labels?: SegmentLabels;
+};
+/**
+ * A `mask` prop — a preset name or a pattern string — to the parts a keystroke walks.
+ *
+ * The presets carry rules a pattern cannot: `date` and `datetime` take their order and
+ * separator from the locale, and `date`, `datetime` and `time` clamp their parts as they
+ * complete. `credit-card` and any pattern are shape only.
+ */
+export declare function resolveMask(spec: MaskFieldMask | string, options?: ResolveMaskOptions): Mask;
+/**
+ * What the reader typed, as this mask writes it.
+ *
+ * The input and the parts are walked in lockstep: a literal is **eaten** off the input when
+ * it is already there and **put back** when it is not, and a fill takes the next characters
+ * of its class, skipping anything that is not. That is what makes the field survive a paste,
+ * a keyboard that offers its own punctuation, a backspace over a separator — and being run
+ * over its own output, which a field re-rendered from a controlled `value` does on every
+ * keystroke. `maskInput(maskInput(x))` is `maskInput(x)`.
+ *
+ * A fill is clamped only once it is full, and never raised.
+ */
+export declare function maskInput(input: string, mask: Mask): string;
+/**
+ * The `Date` a `date` mask's text is, or `null` while it is not one.
+ *
+ * `null` covers both "not finished" and "not a real day", and deliberately so: a caller
+ * holding a `Date | null` needs no third state. A year is taken as written — `0023` is the
+ * year 23, not 2023 — since guessing a century is the kind of help that is wrong once and
+ * then silently wrong forever.
+ */
+export declare function parseMaskedDate(text: string, locale?: string, order?: DateOrder): Date | null;
+/** A `Date` as a `date` mask writes it — the inverse of `parseMaskedDate`. */
+export declare function formatMaskedDate(date: Date, locale?: string, order?: DateOrder, separator?: string): string;
+/** The hours and minutes a `time` mask's text is, or `null` while it is not both. */
+export declare function parseMaskedTime(text: string): {
+    hours: number;
+    minutes: number;
+} | null;
+/** Hours and minutes as a `time` mask writes them — `09:05`. */
+export declare function formatMaskedTime(time: {
+    hours: number;
+    minutes: number;
+}): string;
+export {};

package/dist/utils/number.d.cts

@@ -0,0 +1,73 @@
+/**
+ * The three things a number in a control is made of: reading one out of what was typed,
+ * writing one back, and moving one by a step. Shared by `NumberField`, which types it, and
+ * `NumberStepper`, which only walks it.
+ *
+ * Pure, because none of the three can be seen in a screenshot. A number field that eats a
+ * group separator, that turns `0.1 + 0.2` into `0.30000000000000004`, or that lets a
+ * stepper run one press past its own ceiling needs a table of inputs and outputs — which
+ * is what a test is.
+ */
+/** How far a value is allowed to travel. Either end may be absent. */
+export type NumberBounds = {
+    min?: number;
+    max?: number;
+};
+/**
+ * Which characters this locale separates a number's parts with.
+ *
+ * Read off `Intl` rather than tabulated: the group mark is a comma in `en-US`, a full stop
+ * in `de-DE` and a **narrow no-break space** in `fr-FR`, and a table of those is a table
+ * that goes stale. `Intl` is also the thing most likely to be missing — a Hermes build
+ * compiled without ICU has no `NumberFormat` at all — so a failure falls back rather than
+ * throwing out of a render.
+ */
+export declare function numberMarks(locale: string): {
+    group: string;
+    decimal: string;
+};
+/**
+ * The number a reader typed, or `null` while what they typed is not one yet.
+ *
+ * Everything that is not a digit, a sign or the decimal mark is **dropped rather than
+ * rejected**: a field shows its value grouped, and the moment the caret goes back into it
+ * the group separators are still there. Refusing them would make the first keystroke on an
+ * existing value clear the box.
+ *
+ * A full stop passes as the decimal mark wherever the locale is not using it to group —
+ * so `1.5` reads as one and a half in `fr-FR`, whose number pad offers a full stop, and
+ * `1.234` still reads as a thousand-odd in `de-DE`, where it is the grouping.
+ *
+ * `null` and not `NaN`: "not a number yet" is the state a half-typed field is in for as
+ * long as it takes to type a minus sign, and `NaN` is a value that propagates instead of a
+ * state a caller can test.
+ */
+export declare function parseNumber(text: string, locale?: string): number | null;
+/**
+ * The value as the field writes it out.
+ *
+ * `Intl` again, and the same fallback for the same reason: a locale that cannot be
+ * resolved is not a reason for a field to stop rendering its own value.
+ */
+export declare function formatNumber(value: number, locale?: string, options?: Intl.NumberFormatOptions): string;
+/** The value, brought back inside its bounds. An absent bound stops nothing. */
+export declare function clampNumber(value: number, { min, max }: NumberBounds): number;
+/**
+ * One press of a stepper: the value moved by `step`, then clamped.
+ *
+ * **From an empty field the step starts at zero**, which is what puts the first press on
+ * `min` when the range starts above it — `min={5}` and a step of one gives 5, not 6.
+ *
+ * A **negative `step` is the decrement**, rather than a direction argument beside it: the
+ * two buttons differ by a sign and nothing else, and a `direction` parameter would be a
+ * second way to say the same thing that the clamping then has to agree with.
+ */
+export declare function stepNumber(value: number | null, step: number, bounds: NumberBounds): number;
+/**
+ * Whether that press would change anything — which is exactly when the button is live.
+ *
+ * Asked of the **result** rather than of the bound, because those two disagree on the last
+ * press: a value of 9.5 under a ceiling of 10 cannot take a whole step, but it can still
+ * reach the ceiling, and a button disabled there strands the reader half a step short.
+ */
+export declare function canStep(value: number | null, step: number, bounds: NumberBounds): boolean;

package/dist/utils/number.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The three things a number in a control is made of: reading one out of what was typed,
+ * writing one back, and moving one by a step. Shared by `NumberField`, which types it, and
+ * `NumberStepper`, which only walks it.
+ *
+ * Pure, because none of the three can be seen in a screenshot. A number field that eats a
+ * group separator, that turns `0.1 + 0.2` into `0.30000000000000004`, or that lets a
+ * stepper run one press past its own ceiling needs a table of inputs and outputs — which
+ * is what a test is.
+ */
+/** How far a value is allowed to travel. Either end may be absent. */
+export type NumberBounds = {
+    min?: number;
+    max?: number;
+};
+/**
+ * Which characters this locale separates a number's parts with.
+ *
+ * Read off `Intl` rather than tabulated: the group mark is a comma in `en-US`, a full stop
+ * in `de-DE` and a **narrow no-break space** in `fr-FR`, and a table of those is a table
+ * that goes stale. `Intl` is also the thing most likely to be missing — a Hermes build
+ * compiled without ICU has no `NumberFormat` at all — so a failure falls back rather than
+ * throwing out of a render.
+ */
+export declare function numberMarks(locale: string): {
+    group: string;
+    decimal: string;
+};
+/**
+ * The number a reader typed, or `null` while what they typed is not one yet.
+ *
+ * Everything that is not a digit, a sign or the decimal mark is **dropped rather than
+ * rejected**: a field shows its value grouped, and the moment the caret goes back into it
+ * the group separators are still there. Refusing them would make the first keystroke on an
+ * existing value clear the box.
+ *
+ * A full stop passes as the decimal mark wherever the locale is not using it to group —
+ * so `1.5` reads as one and a half in `fr-FR`, whose number pad offers a full stop, and
+ * `1.234` still reads as a thousand-odd in `de-DE`, where it is the grouping.
+ *
+ * `null` and not `NaN`: "not a number yet" is the state a half-typed field is in for as
+ * long as it takes to type a minus sign, and `NaN` is a value that propagates instead of a
+ * state a caller can test.
+ */
+export declare function parseNumber(text: string, locale?: string): number | null;
+/**
+ * The value as the field writes it out.
+ *
+ * `Intl` again, and the same fallback for the same reason: a locale that cannot be
+ * resolved is not a reason for a field to stop rendering its own value.
+ */
+export declare function formatNumber(value: number, locale?: string, options?: Intl.NumberFormatOptions): string;
+/** The value, brought back inside its bounds. An absent bound stops nothing. */
+export declare function clampNumber(value: number, { min, max }: NumberBounds): number;
+/**
+ * One press of a stepper: the value moved by `step`, then clamped.
+ *
+ * **From an empty field the step starts at zero**, which is what puts the first press on
+ * `min` when the range starts above it — `min={5}` and a step of one gives 5, not 6.
+ *
+ * A **negative `step` is the decrement**, rather than a direction argument beside it: the
+ * two buttons differ by a sign and nothing else, and a `direction` parameter would be a
+ * second way to say the same thing that the clamping then has to agree with.
+ */
+export declare function stepNumber(value: number | null, step: number, bounds: NumberBounds): number;
+/**
+ * Whether that press would change anything — which is exactly when the button is live.
+ *
+ * Asked of the **result** rather than of the bound, because those two disagree on the last
+ * press: a value of 9.5 under a ceiling of 10 cannot take a whole step, but it can still
+ * reach the ceiling, and a button disabled there strands the reader half a step short.
+ */
+export declare function canStep(value: number | null, step: number, bounds: NumberBounds): boolean;

package/dist/utils/phone-number.d.cts

@@ -0,0 +1,6 @@
+import type { PhoneCountry, PhoneCountryOption, PhoneNumberValue } from '../components/phone-number-field/phone-number-field.type';
+export declare function phoneCountries(locale: string, codes?: readonly PhoneCountry[]): PhoneCountryOption[];
+export declare function filterPhoneCountries(countries: readonly PhoneCountryOption[], query: string): PhoneCountryOption[];
+export declare function readPhoneNumber(value: PhoneNumberValue): import("libphonenumber-js/min").PhoneNumber | null;
+/** An international paste may select its country, but cannot escape the allowed list. */
+export declare function editPhoneNumber(text: string, current: PhoneNumberValue, allowed?: readonly PhoneCountry[]): PhoneNumberValue;

package/dist/utils/phone-number.d.ts

@@ -0,0 +1,6 @@
+import type { PhoneCountry, PhoneCountryOption, PhoneNumberValue } from '../components/phone-number-field/phone-number-field.type';
+export declare function phoneCountries(locale: string, codes?: readonly PhoneCountry[]): PhoneCountryOption[];
+export declare function filterPhoneCountries(countries: readonly PhoneCountryOption[], query: string): PhoneCountryOption[];
+export declare function readPhoneNumber(value: PhoneNumberValue): import("libphonenumber-js/min").PhoneNumber | null;
+/** An international paste may select its country, but cannot escape the allowed list. */
+export declare function editPhoneNumber(text: string, current: PhoneNumberValue, allowed?: readonly PhoneCountry[]): PhoneNumberValue;

package/dist/utils/placement.d.cts

@@ -0,0 +1,73 @@
+/**
+ * Where a floating panel lands against the thing that opened it, as four numbers.
+ *
+ * Pure on purpose, and shared: positioning an overlay is the one part of a `Select`, a
+ * `Popover` or a `Menu` that is arithmetic rather than rendering, and arithmetic that runs
+ * once per open is arithmetic worth a test rather than a screenshot.
+ *
+ * Everything here is in the coordinate space of whatever the panel is laid out in — the
+ * caller subtracts the portal host's own origin before calling, because the trigger
+ * reports itself against the window and the panel is not laid out in the window.
+ */
+/** `start` and `end` rather than `left` and `right` (R13): the sides mirror in RTL. */
+export type Placement = 'top' | 'bottom' | 'start' | 'end';
+/** Where the panel lines up along the edge it is pinned to. */
+export type Align = 'start' | 'center' | 'end';
+/** The trigger's rectangle. */
+export type Anchor = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * `trigger` matches the anchor exactly. `content-fit` hugs what the panel measured at,
+ * which the component bounds with a measure of its own. `full` is the screen less its
+ * insets — the way to say "yes, actually, all of it", which nothing else in the union can
+ * express: a number is a guess at the screen's width, and `content-fit` refuses on purpose.
+ */
+export type AnchoredWidth = number | 'trigger' | 'content-fit' | 'full';
+/** Screen edges the panel refuses to cross, in points. */
+export type Insets = {
+    top?: number;
+    bottom?: number;
+    start?: number;
+    end?: number;
+};
+export type Size2D = {
+    width: number;
+    height: number;
+};
+export type PlacementInput = {
+    anchor: Anchor;
+    /** What the panel measured at, before it was constrained. */
+    content: Size2D;
+    window: Size2D;
+    /**
+     * A floor under the resolved width. A `trigger`-width panel narrower than this takes this
+     * instead — the case for a control whose panel has a natural minimum (a month grid) but
+     * whose field can be wider. Still clamped to the screen last.
+     */
+    minWidth?: number;
+    placement: Placement;
+    align: Align;
+    width: AnchoredWidth;
+    offset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    insets: Required<Insets>;
+};
+export type PlacementResult = {
+    top: number;
+    start: number;
+    width: number;
+    maxHeight: number;
+    /** Where it actually went — the side asked for, or its opposite if that did not fit. */
+    placement: Placement;
+};
+/**
+ * The order matters. Width is resolved first because the horizontal clamp depends on it;
+ * the side is chosen next because the room to work with is the room on the chosen side;
+ * the two coordinates follow from both.
+ */
+export declare function resolvePlacement(input: PlacementInput): PlacementResult;

package/dist/utils/placement.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Where a floating panel lands against the thing that opened it, as four numbers.
+ *
+ * Pure on purpose, and shared: positioning an overlay is the one part of a `Select`, a
+ * `Popover` or a `Menu` that is arithmetic rather than rendering, and arithmetic that runs
+ * once per open is arithmetic worth a test rather than a screenshot.
+ *
+ * Everything here is in the coordinate space of whatever the panel is laid out in — the
+ * caller subtracts the portal host's own origin before calling, because the trigger
+ * reports itself against the window and the panel is not laid out in the window.
+ */
+/** `start` and `end` rather than `left` and `right` (R13): the sides mirror in RTL. */
+export type Placement = 'top' | 'bottom' | 'start' | 'end';
+/** Where the panel lines up along the edge it is pinned to. */
+export type Align = 'start' | 'center' | 'end';
+/** The trigger's rectangle. */
+export type Anchor = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * `trigger` matches the anchor exactly. `content-fit` hugs what the panel measured at,
+ * which the component bounds with a measure of its own. `full` is the screen less its
+ * insets — the way to say "yes, actually, all of it", which nothing else in the union can
+ * express: a number is a guess at the screen's width, and `content-fit` refuses on purpose.
+ */
+export type AnchoredWidth = number | 'trigger' | 'content-fit' | 'full';
+/** Screen edges the panel refuses to cross, in points. */
+export type Insets = {
+    top?: number;
+    bottom?: number;
+    start?: number;
+    end?: number;
+};
+export type Size2D = {
+    width: number;
+    height: number;
+};
+export type PlacementInput = {
+    anchor: Anchor;
+    /** What the panel measured at, before it was constrained. */
+    content: Size2D;
+    window: Size2D;
+    /**
+     * A floor under the resolved width. A `trigger`-width panel narrower than this takes this
+     * instead — the case for a control whose panel has a natural minimum (a month grid) but
+     * whose field can be wider. Still clamped to the screen last.
+     */
+    minWidth?: number;
+    placement: Placement;
+    align: Align;
+    width: AnchoredWidth;
+    offset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    insets: Required<Insets>;
+};
+export type PlacementResult = {
+    top: number;
+    start: number;
+    width: number;
+    maxHeight: number;
+    /** Where it actually went — the side asked for, or its opposite if that did not fit. */
+    placement: Placement;
+};
+/**
+ * The order matters. Width is resolved first because the horizontal clamp depends on it;
+ * the side is chosen next because the room to work with is the room on the chosen side;
+ * the two coordinates follow from both.
+ */
+export declare function resolvePlacement(input: PlacementInput): PlacementResult;

package/dist/utils/progress.d.cts

@@ -0,0 +1,25 @@
+/**
+ * Where `value` sits between `min` and `max`, as a number from 0 to 1.
+ *
+ * Every argument is external input, so every argument is validated rather than trusted: a
+ * `value` outside the range is clamped, a range that is empty or inverted reads as empty,
+ * and anything that is not a finite number reads as zero. A progress bar drawn from `NaN`
+ * is a fill of `NaN%` — which React Native accepts, and which draws nothing at all with no
+ * error anywhere.
+ */
+export declare function progressFraction(value: number, min: number, max: number): number;
+/**
+ * The progress as the text beside the bar — `'40 %'` in French, `'40%'` in English.
+ *
+ * **Which number gets formatted follows the style.** A percentage is a share of the range,
+ * so it formats the fraction; anything else — a currency, a unit, a plain count — is about
+ * the quantity itself, so it formats the value. Formatting the fraction as euros would
+ * report a 1 250 € goal as `0,63 €`, which is the bug this branch exists to prevent rather
+ * than a convention worth explaining to a caller.
+ *
+ * `Intl` is what makes the locale difference, and it is also the thing most likely to be
+ * missing: a Hermes build compiled without ICU has no `Intl.NumberFormat` at all. The
+ * fallback is the same number with a plain percent sign rather than an exception, because a
+ * locale that cannot be resolved is not a reason for a progress bar to stop rendering.
+ */
+export declare function formatProgress(fraction: number, value: number, options?: Intl.NumberFormatOptions): string;

package/dist/utils/progress.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where `value` sits between `min` and `max`, as a number from 0 to 1.
+ *
+ * Every argument is external input, so every argument is validated rather than trusted: a
+ * `value` outside the range is clamped, a range that is empty or inverted reads as empty,
+ * and anything that is not a finite number reads as zero. A progress bar drawn from `NaN`
+ * is a fill of `NaN%` — which React Native accepts, and which draws nothing at all with no
+ * error anywhere.
+ */
+export declare function progressFraction(value: number, min: number, max: number): number;
+/**
+ * The progress as the text beside the bar — `'40 %'` in French, `'40%'` in English.
+ *
+ * **Which number gets formatted follows the style.** A percentage is a share of the range,
+ * so it formats the fraction; anything else — a currency, a unit, a plain count — is about
+ * the quantity itself, so it formats the value. Formatting the fraction as euros would
+ * report a 1 250 € goal as `0,63 €`, which is the bug this branch exists to prevent rather
+ * than a convention worth explaining to a caller.
+ *
+ * `Intl` is what makes the locale difference, and it is also the thing most likely to be
+ * missing: a Hermes build compiled without ICU has no `Intl.NumberFormat` at all. The
+ * fallback is the same number with a plain percent sign rather than an exception, because a
+ * locale that cannot be resolved is not a reason for a progress bar to stop rendering.
+ */
+export declare function formatProgress(fraction: number, value: number, options?: Intl.NumberFormatOptions): string;

package/dist/utils/selection.d.cts

@@ -0,0 +1,50 @@
+/** How many rows may be chosen at once. */
+export type SelectionMode = 'none' | 'single' | 'multiple';
+/** Which column a table is sorted on, and which way. */
+export type SortDescriptor = {
+    column: string;
+    direction: 'ascending' | 'descending';
+};
+/**
+ * The keys after pressing one row.
+ *
+ * `single` replaces rather than adds, and **pressing the chosen row again clears it** — a
+ * single-selection list with no way back to none is a list a reader can only get wrong once.
+ * `multiple` toggles. `none` is unreachable from a press and returns what it was given, so a
+ * caller need not branch before calling.
+ *
+ * A new array every time it changes and the **same array when it does not**, which is what
+ * lets a memoized row skip a render on a press that did not touch it.
+ */
+export declare function toggleKey(keys: readonly string[], key: string, mode: SelectionMode): readonly string[];
+/**
+ * Whether every row that *can* be chosen already is.
+ *
+ * Disabled rows are not counted, which is the only reading that makes the header's box
+ * usable: a table with one disabled row would otherwise show a box that can never be filled.
+ *
+ * A table with nothing selectable in it is **not** "all selected" — an empty tick is a lie
+ * about a table with no rows.
+ */
+export declare function isEveryKeySelected(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): boolean;
+/** Whether some but not all are — the third state a header's box has to show. */
+export declare function isSomeKeySelected(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): boolean;
+/**
+ * The keys after pressing the header's box.
+ *
+ * All or nothing, and **nothing wins when anything is already chosen** — a half-filled box
+ * that fills the rest on a press is the behaviour every reader expects from it, and clearing
+ * from full is the way back.
+ *
+ * Keys already chosen that are *not* in the table are kept: a table showing one page of a
+ * filtered list must not clear a choice made on another page.
+ */
+export declare function toggleEveryKey(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): readonly string[];
+/**
+ * The sort after pressing a column's header.
+ *
+ * A new column starts ascending, the same column turns round, and **a descending column
+ * pressed a third time clears the sort** — every table that cannot get back to its own order
+ * makes a reader reload the screen to do it.
+ */
+export declare function nextSort(current: SortDescriptor | undefined, column: string): SortDescriptor | undefined;

package/dist/utils/selection.d.ts

@@ -0,0 +1,50 @@
+/** How many rows may be chosen at once. */
+export type SelectionMode = 'none' | 'single' | 'multiple';
+/** Which column a table is sorted on, and which way. */
+export type SortDescriptor = {
+    column: string;
+    direction: 'ascending' | 'descending';
+};
+/**
+ * The keys after pressing one row.
+ *
+ * `single` replaces rather than adds, and **pressing the chosen row again clears it** — a
+ * single-selection list with no way back to none is a list a reader can only get wrong once.
+ * `multiple` toggles. `none` is unreachable from a press and returns what it was given, so a
+ * caller need not branch before calling.
+ *
+ * A new array every time it changes and the **same array when it does not**, which is what
+ * lets a memoized row skip a render on a press that did not touch it.
+ */
+export declare function toggleKey(keys: readonly string[], key: string, mode: SelectionMode): readonly string[];
+/**
+ * Whether every row that *can* be chosen already is.
+ *
+ * Disabled rows are not counted, which is the only reading that makes the header's box
+ * usable: a table with one disabled row would otherwise show a box that can never be filled.
+ *
+ * A table with nothing selectable in it is **not** "all selected" — an empty tick is a lie
+ * about a table with no rows.
+ */
+export declare function isEveryKeySelected(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): boolean;
+/** Whether some but not all are — the third state a header's box has to show. */
+export declare function isSomeKeySelected(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): boolean;
+/**
+ * The keys after pressing the header's box.
+ *
+ * All or nothing, and **nothing wins when anything is already chosen** — a half-filled box
+ * that fills the rest on a press is the behaviour every reader expects from it, and clearing
+ * from full is the way back.
+ *
+ * Keys already chosen that are *not* in the table are kept: a table showing one page of a
+ * filtered list must not clear a choice made on another page.
+ */
+export declare function toggleEveryKey(keys: readonly string[], rowKeys: readonly string[], disabledKeys?: readonly string[]): readonly string[];
+/**
+ * The sort after pressing a column's header.
+ *
+ * A new column starts ascending, the same column turns round, and **a descending column
+ * pressed a third time clears the sort** — every table that cannot get back to its own order
+ * makes a reader reload the screen to do it.
+ */
+export declare function nextSort(current: SortDescriptor | undefined, column: string): SortDescriptor | undefined;

package/dist/utils/stable-hash.d.cts

@@ -0,0 +1,5 @@
+/**
+ * FNV-1a over the canonical form. Not cryptographic — it only has to be stable and cheap,
+ * because it becomes the first component of the style cache key.
+ */
+export declare function stableHash(value: unknown): string;

package/dist/utils/stable-hash.d.ts

@@ -0,0 +1,5 @@
+/**
+ * FNV-1a over the canonical form. Not cryptographic — it only has to be stable and cheap,
+ * because it becomes the first component of the style cache key.
+ */
+export declare function stableHash(value: unknown): string;

package/dist/utils/style-props.d.cts

@@ -0,0 +1,32 @@
+/**
+ * The runtime half of R14. The type half lives in `system/style-props/`, and the two are
+ * pinned to each other by a compile-time check there: a React Native upgrade that adds or
+ * removes a style key fails `type-check` with the key's name rather than drifting.
+ *
+ * One set for the three style types rather than one per node. A caller cannot write
+ * `fontSize` on a view slot — that slot's props are typed `ViewStyleProps` — so the split
+ * never has to know which node it runs for, and every component shares one table.
+ */
+declare const STYLE_PROP_KEYS: readonly ["alignContent", "alignItems", "alignSelf", "aspectRatio", "boxSizing", "columnGap", "direction", "display", "flex", "flexBasis", "flexDirection", "flexGrow", "flexShrink", "flexWrap", "gap", "justifyContent", "overflow", "rowGap", "bottom", "end", "inset", "insetBlock", "insetBlockEnd", "insetBlockStart", "insetInline", "insetInlineEnd", "insetInlineStart", "position", "start", "top", "zIndex", "margin", "marginBlock", "marginBlockEnd", "marginBlockStart", "marginBottom", "marginEnd", "marginHorizontal", "marginInline", "marginInlineEnd", "marginInlineStart", "marginStart", "marginTop", "marginVertical", "padding", "paddingBlock", "paddingBlockEnd", "paddingBlockStart", "paddingBottom", "paddingEnd", "paddingHorizontal", "paddingInline", "paddingInlineEnd", "paddingInlineStart", "paddingStart", "paddingTop", "paddingVertical", "height", "maxHeight", "maxWidth", "minHeight", "minWidth", "width", "borderBlockColor", "borderBlockEndColor", "borderBlockStartColor", "borderBottomColor", "borderBottomEndRadius", "borderBottomStartRadius", "borderBottomWidth", "borderColor", "borderCurve", "borderEndColor", "borderEndEndRadius", "borderEndStartRadius", "borderEndWidth", "borderRadius", "borderStartColor", "borderStartEndRadius", "borderStartStartRadius", "borderStartWidth", "borderStyle", "borderTopColor", "borderTopEndRadius", "borderTopStartRadius", "borderTopWidth", "borderWidth", "backfaceVisibility", "backgroundColor", "boxShadow", "cursor", "elevation", "experimental_backgroundImage", "filter", "isolation", "mixBlendMode", "opacity", "outlineColor", "outlineOffset", "outlineStyle", "outlineWidth", "shadowColor", "shadowOffset", "shadowOpacity", "shadowRadius", "rotation", "scaleX", "scaleY", "transform", "transformMatrix", "transformOrigin", "translateX", "translateY", "color", "fontFamily", "fontSize", "fontStyle", "fontVariant", "fontWeight", "includeFontPadding", "letterSpacing", "lineHeight", "textAlign", "textAlignVertical", "textDecorationColor", "textDecorationLine", "textDecorationStyle", "textShadowColor", "textShadowOffset", "textShadowRadius", "textTransform", "userSelect", "verticalAlign", "writingDirection", "objectFit", "overlayColor", "resizeMode", "tintColor"];
+export type StylePropKey = (typeof STYLE_PROP_KEYS)[number];
+/** What `splitStyleProps` takes out of a props object. */
+export type StylePropsOf<P> = Pick<P, Extract<keyof P, StylePropKey>>;
+/** What it leaves in it. */
+export type RestPropsOf<P> = Omit<P, StylePropKey>;
+/**
+ * Separates the style keys from everything else, transforming neither:
+ *
+ * ```ts
+ * splitStyleProps({ padding: 16, onPress })   // → [{ padding: 16 }, { onPress }]
+ * ```
+ *
+ * A component destructures its own vocabulary — `variant`, `size`, `color` — before
+ * calling this, which is what keeps the two apart with no list of exceptions: `color` on
+ * a root is R7's tint and never reaches here, while on a text slot it is `TextStyle`'s
+ * and does.
+ *
+ * A key written as `undefined` still counts as written and lands in the style half.
+ * Dropping it would be a transformation, and `undefined` in a style is already a no-op.
+ */
+export declare function splitStyleProps<P extends object>(props: P): [StylePropsOf<P>, RestPropsOf<P>];
+export {};