@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/parts/data/KeyedItems.d.ts

@@ -0,0 +1,91 @@
+import { type Event as MotifEvent } from '@motifx/core';
+import { data } from '@motifx-community/data';
+import type { KeyedItem } from './keyed-item';
+import type { TextSearch } from './text-search';
+type Source = data.DataSource<any, any> | readonly unknown[];
+/**
+ * Items by key, from a data source of the data layer (any adapter) or an array: what a grid cell, a
+ * drop-down's field or a filter list needs to turn a key into its item. Keys are asked for when they
+ * are needed and only once: the keys asked for in the same moment go out together, in one request
+ * per `batchSize` keys (`valueField in [...]`), or one request per key for a service that only gives
+ * one item by key (`resolve: 'byKey'`). There is one cache per source and value field, shared by
+ * every grid, column and list that uses it (`KeyedItems.of`). Requests go through the source's
+ * adapter, so the source's own query (filter, page, search) never changes.
+ *
+ * @example
+ * const customers = KeyedItems.of(customerSource, 'id');
+ * customers.onResolved(() => redraw());
+ * customers.request([7, 9]);
+ * customers.get(7); // { state: 'loading' }, later { state: 'found', item }
+ */
+export declare class KeyedItems<T = unknown> {
+    private readonly source;
+    readonly valueField?: string | undefined;
+    /** `'batch'`: the keys of a moment in one request each `batchSize`; `'byKey'`: one request per key. Default: `'batch'` when the service filters, else `'byKey'`. */
+    resolve: 'batch' | 'byKey';
+    batchSize: number;
+    /** `'byKey'`: requests at the same time. */
+    parallelRequests: number;
+    /** Items asked for when an exact text is looked for (a pasted text). */
+    pasteSearchLimit: number;
+    private readonly entries;
+    private readonly waiting;
+    private queue;
+    private queued;
+    private index;
+    private indexedLength;
+    private generation;
+    private readonly resolvedEmitter;
+    /** Keys were resolved (their key texts) or, with `null`, everything was cleared. */
+    readonly onResolved: MotifEvent<readonly string[] | null>;
+    /** The same text for equal keys, as the cache keeps them (`1` and `'1'` are one key). */
+    static keyString(key: unknown): string;
+    /** The shared cache of a source and value field. Every data source over the same adapter shares it. */
+    static of<T = unknown>(source: data.DataSource<any, any> | readonly T[], valueField?: string): KeyedItems<T>;
+    constructor(source: Source, valueField?: string | undefined);
+    /** Whether the items are an array in memory (every key is known at once). */
+    get inMemory(): boolean;
+    /** The value of an item: its `valueField`, else the adapter's key (an array: `item.value`, or the item itself). */
+    valueOf(item: T): unknown;
+    sameKey(a: unknown, b: unknown): boolean;
+    /** What is known of a key now; `undefined` when it was never asked for (an array knows every key). */
+    get(key: unknown): KeyedItem<T> | undefined;
+    /** Asks for the keys not known yet; resolves once every one of them is found or missing. */
+    request(keys: Iterable<unknown>): Promise<void>;
+    /** Keeps what an editor chose for a key: its item, or its text. It shows at once, without a request. */
+    remember(key: unknown, itemOrText: T | string): void;
+    /** Items among those known whose text is exactly `text` (case aside, in the locale). */
+    findLoadedByText(text: string, search: TextSearch<T>): T[];
+    /** Items whose text is exactly `text`: among those known, else asked from the source. */
+    findByText(text: string, search: TextSearch<T>): Promise<T[]>;
+    /**
+     * A part of the items whose text holds `text` (all of them for an empty text), in the source's
+     * order, and how many there are. The items found are kept, so their keys show at once.
+     */
+    search(text: string, search: TextSearch<T>, skip?: number, take?: number): Promise<{
+        items: T[];
+        total: number;
+    }>;
+    /** `search` at once, for items in an array; `null` for items that come from a source. */
+    searchInMemory(text: string, search: TextSearch<T>, skip?: number, take?: number): {
+        items: T[];
+        total: number;
+    } | null;
+    /** Forgets everything; keys are asked for again when they are needed. */
+    clear(): void;
+    private get adapter();
+    /** A source the app reloads drops what is known. */
+    private watch;
+    private fromArray;
+    /** The field a batch filters on: `valueField`, else the adapter's key when it is one field. */
+    private batchField;
+    private flush;
+    private loadMany;
+    private loadOne;
+    /** Items a search brought: their keys are known from now on. */
+    private keep;
+    /** The adapter saved or was told of changes: those keys are asked for again (all of them when the value is not the key). */
+    private changed;
+    private batchFieldOfKey;
+}
+export {};

