@fusion.dev/helix-core 0.142.1 → 0.144.0

package/dist/utils/chord/chord.js

@@ -0,0 +1,53 @@
+export const chordParts = (keys) => keys
+    .split('+')
+    .map((part) => part.trim())
+    .filter((part) => part !== '');
+const ARIA = {
+    alt: 'Alt',
+    backspace: 'Backspace',
+    cmd: 'Meta',
+    ctrl: 'Control',
+    del: 'Delete',
+    down: 'ArrowDown',
+    enter: 'Enter',
+    esc: 'Escape',
+    escape: 'Escape',
+    left: 'ArrowLeft',
+    meta: 'Meta',
+    opt: 'Alt',
+    right: 'ArrowRight',
+    shift: 'Shift',
+    space: 'Space',
+    tab: 'Tab',
+    up: 'ArrowUp',
+};
+export const ariaChord = (keys, apple) => chordParts(keys)
+    .map((part) => {
+    const name = part.toLowerCase();
+    if (name === 'mod') {
+        return apple ? 'Meta' : 'Control';
+    }
+    return ARIA[name] ?? (part.length === 1 ? part.toUpperCase() : part);
+})
+    .join('+');
+export const printableChord = (keys) => {
+    const parts = chordParts(keys).map((part) => part.toLowerCase());
+    const key = parts.at(-1) ?? '';
+    return [...key].length === 1 && parts.slice(0, -1).every((modifier) => modifier === 'shift');
+};
+export const matchesChord = (press, keys, apple) => {
+    const parts = chordParts(keys).map((part) => part.toLowerCase());
+    if (parts.length === 0) {
+        return false;
+    }
+    const wanted = parts[parts.length - 1] ?? '';
+    const modifiers = new Set(parts.slice(0, -1));
+    const ctrl = modifiers.has('ctrl') || (modifiers.has('mod') && !apple);
+    const meta = modifiers.has('cmd') || modifiers.has('meta') || (modifiers.has('mod') && apple);
+    const symbol = wanted.toLowerCase() === wanted.toUpperCase() && [...wanted].length === 1;
+    return (press.key.toLowerCase() === wanted &&
+        (modifiers.has('shift') ? press.shiftKey : symbol || !press.shiftKey) &&
+        (modifiers.has('alt') || modifiers.has('opt') ? press.altKey : !press.altKey) &&
+        (ctrl ? press.ctrlKey : !press.ctrlKey) &&
+        (meta ? press.metaKey : !press.metaKey));
+};

package/dist/utils/clock/clock.d.ts

