@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/src/components/form/form-types.d.ts

@@ -0,0 +1,307 @@
+import { MonoEventProps } from '../../composables/element-props.js';
+import { InputEvents, InputProps } from '../input/input-types.js';
+import { SelectEvents, SelectProps } from '../select/select-types.js';
+import { TextareaEvents, TextareaProps } from '../textarea/textarea-types.js';
+import { RichTextEditorEvents, RichTextEditorProps } from '../rich-text-editor/rich-text-editor-types.js';
+import { DateEvents, DateProps } from '../date/date-types.js';
+import { TagInputEvents, TagInputProps } from '../tag-input/tag-input-types.js';
+import { FileUploadEvents, FileUploadProps } from '../file-upload/file-upload-types.js';
+import { DropdownTableEvents, DropdownTableProps } from '../dropdown-table/dropdown-table-types.js';
+import { CheckboxEvents, CheckboxProps } from '../checkbox/checkbox-types.js';
+import { RadioEvents, RadioProps } from '../radio/radio-types.js';
+import { SwitchEvents, SwitchProps } from '../switch/switch-types.js';
+/**
+ * Tag name → its props, so `inputs[key].props` and `setProp()` autocomplete against the
+ * component actually being driven. Keyed by the LIGHT tag; the shadow twins
+ * (`mono-shadow-*`) share the same prop surface and are accepted at runtime.
+ *
+ * Each entry also takes the component's events as `on<Event>` keys —
+ * `onChange`, `onInput`, `onFocus`, … — which the form attaches to the element
+ * as listeners rather than writing them as props.
+ */
+export interface MonoFormComponentProps {
+    'mono-input': Partial<InputProps> & MonoEventProps<InputEvents>;
+    'mono-select': Partial<SelectProps> & MonoEventProps<SelectEvents>;
+    'mono-textarea': Partial<TextareaProps> & MonoEventProps<TextareaEvents>;
+    'mono-rich-text-editor': Partial<RichTextEditorProps> & MonoEventProps<RichTextEditorEvents>;
+    'mono-date': Partial<DateProps> & MonoEventProps<DateEvents>;
+    'mono-tag-input': Partial<TagInputProps> & MonoEventProps<TagInputEvents>;
+    'mono-file-upload': Partial<FileUploadProps> & MonoEventProps<FileUploadEvents>;
+    'mono-dropdown-table': Partial<DropdownTableProps> & MonoEventProps<DropdownTableEvents>;
+    'mono-checkbox': Partial<CheckboxProps> & MonoEventProps<CheckboxEvents>;
+    'mono-radio': Partial<RadioProps> & MonoEventProps<RadioEvents>;
+    'mono-switch': Partial<SwitchProps> & MonoEventProps<SwitchEvents>;
+}
+/** Every component `monoForm` can drive. */
+export type MonoFormComponent = keyof MonoFormComponentProps;
+/** Props for one component, plus any escape-hatch key the element also accepts. */
+export type MonoFormProps<C extends MonoFormComponent = MonoFormComponent> = MonoFormComponentProps[C] & Record<string, unknown>;
+/**
+ * When a rule runs.
+ * - `live` — on `input`, i.e. every keystroke.
+ * - `change` — on `change`, i.e. commit / blur / select.
+ *
+ * `form.validate()` runs every rule regardless of timing.
+ */
+export type MonoFormTiming = 'live' | 'change';
+/** Context handed to a `type: 'custom'` rule. */
+export interface MonoFormRuleCtx<V = unknown> {
+    value: V;
+    values: Record<string, unknown>;
+    key: string;
+}
+/**
+ * Anything schema-shaped — yup and friends. Duck-typed on purpose: @mono-lit/helper
+ * takes no validation dependency, so any object exposing `validateSync` (or an
+ * async `validate`) works, and the thrown error's `message` becomes the message.
+ */
+export interface MonoFormSchemaLike {
+    validateSync?: (value: unknown, options?: unknown) => unknown;
+    validate?: (value: unknown, options?: unknown) => unknown;
+}
+interface MonoFormRuleBase {
+    /** Overrides the form-level `validation.type` for this rule only. */
+    timing?: MonoFormTiming;
+    message?: string;
+    /**
+     * A schema for this rule. When present it WINS over `type`/`validate`, and its
+     * own error message wins over `message`.
+     */
+    schema?: MonoFormSchemaLike;
+}
+export type MonoFormRule<V = unknown> = (MonoFormRuleBase & {
+    type: 'required';
+}) | (MonoFormRuleBase & {
+    type: 'min';
+    value: number;
+}) | (MonoFormRuleBase & {
+    type: 'max';
+    value: number;
+}) | (MonoFormRuleBase & {
+    type: 'pattern';
+    value: RegExp | string;
+}) | (MonoFormRuleBase & {
+    type: 'email';
+}) | (MonoFormRuleBase & {
+    type: 'custom';
+    /** Return `true` to pass, or a string / `false` to fail. */
+    validate: (ctx: MonoFormRuleCtx<V>) => boolean | string;
+})
+/** Schema-only rule — no `type` needed. */
+ | (MonoFormRuleBase & {
+    type?: undefined;
+    schema: MonoFormSchemaLike;
+});
+/** The validation record exposed per field. */
+export interface MonoFormValidation {
+    /** `true` when the field passes. */
+    success: boolean;
+    /** The failure message, or `''` when it passes. */
+    message: string;
+}
+/**
+ * One row of a list control's RESOLVED options, as reported onto {@link MonoFormItem.list}.
+ *
+ * A flat sequence — group headers interleaved with their leaves, in display order — so it is
+ * rendered with ONE loop that branches on `type`. It is the shape `mono-tag-input`'s own
+ * `_groupRows()` already produces internally.
+ *
+ * ⚠ The discriminant is `type` here, while `controlMonoTable`'s `displayRows` spells the same idea
+ * `kind`. The two are deliberately not unified — do not "tidy" either to match the other.
+ */
+export interface MonoFormListEntry<T = Record<string, unknown>> {
+    /** `'row'` for a selectable option, `'group'` for the header above a run of them. */
+    type: 'row' | 'group';
+    /**
+     * A row's key is `item[keyValue]` — the same value `key-value` already resolves for selection, so
+     * there is only ever one notion of a key here. A group's key is its own group path.
+     */
+    key: string;
+    /** The source row. Present on `'row'` entries only. */
+    item?: T;
+    /** The group's resolved caption. Present on `'group'` entries only. */
+    label?: string;
+    /** Nesting depth. On a ROW this is the depth of the group it sits IN, so indent by it directly. */
+    level: number;
+    /** A group's leaves — enough for a count without walking the rest of the list. */
+    items?: T[];
+    /** Whether this row is currently picked. `'row'` only. */
+    selected?: boolean;
+    /** Whether the keyboard cursor is on this row. `'row'` only. */
+    active?: boolean;
+}
+/** One field's live state, as read through `form.items()`. */
+export interface MonoFormItem<V = unknown> {
+    /** The field name — the same string used as `key-form` on the control. */
+    key: string;
+    /** The value right now. */
+    currentValue: V;
+    /** The value before the most recent change. */
+    oldValue: V;
+    /** Current verdict — from the field's rules, or from `setValidation`. */
+    validate: MonoFormValidation;
+    /** Whether the field has been committed at least once (drives nothing yet; useful to consumers). */
+    touched: boolean;
+    /** The merged props currently pushed onto the element. */
+    props: Record<string, unknown>;
+    /**
+     * The control's RESOLVED options — after the search box, after the DataSource loaded, after
+     * grouping was flattened. Empty for a control that has no list.
+     *
+     * This is what `slot="list"` is looped over: the raw `items` / `dataSource` you passed in would
+     * ignore the search box and desync from what is on screen, which is the whole reason the control
+     * reports this back up rather than the consumer reusing its own array.
+     */
+    list: MonoFormListEntry[];
+}
+/** A ref-like external input (a Vue `ref` satisfies this). */
+export interface MonoFormRefLike<T = unknown> {
+    value: T;
+}
+/** Argument to `setProp` — `component` narrows `props`. */
+export type MonoFormSetProp<C extends MonoFormComponent = MonoFormComponent> = {
+    component?: C;
+    key: string;
+    props: MonoFormProps<C>;
+};
+/** Argument to `setValidation`. */
+export interface MonoFormSetValidation {
+    component?: MonoFormComponent;
+    key: string;
+    validation: Partial<MonoFormValidation>;
+}
+/** Context handed to a field watcher. */
+export interface MonoFormWatcherCtx {
+    /** The field this watcher belongs to. */
+    selfKey: string;
+    /** The field that actually changed (equals `selfKey` for a self change). */
+    peerKey: string;
+    /** Value of `selfKey`. */
+    currentValue: unknown;
+    oldValue: unknown;
+    /** Value of `peerKey` — the field that changed. */
+    peerCurrentValue: unknown;
+    peerOldValue: unknown;
+    /**
+     * The DOM `CustomEvent` (`mno-input` / `mno-change` — same payload as the plain
+     * `input` / `change`) that last touched
+     * `selfKey`. `undefined` when this field hasn't been edited by hand yet, or
+     * when its value was written programmatically via `setValue` / `setValues`.
+     */
+    event?: Event;
+    /**
+     * The DOM `CustomEvent` that caused THIS run — the one that changed `peerKey`.
+     * Same object as `event` on a self change. `undefined` for a programmatic write.
+     */
+    peerEvent?: Event;
+    /** Every field's current value. */
+    values: Record<string, unknown>;
+    /** Unwrapped `external` refs. */
+    external: Record<string, unknown>;
+    /**
+     * Push props onto any field's control. NOTE: a static `inputs[key].props`
+     * declares the same thing and ALWAYS wins over this one.
+     */
+    setProp: <C extends MonoFormComponent = MonoFormComponent>(arg: MonoFormSetProp<C>) => void;
+    /** Mark any field valid/invalid — the message renders on that control. */
+    setValidation: (arg: MonoFormSetValidation) => void;
+    /** Set another field's value (runs its rules + fans out again). */
+    setValue: (key: string, value: unknown) => void;
+}
+/**
+ * One field's declaration, for ONE component. Consumers use {@link MonoFormInput},
+ * which distributes this over the components it is given.
+ */
+export interface MonoFormInputOf<C extends MonoFormComponent = MonoFormComponent, V = unknown> {
+    /** Narrows the TS type of `props`. Optional — omit for a loose record. */
+    component?: C;
+    /**
+     * Static props for this field's control that ALWAYS win — over the
+     * `setProp()` method and over template bindings. Same name and role as
+     * `monoDataGrid({ props })`.
+     */
+    props?: MonoFormProps<C>;
+    /** Initial value for the field. */
+    value?: V;
+    /**
+     * Rules for this field, checked in order — the FIRST failure is reported,
+     * since a control renders one message. Each entry is a built-in `type`, a
+     * `type: 'custom'` function, or a `schema` (which wins over both).
+     */
+    validates?: MonoFormRule<V>[];
+    /**
+     * Runs when THIS field changes (`peerKey === selfKey`) and whenever any OTHER
+     * field changes (`peerKey` = that field) — which is what lets one field react
+     * to another without a separate peer-watcher registry.
+     */
+    watcher?: (ctx: MonoFormWatcherCtx) => void;
+}
+/**
+ * One field's declaration — {@link MonoFormInputOf} DISTRIBUTED over `C`, so
+ * `component: 'mono-input'` discriminates the declaration and `props` narrows to
+ * that component's props, with its `on<Event>` handlers typed
+ * (`onChange: (e) => e.detail.modelValue`). Written as one interface over the
+ * union, `props` was the union of every component's props and a handler's
+ * `event` fell back to `any`. A declaration without `component` still matches
+ * (every member's `component` is optional) and keeps the loose union.
+ */
+export type MonoFormInput<C extends MonoFormComponent = MonoFormComponent, V = unknown> = {
+    [K in C]: MonoFormInputOf<K, V>;
+}[C];
+export interface MonoFormOptions {
+    /** Default rule timing for the whole form. Defaults to `'change'`. */
+    validation?: {
+        type?: MonoFormTiming;
+    };
+    inputs: Record<string, MonoFormInput>;
+    /** Ref-like values readable from watchers as `external.<name>`. */
+    external?: Record<string, MonoFormRefLike | unknown>;
+    /**
+     * A ref the form writes a fresh snapshot into on every change, so a Vue
+     * template can read `state.Name.validate.message` and re-render without any
+     * manual subscription.
+     */
+    state?: MonoFormRefLike<Record<string, MonoFormItem> | undefined>;
+}
+/** The controller returned by {@link monoForm}. */
+export interface MonoFormController {
+    /** Live state for every field (stable object, mutated in place). */
+    items(): Record<string, MonoFormItem>;
+    /** Just the values, `{ Name: 'Denis', Age: 18 }`. */
+    values(): Record<string, unknown>;
+    setValue(key: string, value: unknown): void;
+    /** Bulk-set values, e.g. seeding an edit form from a fetched record. */
+    setValues(values: Record<string, unknown>): void;
+    /** Run EVERY rule on every field regardless of timing. Resolves to overall validity. */
+    validate(): Promise<boolean>;
+    /** Whether every field currently passes. */
+    isValid(): boolean;
+    /** Clear values + validation back to the declared defaults. */
+    reset(): void;
+    /** Push props onto a field's control. `inputs[key].props` still wins over this. */
+    setProp<C extends MonoFormComponent = MonoFormComponent>(arg: MonoFormSetProp<C>): void;
+    /** Mark any field valid/invalid, e.g. from a server response. */
+    setValidation(arg: MonoFormSetValidation): void;
+    /** Re-read `external` refs and re-run watchers. */
+    refresh(): void;
+    /** Write snapshots into `ref` on every change (same as the `state` option). */
+    bindRef(ref: MonoFormRefLike<Record<string, MonoFormItem> | undefined>): () => void;
+    subscribe(cb: () => void): () => void;
+    dispose(): void;
+    /** @internal Register an element under `key`; returns an unregister handle. */
+    _register(key: string, el: unknown): () => void;
+    /**
+     * @internal Element reported a value change. `timing` picks which rules run;
+     * `event` is the originating `mno-input`/`mno-change` CustomEvent, surfaced to
+     * watchers as `event` / `peerEvent`.
+     */
+    _report(key: string, value: unknown, timing: MonoFormTiming, event?: Event): void;
+    /**
+     * @internal A list control publishing its resolved options, so `form.items()[key].list` can be
+     * looped from a `slot="list"`. Reference-compared, so a control may call it on every render.
+     */
+    _reportList(key: string, entries: MonoFormListEntry[]): void;
+    /** @internal The props an element should currently apply (`inputs[key].props` wins). */
+    _propsFor(key: string): Record<string, unknown>;
+}
+export {};