package/dist/parts/data/keyed-item.d.ts

@@ -0,0 +1,9 @@
+/** What `KeyedItems` knows of one key: still asked for, found (with its item, or a text an editor chose), or not in the source. */
+export interface KeyedItem<T> {
+    state: 'loading' | 'found' | 'missing';
+    item?: T;
+    /** A text remembered for the key without its item. */
+    text?: string;
+    /** `missing` because the request failed, not because the source said so. */
+    failed?: boolean;
+}

package/dist/parts/data/text-search.d.ts

@@ -0,0 +1,12 @@
+import type { data } from '@motifx-community/data';
+/** How `KeyedItems` finds items by their text. */
+export interface TextSearch<T> {
+    /** The text of an item, as the user sees it. */
+    textOf: (item: T) => string;
+    /** Fields a data source searches on its service. Without them the items are searched here, by `textOf`. */
+    searchFields?: readonly string[];
+    /** Narrows the items (a data source: on its service; an array: here). */
+    filter?: data.FilterExpression | null;
+    /** Locale of the comparison. Default: the page's. */
+    locale?: string;
+}

package/dist/parts/dates/add-days.d.ts

@@ -0,0 +1 @@
+export declare function addDays(date: Date, days: number): Date;

package/dist/parts/dates/add-months.d.ts

@@ -0,0 +1,2 @@
+/** Jan 31 plus one month is the last day of February. */
+export declare function addMonths(date: Date, months: number): Date;

package/dist/parts/dates/date-kind.d.ts

@@ -0,0 +1,2 @@
+/** What a date field holds: a day, a time of day, or both. */
+export type DateKind = 'date' | 'time' | 'datetime';

package/dist/parts/dates/date-part.d.ts

@@ -0,0 +1 @@
+export type DatePart = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';

package/dist/parts/dates/date-pattern-of.d.ts

@@ -0,0 +1,4 @@
+import type { DateKind } from './date-kind';
+import type { DatePattern } from './date-pattern';
+/** The digit pattern `locale` writes dates (and times, in 24 hours) with. */
+export declare function datePatternOf(locale: string, kind: DateKind, seconds?: boolean): DatePattern;

package/dist/parts/dates/date-pattern.d.ts

@@ -0,0 +1,7 @@
+import type { DatePart } from './date-part';
+/** How a locale writes a date with digits: the parts in order, and a mask for typing it. */
+export interface DatePattern {
+    parts: DatePart[];
+    /** `00.00.0000 00:00` */
+    mask: string;
+}

package/dist/parts/dates/date-to-digits.d.ts

@@ -0,0 +1,3 @@
+import type { DatePattern } from './date-pattern';
+/** The digits a date is typed with in `pattern`, for the mask: `22112006`. */
+export declare function dateToDigits(date: Date, pattern: DatePattern): string;

package/dist/parts/dates/day-start.d.ts

@@ -0,0 +1,2 @@
+/** The same day at midnight, local time. */
+export declare function dayStart(date: Date): Date;

package/dist/parts/dates/digits-to-date.d.ts

@@ -0,0 +1,3 @@
+import type { DatePattern } from './date-pattern';
+/** The date typed as `digits` in `pattern`; `null` when it is not a real date. A part the pattern lacks comes from `base`. */
+export declare function digitsToDate(digits: string, pattern: DatePattern, base?: Date): Date | null;

package/dist/parts/dates/first-day-of-week.d.ts

@@ -0,0 +1,2 @@
+/** The day a week starts on where `locale` is used: 0 Sunday … 6 Saturday. */
+export declare function firstDayOfWeek(locale: string): number;

package/dist/parts/dates/iso-week.d.ts

@@ -0,0 +1,2 @@
+/** The ISO 8601 week number: weeks start on Monday, week 1 holds the year's first Thursday. */
+export declare function isoWeek(date: Date): number;

package/dist/parts/dates/same-day.d.ts