@@ -0,0 +1,87 @@
+/** The two clocks a time is written on: twelve hours, or twenty-four. */
+export type HourCycle = 'h12' | 'h23';
+/**
+ * The locale with its clock set, or the locale as given where no clock is.
+ *
+ * Through the locale's own `-u-hc-` extension, which every `Intl` formatter
+ * reads, so a time written, a meridiem named and the question of whether the
+ * locale writes twelve hours all answer to the one tag. Empty stays empty
+ * without a clock, which is the runtime's own locale.
+ */
+export declare const clockLocale: (locale: string, hourCycle?: HourCycle) => string;
+/**
+ * Whether a locale writes times on a twelve hour clock.
+ *
+ * Asked of `Intl` rather than derived from a list of locales, because it is
+ * exactly the question `resolvedOptions` answers and the list is long and
+ * changes. `en-US` is true, `en-GB`, `fr-FR` and `ja-JP` are false, measured.
+ */
+export declare const isTwelveHour: (locale?: string) => boolean;
+/**
+ * What a locale calls the half of the day before or after noon, such as `AM`,
+ * `PM`, `오전` or `오후`.
+ *
+ * Read off `Intl`'s own rendering of a time in that half, which is the one
+ * place every engine states it.
+ */
+export declare const dayPeriod: (half: 'AM' | 'PM', locale?: string) => string;
+/**
+ * Every time on offer, as seconds since midnight, from `min` to `max` by
+ * `step`.
+ *
+ * `step` is in minutes, or in seconds with `seconds`, the unit
+ * `<input type="time">` counts in. Built from `min` upward, so a list that
+ * starts at `09:00` steps from nine rather than from midnight.
+ */
+export declare const offeredTimes: (min: string, max: string, step: number, seconds?: boolean) => number[];
+/**
+ * The time on offer nearest to one, the earlier winning a tie, or the time
+ * itself where nothing is on offer.
+ */
+export declare const nearestTime: (times: readonly number[], at: number) => number;
+/**
+ * The parts a wheel shows for a time: the hour as the clock writes it, the
+ * minute, the second, and which half of the day.
+ */
+export declare const wheelParts: (at: number, twelve: boolean) => {
+    hour: number;
+    meridiem: 'AM' | 'PM';
+    minute: number;
+    second: number;
+    shown: number;
+};
+/**
+ * The hour of the day a wheel's hour means: on a twelve hour clock the wheel
+ * says 1 to 12 and the meridiem says which half, and 12 AM is midnight.
+ */
+export declare const wholeHour: (shown: number, half?: 'AM' | 'PM') => number;
+/** What a time is checked against: its bounds, the times barred by name, and the times on offer. */
+export interface TimeRules {
+    /** Times barred by name, separated by commas or spaces. */
+    disableTimes: string;
+    /** The latest time, or empty for the end of the day. */
+    max: string;
+    /** The earliest time, or empty for midnight. */
+    min: string;
+    /**
+     * The times on offer, as seconds since midnight, where a time off them is a
+     * fault. Left out, the step is not checked.
+     */
+    offered?: readonly number[] | undefined;
+}
+/** What is wrong with a time, as the validity flag a control reports, or `unavailable` for a barred one. */
+export type TimeFault = 'rangeOverflow' | 'rangeUnderflow' | 'stepMismatch' | 'unavailable';
+/**
+ * Whether a time, as seconds since midnight, is one `disable-times` names,
+ * matching `09:30` and `09:30:00` alike.
+ */
+export declare const timeBarred: (at: number, disableTimes: string) => boolean;
+/**
+ * What is wrong with a time a control can read, or `null`: before `min`, past
+ * `max`, barred by name, or off the times on offer, asked in that order.
+ *
+ * Time Picker reports the first fault of each time it holds, and Time Input
+ * the first fault any of its times has, so each asks this of every time and
+ * keeps the order its own message has always taken.
+ */
+export declare const timeFault: (value: string, rules: TimeRules) => TimeFault | null;

package/dist/utils/clock/clock.js

@@ -0,0 +1,68 @@
+import { valueAsSeconds } from '../value-as/value-as.js';
+import { writtenList } from '../written-list/written-list.js';
+const DAY = 86_400;
+export const clockLocale = (locale, hourCycle) => {
+    if (!hourCycle) {
+        return locale;
+    }
+    try {
+        const base = new Intl.DateTimeFormat(locale || undefined).resolvedOptions().locale;
+        return new Intl.Locale(base, { hourCycle }).toString();
+    }
+    catch {
+        return locale;
+    }
+};
+export const isTwelveHour = (locale) => new Intl.DateTimeFormat(locale || undefined, { timeStyle: 'short' }).resolvedOptions().hour12 ===
+    true;
+export const dayPeriod = (half, locale) => new Intl.DateTimeFormat(locale || undefined, { hour: 'numeric', hour12: true, timeZone: 'UTC' })
+    .formatToParts(new Date(Date.UTC(1970, 0, 1, half === 'AM' ? 9 : 21)))
+    .find((part) => part.type === 'dayPeriod')?.value ?? half;
+export const offeredTimes = (min, max, step, seconds = false) => {
+    const from = valueAsSeconds(min) ?? 0;
+    const to = valueAsSeconds(max) ?? (seconds ? DAY - 1 : DAY - 60);
+    const every = Math.max(1, Math.round(step)) * (seconds ? 1 : 60);
+    const found = [];
+    for (let at = from; at <= to; at += every) {
+        found.push(at);
+    }
+    return found;
+};
+export const nearestTime = (times, at) => {
+    let best = times[0] ?? at;
+    for (const one of times) {
+        if (Math.abs(one - at) < Math.abs(best - at)) {
+            best = one;
+        }
+    }
+    return best;
+};
+export const wheelParts = (at, twelve) => {
+    const hour = Math.floor(at / 3600);
+    return {
+        hour,
+        meridiem: hour < 12 ? 'AM' : 'PM',
+        minute: Math.floor(at / 60) % 60,
+        second: at % 60,
+        shown: twelve ? (hour % 12 === 0 ? 12 : hour % 12) : hour,
+    };
+};
+export const wholeHour = (shown, half) => half === undefined ? shown : (shown % 12) + (half === 'PM' ? 12 : 0);
+export const timeBarred = (at, disableTimes) => writtenList(disableTimes).some((one) => valueAsSeconds(one) === at);
+export const timeFault = (value, rules) => {
+    const read = valueAsSeconds(value);
+    const at = read ?? 0;
+    if (at < (valueAsSeconds(rules.min) ?? 0)) {
+        return 'rangeUnderflow';
+    }
+    if (at > (valueAsSeconds(rules.max) ?? DAY - 1)) {
+        return 'rangeOverflow';
+    }
+    if (read !== null && timeBarred(at, rules.disableTimes)) {
+        return 'unavailable';
+    }
+    if (rules.offered && !rules.offered.includes(at)) {
+        return 'stepMismatch';
+    }
+    return null;
+};

