react-luna-form 0.0.87 → 0.0.89

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,143 @@ 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 isUnreadableLength<T>(length: unknown, read: Readonly<{
+    max?: T;
+    min?: T;
+}>): boolean;
+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 BoundRules = Readonly<{
+    beyond: 'above' | 'after';
+    disordered: string;
+    kind: string;
+    lost: string;
+    needsBoth: boolean;
+}>;
+export declare function describeBounds<T extends number | string>(name: string, length: unknown, limits: Readonly<{
+    max?: T;
+    min?: T;
+}>, rules: BoundRules): string[];
+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/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/list.d.ts

@@ -4,7 +4,9 @@ import type { AnyField, Field, Fields, List, Nullable } from '../type';
  *
  * The defaults are here rather than at each reading, because they are read at
  * mount, on every add and remove, and on assignment -- four chances for one of
- * them to say a list shows one row by default and another to say none.
+ * them to say a list shows one row by default and another to say none. A bound
+ * that is no number keeps its default: the schema, which reads the bounds the
+ * same way, holds such a list back.
  */
 export declare function getListBounds(list: List): {
     min: number;

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): T[];
-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

@@ -3,14 +3,15 @@ import type { CustomValidation, Definition, Field, Input, Schemas, Sections, Zod
 export declare function buildSchema(schemas: Schemas, fields?: Field[], translations?: Record<string, string>): ZodSchema;
 export declare function flatten(error: z.ZodError<Record<string, unknown>>): Record<string, string[]>;
 export declare function getSchema(input: Input, translations?: Record<string, string>): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-export declare function getEmail(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodPipe<z.ZodString, z.ZodEmail>, unknown> | z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodPipe<z.ZodString, z.ZodEmail>, z.ZodLiteral<"">]>>>;
-export declare function getText(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodCoercedString<unknown>, unknown> | z.ZodOptional<z.ZodNullable<z.ZodCoercedString<unknown>>>;
+export declare function getEmail(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodString>, unknown> | z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodUnion<[z.ZodLiteral<"">, z.ZodString]>>>> | z.ZodPreprocess<z.ZodPipe<z.ZodString, z.ZodEmail>, unknown> | z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodPipe<z.ZodString, z.ZodEmail>, z.ZodLiteral<"">]>>>;
+export declare function getText(input: Input, translations?: Record<string, string>): z.ZodPreprocess<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodString>, unknown> | z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodUnion<[z.ZodLiteral<"">, z.ZodString]>>>>;
 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,12 +1,12 @@
+import { type Localization } from '../../../../../luna-core/index';
 import type { Fields, PreviewItem } from '../../../../../luna-core/index';
 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;
 }>;
 export declare function FieldPreview(props: PreviewProps): import("react").JSX.Element;

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

@@ -1,9 +1,9 @@
-import { type Description as DescriptionType } from '../../../../luna-core/index';
+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.
  *
@@ -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-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,13 +9,13 @@ 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;

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

@@ -1,5 +1,5 @@
 import { type DescriptionTextProps } from './description';
-import { type Column } from '../../../luna-core/index';
+import { type Column, type Localization } from '../../../luna-core/index';
 import type { Config } from '../type';
 export declare function Column(props: Readonly<{
     children?: React.ReactNode;
@@ -7,5 +7,5 @@ export declare function Column(props: Readonly<{
     config?: Config;
     context?: Record<string, unknown>;
     description?: React.ComponentType<DescriptionTextProps>;
-    translations?: Record<string, string>;
+    localization?: Localization;
 }>): import("react").JSX.Element;

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

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

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

@@ -1,13 +1,12 @@
-import { type List, type Nullable } from '../../../../luna-core/index';
+import { type List, type Nullable, type Localization } from '../../../../luna-core/index';
 export type ListProps = Readonly<{
     children: (index: number) => React.ReactNode;
     field: List;
-    lang?: string;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
-    translations?: Record<string, string>;
+    localization?: Localization;
     value?: Nullable<Record<string, unknown>>;
 }>;
 export declare function FieldList(props: ListProps): import("react").JSX.Element[];

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

@@ -1,12 +1,12 @@
-import { type Field, type Style } from '../../../../luna-core/index';
+import { type Field, type Style, type Localization } from '../../../../luna-core/index';
 import type { Children } from '../../type';
 export type FieldProps = Readonly<{
     children: Children;
     disabled?: boolean;
     errors?: string[];
     field: Field;
-    lang?: string;
+    now?: string;
     style?: Style;
-    translations?: Record<string, string>;
+    localization?: Localization;
 }>;
 export declare function Field(props: FieldProps): import("react").JSX.Element;

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

@@ -1,9 +1,9 @@
 import type { Config } from '../type';
-import type { Field } from '../../../luna-core/index';
+import type { Field, Localization } from '../../../luna-core/index';
 export type DescriptionProps = Readonly<{
     config?: Config;
     context?: Record<string, unknown>;
     field: Field;
-    translations?: Record<string, string>;
+    localization?: Localization;
 }>;
 export declare function StaticDescription(props: DescriptionProps): import("react").JSX.Element;

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

@@ -15,6 +15,7 @@ export declare function Form(props: Readonly<{
     action?: (formData: FormData) => void;
     children: Slot;
     config: Config;
+    context?: Record<string, unknown>;
     control?: Control;
     definition?: Definition;
     fieldSet?: React.ComponentType<React.ComponentProps<typeof StaticFieldSet>>;

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

@@ -1,4 +1,4 @@
-import { type Field } from '../../../../luna-core/index';
+import { type Field, type Localization } from '../../../../luna-core/index';
 import type { Children } from '../../type';
 export declare function InputBase(props: Readonly<{
     children: Children;
@@ -6,7 +6,7 @@ export declare function InputBase(props: Readonly<{
     errors?: string[];
     field: Field;
     horizontal?: boolean;
-    lang?: string;
+    localization?: Localization;
+    now?: string;
     readOnly?: boolean;
-    translations?: Record<string, string>;
 }>): import("react").ReactNode;

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

@@ -1,6 +1,6 @@
 import { type DescriptionProps } from './field-description';
 import type { Config } from '../type';
-import type { Field } from '../../../luna-core/index';
+import type { Field, Localization } from '../../../luna-core/index';
 export declare function InputGroup(props: Readonly<{
     children: React.ReactNode;
     config?: Config;
@@ -8,5 +8,5 @@ export declare function InputGroup(props: Readonly<{
     description?: React.ComponentType<DescriptionProps>;
     field: Field;
     horizontal?: boolean;
-    translations?: Record<string, string>;
+    localization?: Localization;
 }>): import("react").JSX.Element;

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

@@ -1,5 +1,5 @@
 import { type DescriptionProps } from './field-description';
-import { type Field } from '../../../luna-core/index';
+import { type Field, type Localization } from '../../../luna-core/index';
 import type { Config } from '../type';
 export declare function InputLabel(props: Readonly<{
     config?: Config;
@@ -7,5 +7,5 @@ export declare function InputLabel(props: Readonly<{
     description?: React.ComponentType<DescriptionProps>;
     field: Field;
     horizontal?: boolean;
-    translations?: Record<string, string>;
+    localization?: Localization;
 }>): import("react").JSX.Element;

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

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

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

@@ -1,4 +1,4 @@
-import { type Fields, type Nullable, type Style } from '../../../../luna-core/index';
+import { type Fields, type Nullable, type Style, type Localization } from '../../../../luna-core/index';
 import type { DescriptionTextProps } from '../description';
 import type { Children, Config } from '../../type';
 import type { FieldProps } from '../field/field';
@@ -15,12 +15,11 @@ export declare function SlotBase(props: Readonly<{
     context?: Record<string, unknown>;
     disabled?: boolean;
     fields?: Fields;
-    lang?: string;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
     style?: Style;
-    translations?: Record<string, string>;
+    localization?: Localization;
     value?: Nullable<Record<string, unknown>>;
 }>): import("react").JSX.Element[];

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

@@ -1,5 +1,5 @@
 import type { Children, Config } from '../../type';
-import type { Fields, Nullable, Style } from '../../../../luna-core/index';
+import type { Fields, Localization, Nullable, Style } from '../../../../luna-core/index';
 import type { SlotComponents } from './slot-base';
 export declare function createSlot(components: SlotComponents): (props: Readonly<{
     children: Children;
@@ -7,12 +7,11 @@ export declare function createSlot(components: SlotComponents): (props: Readonly
     context?: Record<string, unknown>;
     disabled?: boolean;
     fields?: Fields;
-    lang?: string;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
     style?: Style;
-    translations?: Record<string, string>;
+    localization?: Localization;
     value?: Nullable<Record<string, unknown>>;
 }>) => import("react").JSX.Element;

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

@@ -1,4 +1,4 @@
-import { type List, type Nullable, type Style } from '../../../../luna-core/index';
+import { type List, type Nullable, type Style, type Localization } from '../../../../luna-core/index';
 import { type SlotComponents } from './slot-base';
 import type { Children, Config } from '../../type';
 export declare function SlotList(props: Readonly<{
@@ -9,12 +9,11 @@ export declare function SlotList(props: Readonly<{
     disabled?: boolean;
     field: List;
     index: number;
-    lang?: string;
     onValueChange?: (input: {
         name: string;
         value: unknown;
     }) => void;
     style?: Style;
-    translations?: Record<string, string>;
+    localization?: Localization;
     value?: Nullable<Record<string, unknown>>;
 }>): import("react").JSX.Element;