package/dist/src/components/form/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { monoForm, controlMonoForm } from './mono-form-controller.js';
+export { MonoFormControlCore } from './form-control-core.js';
+export type { MonoFormControlCoreInterface } from './form-control-core.js';
+export { runRule, runRules, isBlank } from './form-rules.js';
+export type { MonoFormOptions, MonoFormController, MonoFormInput, MonoFormInputOf, MonoFormItem, MonoFormRule, MonoFormRuleCtx, MonoFormSchemaLike, MonoFormTiming, MonoFormValidation, MonoFormWatcherCtx, MonoFormComponent, MonoFormComponentProps, MonoFormProps, MonoFormSetProp, MonoFormSetValidation, MonoFormRefLike, } from './form-types.js';

package/dist/src/components/form/mono-form-controller.d.ts

@@ -0,0 +1,16 @@
+import { MonoFormController, MonoFormOptions } from './form-types.js';
+/**
+ * `monoForm()` — a headless form controller.
+ *
+ * The consumer authors the markup by hand and opts each control in with
+ * `:data-form="form"` + `key-form="Name"`. The controller owns the value,
+ * validation, cross-field reactions and the props pushed onto each element;
+ * nothing here touches the DOM, so it is SSR-safe and testable on its own.
+ *
+ * Mirrors `monoDataGrid`'s controller shape: a plain object with coalesced
+ * `subscribe`/`notify`, state mutated in place, and elements re-rendering off
+ * the subscription.
+ */
+/** Renamed "control" alias of {@link monoForm} (no breaking change — both work). */
+export { monoForm as controlMonoForm };
+export declare function monoForm(options: MonoFormOptions): MonoFormController;