package/dist/utils/color-name/color-name.d.ts

@@ -0,0 +1,28 @@
+import type { Color } from '../css-color/css-color.js';
+/**
+ * The words a color's name is made of, keyed by their English, with the two
+ * sentences that put them together.
+ *
+ * **The keys are React Aria's**, the strings `@react-stately/color` ships for
+ * `Color.getColorName`, so a page that already translates those can hand the
+ * same table over. `colorName` and `transparentColorName` are the sentences,
+ * with `{lightness}`, `{chroma}`, `{hue}` and `{percentTransparent}` filled in;
+ * every other key is one word or one pair of words. A pair is its own entry,
+ * because a language may join two hues in a way that is not two words with a
+ * space between them.
+ */
+export type ColorWords = Record<'black' | 'blue' | 'blue purple' | 'brown' | 'brown yellow' | 'colorName' | 'cyan' | 'cyan blue' | 'dark' | 'gray' | 'grayish' | 'green' | 'green cyan' | 'light' | 'magenta' | 'magenta pink' | 'orange' | 'orange yellow' | 'pale' | 'pink' | 'pink red' | 'purple' | 'purple magenta' | 'red' | 'red orange' | 'transparentColorName' | 'very dark' | 'very light' | 'vibrant' | 'white' | 'yellow' | 'yellow green', string>;
+/** The English the names are spoken in where a page gives no words of its own. */
+export declare const COLOR_WORDS: ColorWords;
+/**
+ * A color's name, such as "vibrant red" or "dark grayish blue", in the words
+ * given.
+ *
+ * The same reading React Aria's `Color.getColorName` gives, from the same
+ * thresholds: a hue from where the color sits on the OKLCH wheel, a lightness
+ * from very dark to very light, and a chroma from grayish to vibrant. A color
+ * with any transparency says how much, in a percentage written for `locale`.
+ */
+export declare const colorName: (color: Color, given?: Partial<ColorWords>, locale?: string) => string;
+/** The name of a color's hue alone, such as "red orange", in the words given. */
+export declare const hueName: (color: Color, given?: Partial<ColorWords>, locale?: string) => string;

package/dist/utils/color-name/color-name.js