@@ -0,0 +1 @@
+export declare function sameDay(a: Date | null | undefined, b: Date | null | undefined): boolean;

package/dist/parts/dates/time-zone.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A time zone: an IANA name (`Europe/Istanbul`), or the browser's own. It turns moments into wall
+ * clock times and back with `Intl` only. A wall clock time is milliseconds of UTC with the clock's
+ * fields (`Date.UTC(2026, 9, 25, 2, 30)` is half past two on the clock), so days and hours can be
+ * counted on it without summer time getting in the way. A time the clock skips (the hour put
+ * forward) is moved on by the gap; a time it shows twice (the hour put back) is the first one,
+ * unless the later is asked for.
+ *
+ * @example
+ * const berlin = TimeZone.of('Europe/Berlin');
+ * berlin.moment(Date.UTC(2026, 2, 29, 2, 30)); // 01:30 UTC: 02:30 does not happen that night
+ */
+export declare class TimeZone {
+    /** The IANA name; empty for the browser's own zone. */
+    readonly name: string;
+    private static readonly made;
+    private static warned;
+    /** The browser's own zone. */
+    static readonly local: TimeZone;
+    /** A zone by its IANA name; the browser's own for none (or for a name `Intl` does not know). */
+    static of(name?: string | null): TimeZone;
+    /** Whether `Intl` knows a zone by this name. */
+    static isValid(name: string): boolean;
+    /** The IANA names the browser knows, with `UTC`. */
+    static names(): string[];
+    /** The browser's own zone's IANA name. */
+    static localName(): string;
+    private readonly offsets;
+    private format;
+    private constructor();
+    /** Minutes the clock is ahead of UTC at a moment (east positive). */
+    offset(moment: number | Date): number;
+    /** The wall clock time of a moment. */
+    wall(moment: number | Date): number;
+    /** The moment the clock shows `wall`: skipped times move on by the gap; of a time shown twice, the first (or `later`). */
+    moment(wall: number, later?: boolean): number;
+    /** The moment as a `Date`. */
+    date(wall: number, later?: boolean): Date;
+    /** The start of the day a moment is in, on this clock. */
+    dayStart(moment: number | Date): Date;
+    /** The same time of the clock `days` later (or earlier). */
+    addDays(moment: number | Date, days: number): Date;
+    /** Whether two moments are on the same day of this clock. */
+    sameDay(a: number | Date, b: number | Date): boolean;
+    /** A date of the browser's clock with this clock's fields at a moment: for editors and calendars, which show the browser's. */
+    toLocal(moment: number | Date): Date;
+    /** The moment this clock shows the fields of a date of the browser's clock (what `toLocal` gave, or an editor's value). */
+    fromLocal(local: Date): Date;
+    /** The wall clock time of a date of the browser's clock, by its fields. */
+    static wallOfLocal(local: Date): number;
+    /** A date of the browser's clock with the fields of a wall clock time. */
+    static localOfWall(wall: number): Date;
+}

package/dist/parts/drag/DragGhost.d.ts

@@ -0,0 +1,57 @@
+/** How a copy shown with `showAt` follows the pointer. */
+interface Follow {
+    /** Where its top left corner sits from the pointer. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** The axis it may move along. */
+    direction: 'both' | 'vertical' | 'horizontal';
+    /** Kept inside this box. */
+    bounds: DOMRect | null;
+    /** Where it started, for the axis it may not move along. */
+    start: {
+        left: number;
+        top: number;
+    };
+}
+/**
+ * The picture of something dragged (a header, a chip, a row, a tab): a copy of it next to the
+ * pointer while it moves, marked with what a drop would do there (`data-target`). It lives inside
+ * the element `root` gives, so it shows above a modal window that element sits in; its place is
+ * measured from where it starts, so a moved or scaled window around it does not throw it off. The
+ * component styles it through `className` and `data-kind`.
+ */
+export declare class DragGhost {
+    private readonly root;
+    private readonly enabled;
+    private readonly className;
+    private el;
+    private origin;
+    private follow;
+    constructor(root: () => HTMLElement, enabled: () => boolean, className: string);
+    /** Whether a copy is shown. */
+    get shown(): boolean;
+    /** Starts showing a copy of `source`, as wide and as tall as it is, after the pointer. */
+    show(source: HTMLElement, x: number, y: number, kind: string): void;
+    /**
+     * Starts showing `content` (a copy, or a drag template) with its top left corner at `offset`
+     * from the pointer, in `root`; it moves along `direction` only and stays in `bounds`.
+     */
+    showAt(content: Node, kind: string, x: number, y: number, options: {
+        offset: {
+            x: number;
+            y: number;
+        };
+        root?: HTMLElement | null;
+        direction?: Follow['direction'];
+        bounds?: DOMRect | null;
+    }): void;
+    /** Follows the pointer; `target` says what dropping here would do. */
+    move(x: number, y: number, target: string): void;
+    hide(): void;
+    /** A copy that looks the same and is nothing else: no ids, no Tab stops, not dragged-looking. */
+    copyOf(source: HTMLElement, sized?: boolean): HTMLElement;
+    private open;
+}
+export {};

