react-luna-form 0.0.86 → 0.0.88

package/dist/types/luna-core/util/date.d.ts

@@ -1,4 +1,15 @@
-import type { Date as DateField, DateFormat, Time, TimeFormat, TimezoneGroup } from '../type';
+import { DATA_FORMAT, DATA_MODE, DATA_RESERVED, MAX, MIN } from './constant';
+import type { Locale } from 'date-fns';
+import type { Date as DateField, DateFormat, Input, Select, Time, TimeFormat, TimezoneGroup } from '../type';
+/**
+ * The language a form writes its months, days, numbers, dates and dictionary
+ * in: its `lang`, as a canonical tag, and English without one, for one that is
+ * no tag, or for one the runtime knows no language for. It is the one reading
+ * of the language, so everything the form writes agrees on it.
+ */
+export declare function toLocale(locale?: string): string;
+/** The base language of a form's language: `es` for `es-CO`. */
+export declare function baseLanguage(locale?: string): string;
 export declare function getMonth(locale?: string): {
     value: string;
     label: string;
@@ -11,13 +22,128 @@ export declare function getYear(min: number, max: number): Array<{
     value: string;
     label: string;
 }>;
-export declare function getCurrentYear(): number;
-export declare function getUserTimezone(): string;
-export declare function getTimezones(): TimezoneGroup[];
-export declare function getConvert(value: string | number, current?: number): number;
+export type YearLimits = Readonly<{
+    max?: number;
+    min?: number;
+}>;
+/**
+ * The first and the last year a year select offers, both included: whole
+ * numbers, the way an `input/number` takes its bounds, or a `$ref` the host
+ * resolved to one. The library keeps no clock, so "this year" is the host's to
+ * say, through `context`, and a field without both bounds offers no year.
+ *
+ * Read once for the options the component is handed and for the schema that
+ * checks a year, so the two cannot disagree. It takes an `Input` as well,
+ * which is what the schema sees every field as.
+ */
+export declare function buildYearLimits(field: Input | Select): YearLimits;
+/**
+ * The zone a timezone select suggests, as its definition gives it in
+ * `advanced.suggested`: the host knows it -- a profile, a cookie, a header --
+ * and passes it through `context`, so the server and the browser suggest the
+ * same one. It is read as the name the runtime gives it, and a value that is no
+ * zone suggests nothing, which a development build names.
+ */
+export declare function buildSuggestedZone(field: Select): string | undefined;
+/**
+ * An instant as the host gives it in `context.now`: an ISO date, time and
+ * offset, such as `2026-10-05T19:30:00-05:00` or `2026-10-06T00:30:00Z`.
+ * Without its offset a time would be read in this machine's zone, which is the
+ * clock the form keeps no more, so anything else is no instant.
+ */
+export declare function readInstant(text?: string): Date | undefined;
+/**
+ * Every zone this engine knows, grouped by region, with the one the host
+ * suggests first. Labelled for the instant the host gives, `context.now`: the
+ * offset a zone has, and the name it goes by, both depend on it, so without one
+ * a zone goes by its city. Nothing here reads this machine's clock or zone.
+ *
+ * Built once while the zone and the instant hold: a timezone select builds its
+ * options on every render, and there are hundreds of zones. Frozen, since every
+ * form that asks shares it, on a server every request. `suggested` is a zone's
+ * name as the runtime gives it, as `buildSuggestedZone` reads it. Sorted in
+ * English, the language of the labels, so no machine's collation orders it.
+ */
+export declare function getTimezones(suggested?: string, now?: string): readonly TimezoneGroup[];
 export declare function toNativeDate(value: string, fromFormat: DateFormat): string;
 export declare function toNativeTime(value: string, fromFormat: TimeFormat): string;
 export declare function fromNativeTime(native: string, toFormat?: TimeFormat): string;
-export declare function fromNativeDate(native: string, toFormat?: DateFormat): string;
+export declare function displayDate(value: string, format: DateFormat, lang?: string): string;
+/**
+ * The date-fns locale for a language, by its base: `es-CO` writes Spanish
+ * names. English for a language the library does not ship.
+ */
+export declare function dateFnsLocale(lang?: string): Locale | undefined;
 export declare function getTimeFormat(field: Time): TimeFormat;
 export declare function getDateFormat(field: DateField): DateFormat;
+export type DateLimits = Readonly<{
+    max?: string;
+    min?: string;
+    reserved: readonly string[];
+    unreadable: boolean;
+}>;
+type DateBound = 'max' | 'min';
+export type DateIssue = Readonly<{
+    issue: DateBound;
+    limit: string;
+}> | Readonly<{
+    issue: 'range';
+}> | Readonly<{
+    issue: 'reserved';
+}> | Readonly<{
+    issue: 'unreadable';
+}>;
+/**
+ * The days a date field allows: the first and the last, both included, and
+ * the ones nobody may pick. Read once for the props its component is handed and
+ * for the schema that checks it, so the two cannot disagree.
+ *
+ * It is the one place the limits are read, on the server and in the browser, so
+ * it is where one that limits nothing is named for whoever wrote the form.
+ */
+export declare function buildDateLimits(field: DateField): DateLimits;
+export declare function checkDay(day: string, limits: DateLimits): DateIssue | null;
+/**
+ * A range as the form holds it, `[from, to]`, with `''` for an end nobody
+ * picked: the pair a calendar emits or the two hidden inputs a form submits,
+ * and one text alone as the first end. Anything else -- numbers, an object, a
+ * list of more than two -- is no range, and comes back `undefined`, so it is
+ * held back for what it is instead of being taken for a range nobody picked.
+ */
+export declare function toRange(value: unknown): [string, string] | undefined;
+export declare function checkRange(from: string, to: string, limits: DateLimits): DateIssue | null;
+export type DateProps = Readonly<{
+    format: DateFormat;
+    lang: string;
+    max?: string;
+    min?: string;
+    mode: 'range' | 'single';
+    reserved: readonly string[];
+}>;
+/**
+ * What a date component reads back from the props the form gave it: the format
+ * to show a day in, whether it picks one day or a range, the first and the last
+ * day it may offer, and the days it may not, all as `yyyy-MM-dd`.
+ *
+ * The form writes a date field's rules as attributes, so a native input and a
+ * calendar from any library can both carry them; this is the other half, and
+ * it lives here so an adapter never decodes an attribute the form chose how
+ * to encode.
+ */
+export declare function readDateProps(props: Readonly<{
+    [DATA_FORMAT]?: string;
+    [DATA_MODE]?: string;
+    [DATA_RESERVED]?: string;
+    [MAX]?: string;
+    [MIN]?: string;
+    lang?: string;
+}>): DateProps;
+/**
+ * What a reader worked out for a key, kept while it is among the last `limit`
+ * keys read, the one read longest ago dropped first: what a component reads on
+ * every render is worked out once while its input holds, whatever other forms
+ * read between, and a server that sees a new input on every request holds no
+ * more than that.
+ */
+export declare function remember<T>(cache: Map<string, T>, key: string, compute: () => T, limit: number): T;
+export {};

package/dist/types/luna-core/util/extract.d.ts

@@ -1,5 +1,26 @@
 import type { Nullable, Option, Value } from '../type';
 export declare function hasOwn(value: object, key: string): boolean;
+export type Entry = {
+    found: boolean;
+    value: unknown;
+};
+/**
+ * The one walk of a dotted path, for every reader of one.
+ *
+ * A flat key that is literally the path wins, because that is how the form
+ * keeps a list's leaves -- `items.0.name` is a key, not a route -- and a
+ * definition is free to name a field the same way. Then objects by key and
+ * arrays by numeric index.
+ *
+ * There were two of these, one per package, and they disagreed about that first
+ * step: a list named `config.items` was found by the reader in luna-react and
+ * not by the one here, so whether a form hydrated depended on which one the
+ * caller happened to use. `extract` and `resolveValue` are both this now.
+ *
+ * Every step asks `hasOwn`, so an inherited member is not a value and a name
+ * that reaches a prototype resolves to nothing. See SEG-2.
+ */
+export declare function resolveEntry(name: string, currentValue: Record<string, unknown> | unknown[]): Entry;
 export declare function getEntity<T>(selected: Value, collection?: Nullable<T[]>, entity?: string): NonNullable<T> | {
     value: import("..").Multiple;
 } | {

package/dist/types/luna-core/util/format.d.ts

@@ -1,6 +1,17 @@
 export type FormatContext = {
     locale?: string;
+    now?: string;
 };
 export type FormatFilter = (value: unknown, args: string[], ctx: FormatContext) => string;
+/**
+ * `context.now`, the one key of the host's `context` the library reads on its
+ * own: the instant a relative date is measured from and a time zone's offset is
+ * given for. The library keeps no clock, so without it there is no "now".
+ *
+ * Only an ISO date, time and offset is an instant. A `Date`, a timestamp or a
+ * time without its offset is none, and a development build names it once for
+ * the context that carries it, since nothing on the form says so otherwise.
+ */
+export declare function readNow(context?: Record<string, unknown>): string | undefined;
 export declare const formatFilters: Record<string, FormatFilter>;
 export declare function applyFormatFilter(value: unknown, expression: string, ctx: FormatContext): string | undefined;

package/dist/types/luna-core/util/is-input.d.ts

@@ -1,4 +1,4 @@
-import type { Chips, Column, Field, Input, List, Nullable, Select, Time } from '../type';
+import type { Chips, Column, Date as DateField, Field, Input, List, Nullable, Select, Time } from '../type';
 export declare const isSelectActive: (field: Field) => boolean;
 export declare const isSelectDay: (field: Field) => boolean;
 export declare const isSelectMonth: (field: Field) => boolean;
@@ -6,8 +6,9 @@ export declare const isSelectYear: (field: Field) => boolean;
 export declare const isSelectTimezone: (field: Field) => boolean;
 export declare const isChipsDays: (field: Field) => boolean;
 export declare const isChipsMonths: (field: Field) => boolean;
-export declare const isDate: (field: Field) => field is Field;
+export declare const isDate: (field: Field) => field is DateField;
 export declare const isTime: (field: Field) => field is Time;
+export declare function isDateRange(field: Field): boolean;
 export declare const isCheckbox: (field: Field) => field is Input;
 export declare const isChips: (field: Field) => field is Chips;
 export declare const isRadio: (field: Field) => field is Select;

package/dist/types/luna-core/util/pattern.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What an authored pattern can do to the thread that runs it.
+ *
+ * A pattern that can split the same text between its repetitions in more than
+ * one way backtracks exponentially on a value that almost matches: `^(a+)+$`
+ * holds the thread for seconds on thirty characters, a tab's or a server's.
+ * Only the ambiguity is dangerous. `^[a-z]+(-[a-z]+)*$` repeats a group with a
+ * quantifier inside it as well, and runs in linear time, because every
+ * repetition opens with a `-` that the one before cannot close with.
+ *
+ * So the question asked of each repeated group is not whether it nests a
+ * quantifier but whether its repetitions can overlap: whether the group can
+ * open with a character it can also close with, and then either holds an
+ * unbounded quantifier or offers alternatives that open alike. That is
+ * `(a+)+`, `(\w+\s?)+` and `(a|a)+`, and not `(-[a-z]+)*`, `(,\d+)*` or
+ * `(ab+c)+`.
+ *
+ * It is a reading of the source, not a proof. Characters are reasoned about as
+ * ASCII, with everything beyond it counted as one more symbol, and what the
+ * reader cannot tell apart it reads as any character: it would rather refuse
+ * a safe pattern than run a catastrophic one. Quadratic patterns are not its
+ * concern; they need very long values to hurt.
+ *
+ * Every term works out what it can open and close with as it is read, once,
+ * so reading a pattern costs time in proportion to its length, however it
+ * nests.
+ */
+export declare function backtracksCatastrophically(source: string, flags?: string): boolean;

package/dist/types/luna-core/util/prepare.d.ts

@@ -1,4 +1,5 @@
 import type { Definition, Filterable, Nullable } from '../type';
-export declare function prepare<T extends Filterable>(base?: readonly T[], definition?: Definition): any[];
-export declare function resolveRefs(base: unknown, definition?: Definition, cache?: Map<object, unknown>, visited?: WeakSet<object>): unknown;
+export declare function prepare<T extends Filterable>(base?: readonly T[], definition?: Definition, context?: Record<string, unknown>): T[];
+export declare function resolveRefs(base: unknown, definition?: Definition, context?: Record<string, unknown>): unknown;
+export declare function refOf(value: unknown): string | undefined;
 export declare function entries<T>(values?: Nullable<Record<string, T>>): [key: string, value: T][];

package/dist/types/luna-core/util/schema.d.ts

@@ -8,9 +8,10 @@ export declare function getText(input: Input, translations?: Record<string, stri
 export declare function getNumber(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>>, unknown> | z.ZodPreprocess<z.ZodPipe<z.ZodUnknown, z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>, unknown>;
 export declare function getYearSchema(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>>, unknown> | z.ZodPreprocess<z.ZodPipe<z.ZodUnknown, z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>, unknown>;
 export declare function getMonthSchema(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>>, unknown> | z.ZodPreprocess<z.ZodPipe<z.ZodUnknown, z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>>, unknown>;
+export declare function getDateSchema(field: Field, translations?: Record<string, string>): z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodType<[string, string], unknown, z.core.$ZodTypeInternals<[string, string], unknown>>>>, unknown> | z.ZodPreprocess<z.ZodPipe<z.ZodUnknown, z.ZodType<[string, string], unknown, z.core.$ZodTypeInternals<[string, string], unknown>>>, unknown> | z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>>, unknown> | z.ZodPreprocess<z.ZodPipe<z.ZodUnknown, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>, unknown>;
 export declare function applyCustomValidation(schema: ZodSchema, fields?: Field[], translations?: Record<string, string>): ZodSchema;
 export declare function validateCustom(value: unknown, rules: CustomValidation | Array<CustomValidation>, getValue: (name: string) => unknown, translations?: Record<string, string>): string[];
-export declare function buildFormSchema(sections: Sections, translations?: Record<string, string>, definition?: Definition): z.ZodType;
+export declare function buildFormSchema(sections: Sections, translations?: Record<string, string>, definition?: Definition, context?: Record<string, unknown>): z.ZodType;
 export declare function collectIssues(error: z.ZodError): Array<{
     path: string;
     message: string;

package/dist/types/luna-core/util/string.d.ts

@@ -1,6 +1,13 @@
 export type InterpolateOptions = {
     locale?: string;
+    now?: string;
 };
+/**
+ * What text the form renders is formatted with: the form's language, its
+ * `lang`, and the instant the host gave in `context`. A label and a
+ * description format the same value the same way because they ask here.
+ */
+export declare function renderOptions(lang?: string, context?: Record<string, unknown>): InterpolateOptions;
 /**
  * Replaces placeholders in the format {key} with values from the provided object.
  * Supports nested objects using dot notation (e.g., {user.id}) and pipe filters

package/dist/types/luna-react/src/client/component/field/field-list-preview-item.d.ts

@@ -1,6 +1,7 @@
+import { type Localization } from '../../../../../luna-core/index';
 import type { List, Nullable, PreviewItem } from '../../../../../luna-core/index';
 import type { ReactNode } from 'react';
-export declare function FieldListPreviewItem({ canRemove, children, field, index, isMultiField, itemKey, label, lang, onRemove, previewBadge, previewLabel, previewTags, translations, value, }: {
+export declare function FieldListPreviewItem({ canRemove, children, field, index, isMultiField, itemKey, label, localization, onRemove, previewBadge, previewLabel, previewTags, value, }: {
     canRemove: boolean;
     children: ReactNode;
     field: List;
@@ -8,11 +9,10 @@ export declare function FieldListPreviewItem({ canRemove, children, field, index
     isMultiField: boolean;
     itemKey: string | number;
     label: string;
-    lang?: string;
+    localization?: Localization;
     onRemove: (index: number) => void;
     previewBadge?: PreviewItem;
     previewLabel?: PreviewItem;
     previewTags?: PreviewItem[];
-    translations?: Record<string, string>;
     value?: Nullable<Record<string, unknown> | unknown[]>;
 }): import("react").JSX.Element;

package/dist/types/luna-react/src/client/component/field/field-preview-item.d.ts

@@ -1,7 +1,9 @@
-import { type Option } from '../../../../../luna-core/index';
-export declare function FieldPreviewItem({ className, initialValue, name, options, separator, staticLabel, }: Readonly<{
+import { type DateFormat, type Option } from '../../../../../luna-core/index';
+export declare function FieldPreviewItem({ className, dateFormat, initialValue, lang, name, options, separator, staticLabel, }: Readonly<{
     className?: string;
+    dateFormat?: DateFormat;
     initialValue?: unknown;
+    lang?: string;
     name?: string;
     options?: Array<Option | string>;
     separator?: boolean;

package/dist/types/luna-react/src/client/component/field/field-preview-value.d.ts

@@ -1,5 +1,8 @@
-export declare function FieldPreviewValue({ children, initialValue, name, }: Readonly<{
+import { type DateFormat } from '../../../../../luna-core/index';
+export declare function FieldPreviewValue({ children, dateFormat, initialValue, lang, name, }: Readonly<{
     children: (value: string) => React.ReactNode;
+    dateFormat?: DateFormat;
     initialValue?: unknown;
+    lang?: string;
     name: string;
 }>): import("react").JSX.Element;

package/dist/types/luna-react/src/client/component/field/field-preview.d.ts

@@ -1,11 +1,13 @@
+import { type Localization } from '../../../../../luna-core/index';
 import type { Fields, PreviewItem } from '../../../../../luna-core/index';
-export declare function FieldPreview({ className, fields, label, lang, name, previews, translations, value, }: Readonly<{
+type PreviewProps = Readonly<{
     className?: string;
     fields?: Fields;
     label?: string;
-    lang?: string;
+    localization?: Localization;
     name: string;
     previews: PreviewItem | PreviewItem[];
-    translations?: Record<string, string>;
     value?: Record<string, unknown> | unknown[] | null;
-}>): import("react").JSX.Element | null;
+}>;
+export declare function FieldPreview(props: PreviewProps): import("react").JSX.Element;
+export {};

package/dist/types/luna-react/src/{component → client/component}/field/field-set-advanced.d.ts

@@ -1,4 +1,4 @@
-import type { Section } from '../../../../luna-core/index';
+import type { Section } from '../../../../../luna-core/index';
 export declare function FieldSetAdvanced(props: Readonly<{
     description?: string;
     group: React.ReactNode;

package/dist/types/luna-react/src/client/component/field/field-set.d.ts

@@ -0,0 +1,11 @@
+import { type Section, type Style } from '../../../../../luna-core/index';
+export declare function FieldSet(props: Readonly<{
+    advanced?: {
+        step?: boolean;
+    };
+    children?: React.ReactNode;
+    section: Section;
+    step?: number;
+    style?: Style;
+    translations?: Record<string, string>;
+}>): import("react").JSX.Element;

package/dist/types/luna-react/src/client/component/field/field.d.ts

@@ -1,3 +1,19 @@
+import type { FieldProps } from '../../../component/field/field';
+/**
+ * Everything a field reads from the store, in one component, with the memo
+ * around it rather than inside.
+ *
+ * Two wrappers used to sit outside that memo, one per atom, and both of them
+ * ran on every render of the form: a hundred fields cost two hundred renders a
+ * keystroke on a controlled host, for the memo underneath to then find every
+ * prop unchanged. Outside, the same comparison stops the field whole, the two
+ * reads included.
+ *
+ * Stopping there does not cut a field off from the store. What it reads are
+ * subscriptions, so its own state and its own errors render it whatever its
+ * props do -- which is the only way either of them changes.
+ */
+declare function FieldWithMeta(props: FieldProps): import("react").JSX.Element | null;
 /**
  * A field renders when something it can see has changed, and not because a
  * field elsewhere in the form did.
@@ -14,15 +30,8 @@
  * prop, so `children` is a stable callback rather than a closure rebuilt
  * whenever that value moved; a field reads its own entry from the store, and
  * the one thing that has to be read while rendering comes through a context
- * whose identity never changes. `errors` is the one prop that moves, and it
- * moves for the field it belongs to.
+ * whose identity never changes. What used to move, `errors`, is read from the
+ * store now, on the inside of this comparison.
  */
-export declare const Field: (props: Readonly<Readonly<Readonly<{
-    children: import("../../../type").Children;
-    disabled?: boolean;
-    errors?: Record<string, string[]>;
-    field: import('../../../../../luna-core/index').Field;
-    lang?: string;
-    style?: import('../../../../../luna-core/index').Style;
-    translations?: Record<string, string>;
-}>>>) => import("react").JSX.Element | null;
+export declare const Field: import("react").MemoExoticComponent<typeof FieldWithMeta>;
+export {};

package/dist/types/luna-react/src/client/component/field-description.d.ts

@@ -0,0 +1,2 @@
+import type { DescriptionProps } from '../../component/field-description';
+export declare function FieldDescription(props: DescriptionProps): import("react").JSX.Element;

package/dist/types/luna-react/src/{component → client/component}/formatted-description.d.ts

@@ -1,9 +1,9 @@
-import { type Description as DescriptionType } from '../../../luna-core/index';
-import type { Config } from '../type';
+import { type Description as DescriptionType, type Localization } from '../../../../luna-core/index';
+import type { Config } from '../../type';
 export declare function FormattedDescription(props: Readonly<{
     config?: Config;
     context?: Record<string, unknown>;
+    localization?: Localization;
     text?: DescriptionType;
-    translations?: Record<string, string>;
     value?: unknown;
 }>): import("react").JSX.Element | null;

package/dist/types/luna-react/src/client/component/guard/list-guard.d.ts

@@ -1,2 +1,2 @@
 import type { ListProps } from '../../../component/field/field-list';
-export declare function ListGuard({ children, field, lang, onValueChange, translations, value, }: ListProps): import("react").JSX.Element;
+export declare function ListGuard({ children, field, onValueChange, localization, value, }: ListProps): import("react").JSX.Element;

package/dist/types/luna-react/src/client/component/input-strategies.d.ts

@@ -1,5 +1,14 @@
 import type { Config } from '../../type';
 import type { DataSource, Field, Nullable, Value } from '../../../../luna-core/index';
+/**
+ * What a held value is when the change events run at mount, which has to be
+ * what a change hands them later: a form reopened on saved data reveals what it
+ * revealed when it was filled in. An array travels as one -- a `chips` field's
+ * selections, the two days of a range -- since `String()` on it joins them into
+ * "a,b", which answers to no option, no `when` and no day. Anything else is the
+ * text it would have been typed as.
+ */
+export declare function toChangeValue(value: unknown): Value;
 /**
  * What the input pipeline reads off a change, and all it reads: the new value.
  *
@@ -30,7 +39,7 @@ export type InputStrategies = Readonly<{
         valueRef: React.RefObject<unknown>;
     }>) => boolean;
     dispatchChange: (ctx: Readonly<{
-        applyChangeEventsRef: React.RefObject<((s: unknown) => void) | null>;
+        applyChangeEventsRef: React.RefObject<(s: unknown) => void>;
         data: Nullable<unknown[]>;
         entity?: string;
         inputValue: Value;
@@ -38,5 +47,4 @@ export type InputStrategies = Readonly<{
     }>) => void;
     buildInitialSelected: (defaultValue: unknown, data: Nullable<unknown[]>, entity: string | undefined) => unknown;
     isInitialReady: (field: Field, defaultValue: unknown, data: Nullable<unknown[]>) => boolean;
-    useExtraProps?: (field: Field) => Record<string, unknown> | undefined;
 }>;

package/dist/types/luna-react/src/client/component/slot/slot.d.ts

@@ -4,12 +4,11 @@ export declare const Slot: (props: Readonly<{
     context?: Record<string, unknown>;
     disabled?: boolean;
     fields?: import('../../../../../luna-core/index').Fields;
-    lang?: string;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
     style?: import('../../../../../luna-core/index').Style;
-    translations?: Record<string, string>;
+    localization?: import('../../../../../luna-core/index').Localization;
     value?: import('../../../../../luna-core/index').Nullable<Record<string, unknown>>;
 }>) => import("react").JSX.Element;

package/dist/types/luna-react/src/client/hook/use-entry-atom.d.ts

@@ -0,0 +1,18 @@
+import type { PrimitiveAtom } from 'jotai';
+/**
+ * One entry of a record the whole form shares, as an atom of the component that
+ * reads it.
+ *
+ * A family did this before: one atom per name, kept in a module-level cache for
+ * the life of the page. That cache never let go on its own, so it had to be
+ * emptied by hand -- release atoms, a call in `useStore`, and a comment on the
+ * loop to avoid -- and two of the three families grew anyway, a key per row ever
+ * added and a key per name ever shown. Made here, the atom goes when the
+ * component does, and there is nothing left to release.
+ */
+export declare function useEntryAtom<T>(base: PrimitiveAtom<Record<string, T>>, name: string): import("jotai").WritableAtom<NonNullable<T> | undefined, [next: T | undefined], void>;
+/** The same for a record of contributions. See `createContributionAtom`. */
+export declare function useContributionAtom<T>(base: PrimitiveAtom<Record<string, Record<string, T>>>, name: string, options: Readonly<{
+    merge: (values: T[]) => T | undefined;
+    validateTarget: (target: string) => boolean;
+}>): import("jotai").WritableAtom<T | undefined, [target: string, value: T | undefined], void>;

package/dist/types/luna-react/src/client/hook/use-input-core.d.ts

@@ -1,4 +1,4 @@
-import { type AriaAttributes, type CommonProps, type DataAttributes, type DataSource, type Field, type Schema, type Value } from '../../../../luna-core/index';
+import { type AriaAttributes, type CommonProps, type DataAttributes, type DataSource, type Field, type Schema, type Value, type Localization } from '../../../../luna-core/index';
 import type { Config, InputChange } from '../../type';
 export type InputCoreProps = Readonly<{
     ariaAttributes?: AriaAttributes;
@@ -9,20 +9,20 @@ export type InputCoreProps = Readonly<{
     field: Field;
     getField: (name: string) => Field | undefined;
     horizontal?: boolean;
+    localization?: Localization;
     onRegister: (name: string, schema: Schema, field: Field) => void;
     onUnmount: (name: string, options?: {
         keepValue?: boolean;
     }) => void;
     onValueChange?: (input: InputChange) => void;
     readOnly?: boolean;
-    translations?: Record<string, string>;
 }>;
 export declare function useInputCore(props: InputCoreProps, deps: Readonly<{
     setSource: (target: string, source?: DataSource) => void;
     setValue: (value: unknown) => void;
     value: unknown;
 }>): {
-    readonly applyChangeEventsRef: import("react").RefObject<((selected: unknown) => void) | null>;
+    readonly applyChangeEventsRef: import("react").RefObject<(selected: unknown) => void>;
     readonly commonProps: {
         placeholder: string;
         disabled?: boolean;
@@ -33,7 +33,7 @@ export declare function useInputCore(props: InputCoreProps, deps: Readonly<{
     readonly entity: string | undefined;
     readonly hasClickable: boolean;
     readonly onBlur: (event: React.FocusEvent<HTMLInputElement>) => void;
-    readonly onValueChangeRef: import("react").RefObject<((value: Value) => void) | null>;
+    readonly onValueChangeRef: import("react").RefObject<(value: Value) => void>;
     readonly setTimeoutRef: (callback: () => void, delay: number) => void;
     readonly validated: (value: Value) => void;
     readonly valueRef: import("react").RefObject<unknown>;

package/dist/types/luna-react/src/client/hook/use-latest.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The latest value a commit left, for the code that runs after it: an event
+ * handler, an effect, a callback whose identity has to stay steady across
+ * renders.
+ *
+ * Written from a layout effect and not from the render body, which is the whole
+ * point. A render is not a promise that anything reached the screen -- React
+ * throws one away when a transition is interrupted or a boundary retries -- and
+ * a ref assigned while rendering keeps whatever that discarded render held,
+ * which is props nobody ever saw. A commit is the moment a value becomes real,
+ * so that is when this writes it. It is also what the React Compiler asks of a
+ * component before it will optimize it.
+ *
+ * Layout and not `useEffect`: every effect of a commit runs after every layout
+ * effect of that same commit, so an effect reading this ref reads the value of
+ * the render it belongs to, whatever order the hooks were declared in.
+ *
+ * Reading it while rendering is still wrong, and still reported by
+ * `react-hooks/refs`: there the value is one commit old. What a render needs is
+ * the value itself.
+ */
+export declare function useLatest<T>(value: T): import("react").RefObject<T>;

package/dist/types/luna-react/src/client/hook/use-live-item-value.d.ts

@@ -1,6 +1,20 @@
 /**
- * Returns the live value of a list item or field path, merging the current
- * Jotai form state on top of the initial value tree. Used by previews to
- * evaluate `when` conditions reactively against user edits.
+ * What a row holds right now: the form's own state over the initial value tree,
+ * for a `when` that has to follow what the user types.
+ *
+ * Subscribed to the row's keys and not to the record. Every field in the form
+ * writes into that one record, so a row that read it woke up on every keystroke
+ * anywhere and walked every key in the form to find its own. The selection is
+ * compared shallowly, so a keystroke outside the row recomputes the pick, finds
+ * the same keys, and renders nothing.
+ *
+ * Only a condition needs this, and only a condition asks for it: the components
+ * that own one render the child that calls this hook, so a row with no
+ * condition to answer never subscribes at all.
+ *
+ * The atom is made with the component that reads it and goes with it: jotai
+ * caches a selection under the selector function, `pickRow` makes a new one per
+ * row, and both are held weakly, so nothing is kept by name for the life of the
+ * page.
  */
 export declare function useLiveItemValue(name: string, initialValue?: Record<string, unknown> | unknown[] | null): unknown;

package/dist/types/luna-react/src/client/hook/use-value.d.ts

@@ -1,6 +1,6 @@
 import { type Field } from '../../../../luna-core/index';
 export declare function useValue(field: Field): {
-    readonly setValue: (newValue: unknown) => void;
+    readonly setValue: (next: unknown) => void;
     readonly shouldSkipOnChange: () => boolean;
     readonly value: {} | undefined;
 };

package/dist/types/luna-react/src/client/lib/error-store.d.ts

@@ -1,10 +1,9 @@
-export declare const clearInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
-    init: null;
+export declare const inputErrorAtom: import("jotai").PrimitiveAtom<Record<string, string[]>> & {
+    init: Record<string, string[]>;
 };
-export declare const releaseInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
+export declare const clearInputErrorAtom: import("jotai").WritableAtom<null, [names: string[]], void> & {
     init: null;
 };
 export declare const reportErrorAtom: import("jotai").WritableAtom<null, [newValue: Record<string, string[]>], void> & {
     init: null;
 };
-export declare const reportInputErrorAtom: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<string[] | undefined, [newValue: string[] | undefined], void>>;