@@ -0,0 +1,150 @@
+export const COLOR_WORDS = {
+    black: 'black',
+    blue: 'blue',
+    'blue purple': 'blue purple',
+    brown: 'brown',
+    'brown yellow': 'brown yellow',
+    colorName: '{lightness} {chroma} {hue}',
+    cyan: 'cyan',
+    'cyan blue': 'cyan blue',
+    dark: 'dark',
+    gray: 'gray',
+    grayish: 'grayish',
+    green: 'green',
+    'green cyan': 'green cyan',
+    light: 'light',
+    magenta: 'magenta',
+    'magenta pink': 'magenta pink',
+    orange: 'orange',
+    'orange yellow': 'orange yellow',
+    pale: 'pale',
+    pink: 'pink',
+    'pink red': 'pink red',
+    purple: 'purple',
+    'purple magenta': 'purple magenta',
+    red: 'red',
+    'red orange': 'red orange',
+    transparentColorName: '{lightness} {chroma} {hue}, {percentTransparent} transparent',
+    'very dark': 'very dark',
+    'very light': 'very light',
+    vibrant: 'vibrant',
+    white: 'white',
+    yellow: 'yellow',
+    'yellow green': 'yellow green',
+};
+const HUES = [
+    [0, 'pink'],
+    [15, 'red'],
+    [48, 'orange'],
+    [94, 'yellow'],
+    [135, 'green'],
+    [175, 'cyan'],
+    [264, 'blue'],
+    [284, 'purple'],
+    [320, 'magenta'],
+    [349, 'pink'],
+];
+const BROWN_BELOW = 0.68;
+const YELLOW_GREEN_BELOW = 0.85;
+const DARK_BELOW = 0.55;
+const GRAY_BELOW = 0.001;
+const linear = (channel) => channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+const oklch = (color) => {
+    const hue = (((color.hue % 360) + 360) % 360) / 60;
+    const value = color.brightness / 100;
+    const chroma = value * (color.saturation / 100);
+    const middle = chroma * (1 - Math.abs((hue % 2) - 1));
+    const base = value - chroma;
+    const sextants = [
+        [chroma, middle, 0],
+        [middle, chroma, 0],
+        [0, chroma, middle],
+        [0, middle, chroma],
+        [middle, 0, chroma],
+        [chroma, 0, middle],
+    ];
+    const [red, green, blue] = (sextants[Math.floor(hue) % 6] ?? [0, 0, 0]).map((one) => linear(one + base));
+    const l = Math.cbrt(0.4122214708 * red + 0.5363325363 * green + 0.0514459929 * blue);
+    const m = Math.cbrt(0.2119034982 * red + 0.6806995451 * green + 0.1073969566 * blue);
+    const s = Math.cbrt(0.0883024619 * red + 0.2817188376 * green + 0.6299787005 * blue);
+    const lightness = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
+    const a = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
+    const b = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
+    const angle = (Math.atan2(b, a) * 180) / Math.PI;
+    return [lightness, Math.hypot(a, b), angle >= 0 ? angle : angle + 360];
+};
+const hueOf = (lightness, chroma, hue, words) => {
+    if (chroma < GRAY_BELOW) {
+        return [words.gray, lightness];
+    }
+    for (let at = 0; at < HUES.length; at += 1) {
+        const [from, named] = HUES[at];
+        const [to, after] = HUES[at + 1] ?? [360, 'pink'];
+        if (hue < from || hue >= to) {
+            continue;
+        }
+        let name = named;
+        let light = lightness;
+        if (name === 'orange') {
+            if (lightness < BROWN_BELOW) {
+                name = 'brown';
+            }
+            else {
+                light = lightness - BROWN_BELOW + DARK_BELOW;
+            }
+        }
+        if (hue > from + (to - from) / 2 && name !== after) {
+            name = `${name} ${after}`;
+        }
+        else if (name === 'yellow' && lightness < YELLOW_GREEN_BELOW) {
+            name = 'yellow green';
+        }
+        return [words[name] ?? COLOR_WORDS[name] ?? name, light];
+    }
+    return [words.gray, lightness];
+};
+export const colorName = (color, given = {}, locale = '') => {
+    const words = { ...COLOR_WORDS, ...given };
+    const [lightness, chroma, angle] = oklch(color);
+    if (lightness > 0.999) {
+        return words.white;
+    }
+    if (lightness < 0.001) {
+        return words.black;
+    }
+    const [hue, light] = hueOf(lightness, chroma, angle, words);
+    let tone = '';
+    if (chroma <= 0.1 && chroma >= GRAY_BELOW) {
+        tone = light >= 0.7 ? words.pale : words.grayish;
+    }
+    else if (chroma >= 0.15) {
+        tone = words.vibrant;
+    }
+    let shade = '';
+    if (light < 0.3) {
+        shade = words['very dark'];
+    }
+    else if (light < DARK_BELOW) {
+        shade = words.dark;
+    }
+    else if (light >= 0.85) {
+        shade = words['very light'];
+    }
+    else if (light >= 0.7) {
+        shade = words.light;
+    }
+    const alpha = Math.min(100, Math.max(0, color.alpha)) / 100;
+    const sentence = alpha < 1 ? words.transparentColorName : words.colorName;
+    const percent = new Intl.NumberFormat(locale || undefined, { style: 'percent' }).format(1 - alpha);
+    return sentence
+        .replaceAll('{lightness}', () => shade)
+        .replaceAll('{chroma}', () => tone)
+        .replaceAll('{hue}', () => hue.toLocaleLowerCase(locale || undefined))
+        .replaceAll('{percentTransparent}', () => percent)
+        .replace(/\s+/g, ' ')
+        .trim();
+};
+export const hueName = (color, given = {}, locale = '') => {
+    const [lightness, chroma, angle] = oklch(color);
+    return hueOf(lightness, chroma, angle, { ...COLOR_WORDS, ...given })[0].toLocaleLowerCase(locale || undefined);
+};