package/dist/src/components/input/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoInput } from './mono-input.js';
+export type { InputType, InputSize, InputVariant, InputColor, InputProps, InputEvents, } from './input-types.js';
+export { applyFormat, caretAfterFormat, localeSeparators, normaliseValue, parseFormat, resolveFormat, significantFor, stripFormat, } from './input-format.js';
+export type { InputFormat, InputFormatCtx, InputFormatDescriptor, InputFormatOn, } from './input-format.js';
+export { validateInputProps, generateInputAttributes, generateInputAriaAttributes, getInputIcon, } from './input-utils.js';

package/dist/src/components/input/index.shadow.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoInputShadow } from './mono-input.shadow.js';
+export { MonoInputCore } from './input-core.js';
+export type { InputSlotName } from './input-core.js';
+export type { InputType, InputSize, InputVariant, InputColor, InputProps, InputEvents, } from './input-types.js';
+export { applyFormat, caretAfterFormat, localeSeparators, normaliseValue, parseFormat, resolveFormat, significantFor, stripFormat, } from './input-format.js';
+export type { InputFormat, InputFormatCtx, InputFormatDescriptor, InputFormatOn, } from './input-format.js';
+export { validateInputProps, generateInputAttributes, generateInputAriaAttributes, getInputIcon, } from './input-utils.js';