package/dist/parts/drag/scroll-step.d.ts

@@ -0,0 +1,6 @@
+/**
+ * How far to scroll in one frame while something is dragged at `pos` near the edges of `start`…`end`
+ * (one axis): nothing farther than `sensitivity` from them, `speed` at the edge and beyond it, less
+ * on the way in. Negative scrolls towards `start`.
+ */
+export declare function scrollStep(pos: number, start: number, end: number, sensitivity: number, speed: number): number;

package/dist/parts/field/Field.d.ts

@@ -0,0 +1,130 @@
+import { type Bind, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import { Control } from '../../core/control';
+import type { ControlSize } from '../../core/control-size';
+import type { IconSource } from '../../core/icon-source';
+import type { ValidationGroup } from '../validation/ValidationGroup';
+import type { ValidationRule } from '../validation/validation-rule';
+import type { ValidationTarget } from '../validation/validation-target';
+import type { BoxArea } from './box-area';
+import type { FieldButton } from './field-button';
+import type { FieldLabelMode } from './field-label-mode';
+import type { FieldProps } from './field-props';
+import type { FieldVariant } from './field-variant';
+import type { ValidateOn } from './validate-on';
+import type { ValidatedEventArgs } from './validated-event-args';
+import type { ValueChangedEventArgs } from './value-changed-event-args';
+/**
+ * The base of every editor: a label, a box with the editor and its buttons, a line for help or
+ * an error, the value (two-way with `x-model`) and validation. A subclass gives the element that
+ * holds the value (`createControl`) and draws the value into it (`renderValue`).
+ */
+export declare abstract class Field<T, TProps extends FieldProps<T> = FieldProps<T>> extends Control<HTMLDivElement, TProps> implements ValidationTarget {
+    constructor(props?: IBaseProp<TProps>);
+    get value(): T;
+    set value(value: Bind<T>);
+    get label(): string;
+    set label(value: Bind<string>);
+    /** As set, else the design language's default. */
+    get labelMode(): FieldLabelMode;
+    set labelMode(value: Bind<FieldLabelMode>);
+    get helpText(): string;
+    set helpText(value: Bind<string>);
+    get hint(): string;
+    set hint(value: Bind<string>);
+    get prefix(): string;
+    set prefix(value: Bind<string>);
+    get suffix(): string;
+    set suffix(value: Bind<string>);
+    get icon(): IconSource | null;
+    set icon(value: Bind<IconSource | null>);
+    get buttons(): readonly FieldButton[];
+    set buttons(value: Bind<readonly FieldButton[]>);
+    get readOnly(): boolean;
+    set readOnly(value: Bind<boolean>);
+    get required(): boolean;
+    set required(value: Bind<boolean>);
+    get size(): ControlSize;
+    set size(value: Bind<ControlSize>);
+    /** As set, else the design language's default. */
+    get variant(): FieldVariant;
+    set variant(value: Bind<FieldVariant>);
+    get stretch(): boolean;
+    set stretch(value: Bind<boolean>);
+    get rules(): readonly ValidationRule<T>[];
+    set rules(value: Bind<readonly ValidationRule<T>[]>);
+    get error(): string;
+    set error(value: Bind<string | null>);
+    get validateOn(): ValidateOn;
+    set validateOn(value: Bind<ValidateOn>);
+    get validationGroup(): ValidationGroup | null;
+    set validationGroup(value: Bind<ValidationGroup | null>);
+    get onValueChanged(): MotifEvent<ValueChangedEventArgs<T>>;
+    get onValidated(): MotifEvent<ValidatedEventArgs>;
+    /** `false` while a failed check or an `error` shows. */
+    get isValid(): boolean;
+    /** The error shown, `''` when there is none. */
+    get validationMessage(): string;
+    /** An asynchronous rule is running. */
+    get validating(): boolean;
+    /** Checks the value and shows the outcome. */
+    validate(): Promise<boolean>;
+    /** Hides the outcome of earlier checks; a running one is dropped. */
+    resetValidation(): void;
+    /** The element that holds the value and takes focus. Called once, before the subclass's fields exist. */
+    protected abstract createControl(): HTMLElement;
+    /** Draws the value into the control. */
+    protected abstract renderValue(value: T): void;
+    protected abstract emptyValue(): T;
+    protected normalizeValue(value: T): T;
+    protected isEmptyValue(value: T): boolean;
+    protected sameValue(a: T, b: T): boolean;
+    /** The rules the field brings itself, checked before `rules`. */
+    protected builtInRules(): ValidationRule<T>[];
+    /** The value without tracking it. */
+    protected peekValue(): T;
+    /** The user changed the value: stored, written back to `x-model`, reported and checked. */
+    protected commit(value: T, event?: Event): void;
+    /** Writes the value to `x-model`, if there is one. */
+    protected writeBack(value: T): void;
+    /**
+     * Reads your data again after it was changed in place (the field's buttons here; a list its items). Your data
+     * may be plain or reactive; the field reads it as it is.
+     */
+    refresh(): void;
+    /** A place in the box for the subclass's own parts (a clear button, a drop-down arrow). */
+    protected area(name: BoxArea): HTMLElement;
+    /** Takes a place out of the box; `area` makes a new one when it is wanted again. */
+    protected removeArea(name: BoxArea): void;
+    /** A short text at the end of the line under the box, e.g. `12/50`; `''` removes it. */
+    protected setCounter(text: string): void;
+    /**
+     * Shows or removes the button that empties the field (named from `uiLocale`, not a Tab stop);
+     * `clear` runs on a press, then the field gets focus. `className` is the subclass's own hook.
+     */
+    protected showClearButton(on: boolean, clear: (event: MouseEvent) => void, className: string): void;
+    protected renderReadOnly(on: boolean): void;
+    protected get focusElement(): HTMLElement;
+    private get parts();
+    private createParts;
+    /** `x-model` handing back the value the field just wrote: the written value, not the model's copy. */
+    private takeEcho;
+    private valueStored;
+    private focusLeft;
+    private refreshValidity;
+    private joinGroup;
+    private renderLabel;
+    private renderLook;
+    /** Reads again what the design language decides for the field (variant, label mode, size). The field does it once
+     *  it is in the page; one placed in the page outside the component tree is told when it is placed. */
+    readLook(): void;
+    onMounted(): void;
+    private renderHint;
+    private renderRequired;
+    private renderAffix;
+    private renderIcon;
+    private renderButtons;
+    private drawButtons;
+    private renderMessage;
+    private markMessage;
+    private renderDescribedBy;
+}

package/dist/parts/field/box-area.d.ts

@@ -0,0 +1,2 @@
+/** The places in a field's box, in the order they are shown; the editor itself sits after `start`. */
+export type BoxArea = 'icon' | 'prefix' | 'start' | 'suffix' | 'tools' | 'end' | 'actions';

package/dist/parts/field/enter-key-event-args.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentBase } from '@motifx/core';
+export interface EnterKeyEventArgs<T> {
+    value: T;
+    source: ComponentBase;
+    event: KeyboardEvent;
+}