package/dist/utils/count-label/count-label.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A count said in one of two sentences, the one for a single thing or the one
+ * for any other number, with `{count}` filled in for `locale`.
+ *
+ * **`Intl.PluralRules` picks the sentence**, because the line between "one"
+ * and "other" is the language's: French says "0 résultat" where English says
+ * "0 results". A language with more forms than two writes its `one` in the
+ * first sentence and the rest in the second.
+ *
+ * Data Table says how many rows a search left this way, and Listbox how many
+ * options a filter left, which Combobox and Command hand down to it.
+ */
+export declare const countLabel: (count: number, one: string, other: string, locale?: string) => string;

package/dist/utils/count-label/count-label.js

@@ -0,0 +1,5 @@
+import { fillTemplate } from '../fill-template/fill-template.js';
+import { formatNumbers } from '../format-numbers/format-numbers.js';
+export const countLabel = (count, one, other, locale = '') => fillTemplate(new Intl.PluralRules(locale || undefined).select(count) === 'one' ? one : other, {
+    count: formatNumbers(locale)(count),
+});

package/dist/utils/css-color/css-color.d.ts

@@ -41,6 +41,18 @@ export interface Color {
 }
 /** The syntaxes a value can be written in. */
 export type ColorFormat = 'hex' | 'hsl' | 'rgb';