package/dist/src/components/input/input-core.d.ts

@@ -0,0 +1,91 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { InputType, InputSize, InputColor, InputVariant, InputValidationState, InputCssClass } from './input-types.js';
+import { InputFormat, InputFormatOn } from './input-format.js';
+import { Constructor } from '../../composables/hybird-prop';
+import { buildSizeStyle, CssSizeValue } from '../../composables/css-size';
+export declare const numberStringConverter: {
+    fromAttribute(value: string | null): number | undefined;
+    toAttribute(value: number | undefined): string | null;
+};
+export type InputSlotName = 'prefix' | 'suffix' | 'label' | 'helper';
+/** Public surface added by the core mixin (for typing the wrappers + tag map). */
+export declare class MonoInputCoreInterface {
+    cssClass: InputCssClass;
+    cssClassName: string;
+    type: InputType;
+    size: InputSize;
+    color: InputColor;
+    variant: InputVariant;
+    modelValue: string;
+    formatDisplay?: InputFormat;
+    formatValue?: InputFormat;
+    formatOn: InputFormatOn;
+    formatLocale?: string;
+    value: string;
+    name: string;
+    placeholder: string;
+    label: string;
+    helperText: string;
+    validationState: InputValidationState;
+    validationMessage: string;
+    error: boolean;
+    errorMessage: string;
+    success: boolean;
+    successMessage: string;
+    pattern: string;
+    autocomplete: string;
+    inputmode: string;
+    ariaLabelText?: string;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    clearable: boolean;
+    autofocus: boolean;
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    focus(): void;
+    blur(): void;
+    select(): void;
+    protected _hasPrefixSlotState: boolean;
+    protected _hasSuffixSlotState: boolean;
+    protected _hasLabelSlotState: boolean;
+    protected _hasHelperSlotState: boolean;
+    protected readonly _hasPrefixSlot: boolean;
+    protected readonly _hasSuffixSlot: boolean;
+    protected readonly _hasLabelSlot: boolean;
+    protected readonly _hasHelperSlot: boolean;
+    protected readonly _inputId: string;
+    protected readonly _messageId: string;
+    protected readonly _resolvedValidationState: InputValidationState;
+    protected readonly _wrapperClasses: string;
+    protected readonly _fieldClasses: string;
+    protected _cls(base: string, key: keyof InputCssClass): string;
+    protected _sizeStyle(): ReturnType<typeof buildSizeStyle>;
+    protected _renderWrapper(inner: TemplateResult): TemplateResult;
+    protected _renderNative(): TemplateResult;
+    protected _renderClear(): TemplateResult | typeof nothing;
+    protected renderIcon(name: 'close'): TemplateResult;
+}
+/**
+ * `MonoInputCore` — all render-mode-agnostic logic for `mono-input`: reactive
+ * props, hybrid prop aliases (camelCase ↔ kebab ↔ lowercase), attribute
+ * observation, value/model two-way sync, events, validation/class computation,
+ * sizing, and imperative focus/blur/select.
+ *
+ * It deliberately leaves out:
+ *  - `createRenderRoot()` (light vs shadow) — set by each wrapper.
+ *  - the slot strategy + `render()` — light uses a capture/`data-mono-slot`
+ *    hack; shadow uses native `<slot>` with slotchange-driven presence. The
+ *    shared `_hasXxxSlotState` `@state` fields back both strategies and feed the
+ *    class getters.
+ */
+export declare const MonoInputCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoInputCoreInterface> & T;