package/dist/parts/field/field-button-click-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentBase } from '@motifx/core';
+import type { FieldButton } from './field-button';
+export interface FieldButtonClickEventArgs {
+    button: FieldButton;
+    source: ComponentBase;
+    event: MouseEvent;
+}

package/dist/parts/field/field-button.d.ts

@@ -0,0 +1,18 @@
+import type { Bind } from '@motifx/core';
+import type { IconSource } from '../../core/icon-source';
+import type { FieldButtonClickEventArgs } from './field-button-click-event-args';
+/** A button inside a field's box. Every field but `click` and `data` may be a function. */
+export interface FieldButton {
+    icon?: Bind<IconSource>;
+    text?: Bind<string>;
+    /** A tooltip; it also names a button that has only an icon. */
+    hint?: Bind<string>;
+    /** Default `'end'`. */
+    position?: Bind<'start' | 'end'>;
+    enabled?: Bind<boolean>;
+    visible?: Bind<boolean>;
+    /** `false` takes it out of the Tab order. Default `true`. */
+    tabStop?: Bind<boolean>;
+    click?: (e: FieldButtonClickEventArgs) => void;
+    data?: unknown;
+}

package/dist/parts/field/field-label-mode.d.ts

@@ -0,0 +1,2 @@
+/** `top` above the box, `side` next to it, `floating` inside it until there is a value, `hidden` only for screen readers. */
+export type FieldLabelMode = 'top' | 'side' | 'floating' | 'hidden';