+/** HSB to bytes, which is the road every written syntax goes down. */
+export declare const toRgb: (color: Color) => {
+    blue: number;
+    green: number;
+    red: number;
+};
+/** HSB to HSL, which is a different pair of numbers for the same color. */
+export declare const toHsl: (color: Color) => {
+    hue: number;
+    lightness: number;
+    saturation: number;
+};
 /**
  * Any of the syntaxes to the working model, or `null` where it is not a color.
  *

package/dist/utils/css-color/css-color.js

@@ -40,7 +40,7 @@ const rgbToHsb = (red, green, blue, alpha) => {
         saturation: Math.round(high === 0 ? 0 : (span / high) * 100),
     };
 };
-const toRgb = (color) => {
+export const toRgb = (color) => {
     const hue = (((color.hue % 360) + 360) % 360) / 60;
     const saturation = color.saturation / 100;
     const brightness = color.brightness / 100;
@@ -62,7 +62,7 @@ const toRgb = (color) => {
         red: Math.round((red + base) * 255),
     };
 };
-const toHsl = (color) => {
+export const toHsl = (color) => {
     const saturation = color.saturation / 100;
     const brightness = color.brightness / 100;
     const lightness = (brightness * (2 - saturation)) / 2;

package/dist/utils/date-segments/date-segments.d.ts

@@ -0,0 +1,122 @@
+/** One part of a date or a time a reader sets on its own. */
+export type SegmentKind = 'day' | 'dayPeriod' | 'hour' | 'minute' | 'month' | 'second' | 'year';
+/** What a segmented field holds: a date, or a time of day. */
+export type SegmentedKind = 'date' | 'time';
+/**
+ * The parts set so far, each a number: the month 1 to 12, the hour 0 to 23
+ * whatever clock it is shown on, and the half of the day 0 for before noon and
+ * 1 for after. A part not yet set is absent.
+ */
+export type Segments = Partial<Record<SegmentKind, number>>;
+/** One place in the field: a segment, or the text a locale writes between two. */
+export type SegmentSlot = {
+    kind: SegmentKind;
+} | {
+    literal: string;
+};
+/** How the field is laid out and which clock its hour is on. */
+export interface SegmentOptions {
+    /** `h12` or `h23`, or absent for the locale's own. */
+    hourCycle?: 'h12' | 'h23' | undefined;
+    /** Whether a time carries its seconds. */
+    seconds?: boolean | undefined;
+}
+/**
+ * The segments in the order the locale writes them, with what it writes
+ * between them, read off `Intl`'s own rendering of a sample.
+ *
+ * `en-US` is month, day, year with slashes; `de-DE` day, month, year with
+ * dots; `ja-JP` year, month, day. A time follows the clock: a twelve hour
+ * locale ends with the half of the day.
+ */
+export declare const segmentLayout: (kind: SegmentedKind, locale: string, options?: SegmentOptions) => SegmentSlot[];
+/** Whether a layout writes the hour on a twelve hour clock. */
+export declare const isTwelveHourLayout: (layout: readonly SegmentSlot[]) => boolean;
+/**
+ * The lowest and highest a segment can be, as it is shown: the hour on a twelve
+ * hour clock is 1 to 12, and a day goes as high as its month allows.
+ */
+export declare const segmentRange: (kind: SegmentKind, segments: Segments, twelve: boolean) => {
+    max: number;
+    min: number;
+};
+/** A segment's number as it is shown: the hour on the clock the field is on. */
+export declare const shownValue: (kind: SegmentKind, segments: Segments, twelve: boolean) => number | undefined;
+/**
+ * Sets a segment from the number shown for it, which on a twelve hour clock
+ * is put back together with the half of the day, and keeps the day inside its
+ * month.
+ */
+export declare const setSegment: (segments: Segments, kind: SegmentKind, shown: number | undefined, twelve: boolean) => Segments;
+/**
+ * A segment moved by a key's step, wrapping at its ends as a dial does, and
+ * starting from where a reader would look for it when it is empty: the lowest
+ * going up, the highest going down, and this year for a year.
+ */
+export declare const stepSegment: (segments: Segments, kind: SegmentKind, by: number, twelve: boolean, thisYear?: number) => Segments;
+/**
+ * A digit typed into a segment, given what was typed into it already.
+ *
+ * The digits run on while the number they make still fits and could take
+ * another, so `1` then `2` in a month is December; a digit that would overflow
+ * starts the number over. `advance` says the segment is full, so focus moves
+ * on, which is React Aria's typing: `3` in a month is March and moves to the
+ * day, `1` waits for a second digit.
+ */
+export declare const typeDigit: (segments: Segments, kind: SegmentKind, typed: string, digit: string, twelve: boolean) => {
+    advance: boolean;
+    segments: Segments;
+    typed: string;
+};
+/** Where a segment stands when a key arrives: its kind, the field's parts, and what was typed into it. */
+export interface SegmentKeyState {
+    /** The segment the key was pressed on. */
+    kind: SegmentKind;
+    /** The locale the meridiem is written in, whose words a letter picks. */
+    locale: string;
+    /** The field's parts. */
+    segments: Segments;
+    /** Whether the field is on a twelve hour clock. */
+    twelve: boolean;
+    /** The digits typed into the segment so far. */
+    typed: string;
+}
+/**
+ * What an editing key does to a segment, or `null` for a key that edits
+ * nothing.
+ *
+ * The arrows step it and wrap, Home and End take it to its lowest and highest,
+ * Backspace and Delete empty it, a digit is typed as `typeDigit` types it, and
+ * on the meridiem a letter picks the half whose word starts with it. `advance`
+ * says the segment is full and focus moves on.
+ */
+export declare const segmentKey: (key: string, { kind, locale, segments, twelve, typed }: SegmentKeyState) => {
+    advance: boolean;
+    segments: Segments;
+    typed: string;
+} | null;
+/** The segments a value names, or none where it names nothing whole. */
+export declare const segmentsOf: (kind: SegmentedKind, value: string) => Segments;
+/**
+ * The value the segments add up to, or the empty string while any segment the
+ * layout shows is unset.
+ *
+ * A date that does not exist, the thirtieth of February, cannot be reached,
+ * the day being kept inside its month as it is set.
+ */
+export declare const segmentsValue: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[]) => string;
+/** Whether a reader has set some segments and not all of them. */
+export declare const isPartial: (kind: SegmentedKind, segments: Segments, layout: readonly SegmentSlot[]) => boolean;
+/**
+ * What a segment shows: its number, padded the way the locale pads it, the
+ * locale's own word for the half of the day, or dashes while it is unset.
+ */
+export declare const segmentText: (kind: SegmentKind, segments: Segments, twelve: boolean, locale: string) => string;
+/**
+ * What a screen reader hears for a segment's value: what it shows, and for a
+ * month its name as well, "8 – August", which is React Aria's reading. A
+ * month heard as a number alone leaves a reader counting.
+ */
+export declare const segmentValueText: (kind: SegmentKind, segments: Segments, twelve: boolean, locale: string) => string;
+/** What a locale calls a segment, such as "month" or "AM/PM", from `Intl`. */
+export declare const segmentName: (kind: SegmentKind, locale: string) => string;