package/dist/src/components/input/input-format.d.ts

@@ -0,0 +1,118 @@
+/**
+ * `<mono-input>` value formatting — the pattern dialect, and the caret maths that make it usable
+ * while typing.
+ *
+ * Everything here is PURE and DOM-free on purpose: live formatting is easy to get subtly wrong
+ * (trailing separators, a caret that jumps to the end, a value that stops parsing), and those are
+ * only cheap to test when they are plain functions.
+ *
+ * ── Two dialects, chosen by content ──
+ *
+ * A pattern containing `{}` is a TEMPLATE — the typed text goes in the hole and everything else is
+ * literal (`"{}@gmail.com"`). Anything else is a NUMBER pattern in the Excel / DevExtreme surface
+ * syntax the rest of this codebase already speaks (`#,##0.##`):
+ *
+ *   `#`     an optional digit
+ *   `0`     a required digit (pads with zeros)
+ *   `,`     turn on grouping
+ *   `.`     the decimal point
+ *   `"…"`   a literal prefix or suffix (`"Rp"#,##0`)
+ *
+ * The pattern describes a SHAPE — grouping on, up to two decimals — and the LOCALE decides which
+ * characters that shape is drawn with, so `#,##0.##` prints `10,000.25` under `en-US` and
+ * `10.000,25` under `id-ID`. Nothing here hand-rolls a separator.
+ *
+ * ── Why this does not use `parseNumber` from `src/import/coerce.ts` ──
+ *
+ * That parser exists to read numbers whose locale is UNKNOWN, so it infers the separators from the
+ * text — and its rule ("a single `.` with exactly three trailing digits is grouping") is a good
+ * guess but still a guess: `1.234` is 1234 while `1.23` is 1.23. Here the locale is declared, so
+ * the separators can be derived from `Intl` and the strip is exact rather than inferred. Guessing
+ * would be strictly worse when the answer is already known.
+ */
+/** When the display reformats. */
+export type InputFormatOn = 'input' | 'blur';
+/** What a format FUNCTION receives. */
+export interface InputFormatCtx {
+    /** The typed text with any formatting removed — the raw value. */
+    value: string;
+    /** The input's `type`, so one function can serve several fields. */
+    type: string;
+    /** The resolved locale, when one was given. */
+    locale?: string;
+}
+/** A pattern string, or a function that returns the finished text. */
+export type InputFormat = string | ((ctx: InputFormatCtx) => string);
+/** A parsed pattern. */
+export type InputFormatDescriptor = {
+    kind: 'number';
+    grouping: boolean;
+    minFraction: number;
+    maxFraction: number;
+    prefix: string;
+    suffix: string;
+} | {
+    kind: 'template';
+    before: string;
+    after: string;
+};
+/** The characters a locale draws a grouped decimal number with. */
+export interface LocaleSeparators {
+    group: string;
+    decimal: string;
+}
+/**
+ * Ask `Intl` which characters this locale uses, rather than assuming `,` and `.`.
+ *
+ * Several locales use neither — `fr-FR` groups with a narrow no-break space, `de-CH` with an
+ * apostrophe — and a hardcoded pair would silently mangle them.
+ */
+export declare function localeSeparators(locale?: string): LocaleSeparators;
+/**
+ * Parse a pattern string into a descriptor, or `null` when it is not a pattern we understand.
+ *
+ * `null` is deliberately not an error: an unparseable pattern leaves the field an ordinary
+ * unformatted input rather than blanking it or throwing mid-keystroke.
+ */
+export declare function parseFormat(pattern: string): InputFormatDescriptor | null;
+export declare function stripFormat(text: string, descriptor: InputFormatDescriptor | null, locale?: string): string;
+/**
+ * Render a raw value for DISPLAY.
+ *
+ * The number branch deliberately does NOT hand the whole string to `Intl`: a value being typed is
+ * usually not yet a finished number, and `Intl` would tidy away exactly the characters the user is
+ * in the middle of writing — a trailing decimal point (`10000.`) and trailing fraction zeros
+ * (`10.50`) both vanish, which makes the field fight the person using it. Only the INTEGER part is
+ * grouped; the fraction is carried through verbatim, clamped to the pattern's ceiling.
+ */
+export declare function applyFormat(raw: string, descriptor: InputFormatDescriptor | null, locale?: string, opts?: {
+    pad?: boolean;
+}): string;
+/**
+ * Normalise a raw value for the VALUE side.
+ *
+ * A number pattern yields a canonical numeric string (`"10000000.25"`) rather than the formatted
+ * text, so `Number(v)` works and a store that does arithmetic on it does not have to know a format
+ * was ever involved. A template yields the assembled string, because there the decoration IS the
+ * value — an email is not an email without its domain.
+ */
+export declare function normaliseValue(raw: string, descriptor: InputFormatDescriptor | null): string;
+/**
+ * Where the caret belongs after the text was reformatted.
+ *
+ * Reformatting rewrites the whole field, and the browser then parks the caret at the end — so
+ * inserting a digit in the middle of a number would throw you to the end on every keystroke. The
+ * fix is to count in SIGNIFICANT characters (the ones the user actually typed) rather than in
+ * string offsets: count how many sit left of the caret before, then walk the new text until the
+ * same number have gone by.
+ */
+export declare function caretAfterFormat(next: string, caretInPrev: number, prev: string, isSignificant: (ch: string) => boolean): number;
+/**
+ * Which characters count as "typed" for caret purposes — everything the format did NOT insert.
+ */
+export declare function significantFor(descriptor: InputFormatDescriptor | null, locale?: string): (ch: string) => boolean;
+/** Resolve either form of a format prop to its finished text. */
+export declare function resolveFormat(format: InputFormat | undefined, raw: string, ctx: {
+    type: string;
+    locale?: string;
+}, mode: 'display' | 'value'): string | null;