package/dist/parts/field/field-props.d.ts

@@ -0,0 +1,44 @@
+import type { Bind } from '@motifx/core';
+import type { ControlProps } from '../../core/control';
+import type { ControlSize } from '../../core/control-size';
+import type { IconSource } from '../../core/icon-source';
+import type { ValidationGroup } from '../validation/ValidationGroup';
+import type { ValidationRule } from '../validation/validation-rule';
+import type { FieldButton } from './field-button';
+import type { FieldLabelMode } from './field-label-mode';
+import type { FieldVariant } from './field-variant';
+import type { ValidateOn } from './validate-on';
+import type { ValidatedEventArgs } from './validated-event-args';
+import type { ValueChangedEventArgs } from './value-changed-event-args';
+/** Props every field has. Each one is also a settable, reactive property. */
+export interface FieldProps<T> extends ControlProps {
+    /** Two-way with `x-model`. */
+    value?: Bind<T>;
+    /** `&Name` makes Alt+N focus the field. The same as `text`. */
+    label?: Bind<string>;
+    /** Default `'top'`. */
+    labelMode?: Bind<FieldLabelMode>;
+    /** A line under the box; an error message takes its place. */
+    helpText?: Bind<string>;
+    /** A tooltip. */
+    hint?: Bind<string>;
+    prefix?: Bind<string>;
+    suffix?: Bind<string>;
+    icon?: Bind<IconSource | null>;
+    buttons?: Bind<readonly FieldButton[]>;
+    readOnly?: Bind<boolean>;
+    required?: Bind<boolean>;
+    /** Default `'md'`. */
+    size?: Bind<ControlSize>;
+    /** Default `'outline'`. */
+    variant?: Bind<FieldVariant>;
+    stretch?: Bind<boolean>;
+    rules?: Bind<readonly ValidationRule<T>[]>;
+    /** An error from outside, e.g. the server; shown until it is cleared. */
+    error?: Bind<string | null>;
+    /** Default `'blur'`. */
+    validateOn?: Bind<ValidateOn>;
+    validationGroup?: Bind<ValidationGroup | null>;
+    onValueChanged?: (e: ValueChangedEventArgs<T>) => void;
+    onValidated?: (e: ValidatedEventArgs) => void;
+}

package/dist/parts/field/field-variant.d.ts

@@ -0,0 +1,2 @@
+/** `outline` a frame, `filled` a tinted box, `underline` only a line below. */
+export type FieldVariant = 'outline' | 'filled' | 'underline';

package/dist/parts/field/same-as-written.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whether a model hands back the value a control just wrote to it: the same value, or an object or array whose
+ * fields are the same, as a reactive model gives its own copy of it. Anything else is a new value of the app's.
+ */
+export declare function sameAsWritten(value: unknown, written: unknown): boolean;

package/dist/parts/field/validate-on.d.ts

@@ -0,0 +1,2 @@
+/** `blur` when focus leaves a changed field, `input` on every change, `manual` only through `validate()`. */
+export type ValidateOn = 'blur' | 'input' | 'manual';

package/dist/parts/field/validated-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentBase } from '@motifx/core';
+export interface ValidatedEventArgs {
+    valid: boolean;
+    /** The message shown, `''` when it passed. */
+    message: string;
+    source: ComponentBase;
+}

package/dist/parts/field/value-changed-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentBase } from '@motifx/core';
+export interface ValueChangedEventArgs<T> {
+    value: T;
+    previousValue: T;
+    /** `true` when the user changed it, `false` when code did. */
+    byUser: boolean;
+    source: ComponentBase;
+    /** The DOM event of a user change. */
+    event?: Event;
+}

package/dist/parts/icalendar/add-duration.d.ts

@@ -0,0 +1,9 @@
+import type { ICalendarDate } from './icalendar-date';
+/**
+ * A date with a duration added, in its form: days on the wall clock; hours, minutes and seconds as
+ * exact time in an IANA zone, on the wall clock otherwise. A date only takes whole days.
+ */
+export declare function addDuration(date: ICalendarDate, duration: {
+    days: number;
+    time: number;
+}): ICalendarDate;

package/dist/parts/icalendar/date-property.d.ts

@@ -0,0 +1,4 @@
+import type { ICalendarDate } from './icalendar-date';
+import type { ICalendarProperty } from './icalendar-property';
+/** A date property in the date's form: `VALUE=DATE`, its `TZID`, `Z` for UTC, or a floating time. Several dates take the first one's form. */
+export declare function dateProperty(name: string, dates: readonly ICalendarDate[]): ICalendarProperty;

package/dist/parts/icalendar/escape-text.d.ts

@@ -0,0 +1,2 @@
+/** A text as a value writes it: backslash, semicolon and comma escaped, new lines as `\n`. */
+export declare function escapeText(text: string): string;

package/dist/parts/icalendar/event-lines.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarEvent } from './icalendar-event';
+/** The `VEVENT` of an event as content lines, not folded yet; `stamp` is its `DTSTAMP` when it has none, `index` makes a `UID` for one without. */
+export declare function eventLines(event: ICalendarEvent, stamp: number, index: number): string[];

package/dist/parts/icalendar/fold-line.d.ts

@@ -0,0 +1,2 @@
+/** A content line folded at 75 octets of UTF-8, never inside a character; each next line starts with a space. */
+export declare function foldLine(line: string): string;

package/dist/parts/icalendar/format-content-line.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarProperty } from './icalendar-property';
+/** A property as one content line, not folded yet. */
+export declare function formatContentLine(property: ICalendarProperty): string;

package/dist/parts/icalendar/format-offset.d.ts

@@ -0,0 +1,2 @@
+/** Minutes east of UTC as an offset is written: `+0300`, `-0500`, with seconds only when there are some. */
+export declare function formatOffset(minutes: number): string;

package/dist/parts/icalendar/icalendar-component.d.ts

@@ -0,0 +1,8 @@
+import type { ICalendarProperty } from './icalendar-property';
+/** A `BEGIN:…`/`END:…` block of a file, with the blocks inside it. */
+export interface ICalendarComponent {
+    /** Upper case. */
+    name: string;
+    properties: ICalendarProperty[];
+    children: ICalendarComponent[];
+}

package/dist/parts/icalendar/icalendar-date.d.ts

@@ -0,0 +1,6 @@
+import type { RuleDate } from '../recurrence/rule-date';
+/** A date of an iCalendar file: the fields as written (`time`, a wall clock time unless `utc`) and the zone it names. */
+export interface ICalendarDate extends RuleDate {
+    /** The `TZID` it is written in; empty for none. */
+    zone: string;
+}

package/dist/parts/icalendar/icalendar-event.d.ts

@@ -0,0 +1,25 @@
+import type { ICalendarDate } from './icalendar-date';
+import type { ICalendarProperty } from './icalendar-property';
+/** An event (`VEVENT`) of an iCalendar file. */
+export interface ICalendarEvent {
+    uid: string;
+    start: ICalendarDate;
+    /** `DTEND`, or the start with its `DURATION` added, in the start's form; `null` for none. */
+    end: ICalendarDate | null;
+    summary: string;
+    description: string;
+    location: string;
+    /** The `RRULE` value without its name; empty for none. */
+    rule: string;
+    /** Every `EXDATE`. */
+    exceptions: ICalendarDate[];
+    /** The occurrence of a series this event replaces. */
+    recurrenceId: ICalendarDate | null;
+    /** Upper case (`CONFIRMED`, `CANCELLED`); empty when not given. */
+    status: string;
+    /** The `DTSTAMP` moment. */
+    stamp: number | null;
+    sequence: number | null;
+    /** The properties the reader does not map, kept so a writer can put them back. */
+    other: ICalendarProperty[];
+}