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

package/dist/components/scheduler/appointment-form-context.d.ts

@@ -0,0 +1,11 @@
+import type { AppointmentFormData } from './appointment-form-data';
+import type { Scheduler } from './Scheduler';
+/** What the form's items given as functions get: the appointment the form is for and the form's data, as it is now. */
+export interface AppointmentFormContext<T = unknown> {
+    /** `null` for a new one. */
+    appointment: T | null;
+    /** The values in the form (its resource fields too): a function reading them is read again when a field changes. */
+    data: AppointmentFormData;
+    isNew: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-form-data.d.ts

@@ -0,0 +1,10 @@
+/** What the appointment form edits; written back to the appointment's own fields when it is saved. */
+export interface AppointmentFormData {
+    text: string;
+    start: Date | null;
+    end: Date | null;
+    allDay: boolean;
+    description: string;
+    /** Your own fields (from `formOpening`) go here too. */
+    [field: string]: unknown;
+}

package/dist/components/scheduler/appointment-template-context.d.ts

@@ -0,0 +1,15 @@
+import type { SchedulerViewType } from './scheduler-view-type';
+/** What an appointment template gets: the appointment and the part of it shown where the template is. */
+export interface AppointmentTemplateContext<T> {
+    appointment: T;
+    start: Date;
+    end: Date;
+    /** The text the scheduler would write. */
+    text: string;
+    /** The time the scheduler would write (empty for an all-day appointment). */
+    time: string;
+    allDay: boolean;
+    view: SchedulerViewType;
+    /** The resource values of the group the piece stands in, by field; `null` without groups. */
+    group: Record<string, unknown> | null;
+}

package/dist/components/scheduler/appointment-updated-event-args.d.ts

@@ -0,0 +1,12 @@
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+export interface AppointmentUpdatedEventArgs<T = unknown> {
+    appointment: T;
+    changes: Partial<T>;
+    byUser: boolean;
+    scope: SeriesScope | null;
+    series: T | null;
+    /** The appointment the change made: the occurrence changed apart (`occurrence`), or the series going on from it (`following`). */
+    added: T | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/appointment-updating-event-args.d.ts

@@ -0,0 +1,15 @@
+import type { EventArgs } from '@motifx/core';
+import type { SeriesScope } from './model/series-scope';
+import type { Scheduler } from './Scheduler';
+/** An appointment is about to change. `cancel = true` keeps it as it was; `promise` may be set to wait: it changes when it resolves to `true`. */
+export interface AppointmentUpdatingEventArgs<T = unknown> extends EventArgs {
+    appointment: T;
+    /** The new values, by the field names; they may still be changed. */
+    changes: Partial<T>;
+    byUser: boolean;
+    /** For an occurrence of a series: what the change reaches, and the series. `null` for any other appointment. */
+    scope: SeriesScope | null;
+    series: T | null;
+    promise?: Promise<boolean>;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/cell-click-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+import type { SchedulerCell } from './scheduler-cell';
+/** A cell was clicked (or double-clicked); `cancel = true` stops what the scheduler does with it. */
+export interface CellClickEventArgs<T = unknown> extends EventArgs {
+    cell: SchedulerCell;
+    event: MouseEvent | KeyboardEvent;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/cell-template-context.d.ts

@@ -0,0 +1,16 @@
+import type { SchedulerViewType } from './scheduler-view-type';
+/** What a cell template gets: the cell's time (it changes in place with the date shown). */
+export interface CellTemplateContext {
+    readonly start: Date;
+    readonly end: Date;
+    /** A cell of a whole day (the all-day panel, the month, the timeline month). */
+    readonly allDay: boolean;
+    /** Its group's resource values, by field; `null` without groups. */
+    readonly resources: Record<string, unknown> | null;
+    readonly view: SchedulerViewType;
+    readonly today: boolean;
+    /** In the work hours of its group. */
+    readonly work: boolean;
+    /** In a blocked time. */
+    readonly blocked: boolean;
+}

package/dist/components/scheduler/content-ready-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { Scheduler } from './Scheduler';
+import type { SchedulerRange } from './scheduler-range';
+/** The view shows its appointments: after the first load, a new date or view, and new data. */
+export interface ContentReadyEventArgs<T = unknown> {
+    range: SchedulerRange;
+    /** The appointments in the range. */
+    appointments: readonly T[];
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/data-error-event-args.d.ts

@@ -0,0 +1,16 @@
+import type { SeriesWrite } from './model/series-write';
+import type { Scheduler } from './Scheduler';
+/**
+ * Saving to the data source failed; the appointment shows as it was. A change to a series takes
+ * more than one write: `saved` and `unsaved` say which were made before the failure, and `undone`
+ * whether the saved ones were all taken back (when not, that part of the change stays saved).
+ */
+export interface DataErrorEventArgs<T = unknown> {
+    operation: 'add' | 'update' | 'delete';
+    appointment: T | Partial<T>;
+    error: unknown;
+    saved: SeriesWrite<T>[];
+    unsaved: SeriesWrite<T>[];
+    undone: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/date-changed-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { Scheduler } from './Scheduler';
+import type { SchedulerRange } from './scheduler-range';
+export interface DateChangedEventArgs<T = unknown> {
+    from: Date;
+    to: Date;
+    /** The days shown now. */
+    range: SchedulerRange;
+    byUser: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/date-changing-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** The scheduler is about to show another date (today, next, previous, a date chosen); `cancel = true` stays. */
+export interface DateChangingEventArgs<T = unknown> extends EventArgs {
+    from: Date;
+    to: Date;
+    byUser: boolean;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/date-template-context.d.ts

@@ -0,0 +1,13 @@
+import type { SchedulerViewType } from './scheduler-view-type';
+/** What a date template gets: a day's head (a weekday in the month), and the texts the scheduler would write. */
+export interface DateTemplateContext {
+    readonly date: Date;
+    /** "Mon" */
+    readonly weekday: string;
+    /** "27"; empty for a weekday of the month's head. */
+    readonly number: string;
+    readonly today: boolean;
+    readonly view: SchedulerViewType;
+    /** Under `groupByDate`, its group's resource values; otherwise `null`. */
+    readonly resources: Record<string, unknown> | null;
+}

package/dist/components/scheduler/drag-event-args.d.ts

@@ -0,0 +1,21 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/**
+ * An appointment is being moved or resized. `start`, `end` and `allDay` are where it would go.
+ * `cancel = true`: on `…Start` it does not begin, on `moving` and `resizing` it may not go there
+ * (it shows so; `cancel` starts `true` where the time is not free, and `false` lets it go there),
+ * on `moveEnd` and `resizeEnd` it goes back.
+ */
+export interface DragEventArgs<T = unknown> extends EventArgs {
+    appointment: T;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    /** A copy is dropped (Ctrl), the appointment itself stays. */
+    copy: boolean;
+    /** By the keys, not the pointer. */
+    byKeys: boolean;
+    /** Moved to another group: the values its resource fields would get, by field; `null` when they stay. */
+    resources: Record<string, unknown> | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/form-bind.d.ts

@@ -0,0 +1,4 @@
+import type { Bind } from '@motifx/core';
+import type { AppointmentFormContext } from './appointment-form-context';
+/** A value, a function that is followed, or a function of the form (its appointment and its data): a function with a parameter is one of the form. */
+export type FormBind<V, T> = Bind<V> | ((form: AppointmentFormContext<T>) => V);

package/dist/components/scheduler/form-items.d.ts

@@ -0,0 +1,10 @@
+import type { FormItem } from '../formlayout/form-item';
+import type { AppointmentFormContext } from './appointment-form-context';
+import type { SchedulerFormItem } from './scheduler-form-item';
+/**
+ * The appointment form's items from its settings: a built-in item or a resource by its field (the
+ * built-in changed by what an item of the same field gives), groups and tabs with their items
+ * resolved the same way, the rest as given. A setting given as a function of the form is called
+ * with it (and followed).
+ */
+export declare function formItems<T>(given: readonly (string | SchedulerFormItem<T>)[], builtIns: Map<string, FormItem[]>, form: AppointmentFormContext<T>): FormItem[];

package/dist/components/scheduler/form-opening-event-args.d.ts

@@ -0,0 +1,20 @@
+import type { EventArgs } from '@motifx/core';
+import type { FormItem } from '../formlayout/form-item';
+import type { MxForm } from '../form/MxForm';
+import type { BottomSheet } from '../sheet/BottomSheet';
+import type { AppointmentFormData } from './appointment-form-data';
+import type { Scheduler } from './Scheduler';
+/**
+ * The appointment form is about to open. `items` may be changed (fields of your own read and write
+ * `data`, whose extra keys are written to the appointment's fields of those names); `cancel = true`
+ * keeps it closed (to show a form of your own).
+ */
+export interface FormOpeningEventArgs<T = unknown> extends EventArgs {
+    /** The appointment edited; `null` for a new one. */
+    appointment: T | null;
+    data: AppointmentFormData;
+    items: FormItem[];
+    /** The form's window; on a phone, the sheet it comes up in. */
+    form: MxForm | BottomSheet;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/icalendar-export-options.d.ts

@@ -0,0 +1,10 @@
+import type { SchedulerRange } from './scheduler-range';
+/** What `exportICalendar` writes. */
+export interface ICalendarExportOptions<T = unknown> {
+    /** The appointments of the days shown (default), all the ones loaded, or those of a range of your own. A series goes whole, with its rule. */
+    range?: 'visible' | 'all' | SchedulerRange;
+    /** These appointments instead of the range's. */
+    appointments?: readonly T[];
+    /** The calendar's name (`X-WR-CALNAME`). Default: the scheduler's label. */
+    name?: string;
+}

package/dist/components/scheduler/icalendar-exported-event-args.d.ts

@@ -0,0 +1,6 @@
+import type { Scheduler } from './Scheduler';
+export interface ICalendarExportedEventArgs<T = unknown> {
+    text: string;
+    appointments: T[];
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/icalendar-exporting-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+import type { SchedulerRange } from './scheduler-range';
+/** An iCalendar file is about to be written; `appointments` may be changed, `cancel = true` writes nothing. */
+export interface ICalendarExportingEventArgs<T = unknown> extends EventArgs {
+    appointments: T[];
+    /** The range asked for, `null` for all. */
+    range: SchedulerRange | null;
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/icalendar-import-result.d.ts

@@ -0,0 +1,6 @@
+/** What `importICalendar` did: the appointments added, the ones changed (an event whose UID was there already), the ones the data layer refused. */
+export interface ICalendarImportResult<T = unknown> {
+    added: T[];
+    updated: T[];
+    failed: Partial<T>[];
+}

package/dist/components/scheduler/icalendar-imported-event-args.d.ts

@@ -0,0 +1,5 @@
+import type { ICalendarImportResult } from './icalendar-import-result';
+import type { Scheduler } from './Scheduler';
+export interface ICalendarImportedEventArgs<T = unknown> extends ICalendarImportResult<T> {
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/icalendar-importing-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { EventArgs } from '@motifx/core';
+import type { Scheduler } from './Scheduler';
+/** An iCalendar file is about to be read in; `appointments` (as they will be added) may be changed, `cancel = true` adds nothing. */
+export interface ICalendarImportingEventArgs<T = unknown> extends EventArgs {
+    text: string;
+    appointments: Partial<T>[];
+    source: Scheduler<T>;
+}

package/dist/components/scheduler/index.d.ts

@@ -0,0 +1,73 @@
+export { Scheduler } from './Scheduler';
+export { RecurrenceEditor } from './RecurrenceEditor';
+export type { RecurrenceEditorProps } from './recurrence-editor-props';
+export type { SchedulerProps } from './scheduler-props';
+export type { SchedulerView } from './scheduler-view';
+export type { SchedulerViewType } from './scheduler-view-type';
+export type { SchedulerFields } from './scheduler-fields';
+export type { SchedulerCell } from './scheduler-cell';
+export type { SchedulerRange } from './scheduler-range';
+export type { SchedulerKeys } from './scheduler-keys';
+export type { OverlapMode } from './model/overlap-mode';
+export type { ResolvedView } from './model/resolved-view';
+export type { AppointmentTemplateContext } from './appointment-template-context';
+export type { AppointmentClickEventArgs } from './appointment-click-event-args';
+export type { CellClickEventArgs } from './cell-click-event-args';
+export type { ContentReadyEventArgs } from './content-ready-event-args';
+export type { DateChangedEventArgs } from './date-changed-event-args';
+export type { DateChangingEventArgs } from './date-changing-event-args';
+export type { MoreOpeningEventArgs } from './more-opening-event-args';
+export type { SelectionChangedEventArgs } from './selection-changed-event-args';
+export type { ViewChangedEventArgs } from './view-changed-event-args';
+export type { ViewChangingEventArgs } from './view-changing-event-args';
+export type { SchedulerEditing } from './scheduler-editing';
+export type { AppointmentFormData } from './appointment-form-data';
+export type { AppointmentAddingEventArgs } from './appointment-adding-event-args';
+export type { AppointmentAddedEventArgs } from './appointment-added-event-args';
+export type { AppointmentUpdatingEventArgs } from './appointment-updating-event-args';
+export type { AppointmentUpdatedEventArgs } from './appointment-updated-event-args';
+export type { AppointmentDeletingEventArgs } from './appointment-deleting-event-args';
+export type { AppointmentDeletedEventArgs } from './appointment-deleted-event-args';
+export type { FormOpeningEventArgs } from './form-opening-event-args';
+export type { DragEventArgs } from './drag-event-args';
+export type { DataErrorEventArgs } from './data-error-event-args';
+export type { SeriesScope } from './model/series-scope';
+export type { SeriesAction } from './series-action';
+export type { SeriesEditMode } from './series-edit-mode';
+export type { SeriesAskingEventArgs } from './series-asking-event-args';
+export type { SeriesAnsweredEventArgs } from './series-answered-event-args';
+export type { SeriesWrite } from './model/series-write';
+export { rangeFilter } from './model/range-filter';
+export type { RangeFilterOptions } from './model/range-filter-options';
+export type { SchedulerResource } from './scheduler-resource';
+export type { SchedulerBlockedTime } from './scheduler-blocked-time';
+export type { SchedulerTimeCheck } from './scheduler-time-check';
+export type { ResourceHeaderContext } from './resource-header-context';
+export type { SchedulerForm } from './scheduler-form';
+export type { SchedulerFormItem } from './scheduler-form-item';
+export type { SchedulerFormTab } from './scheduler-form-tab';
+export type { FormBind } from './form-bind';
+export type { AppointmentFormContext } from './appointment-form-context';
+export type { SchedulerTemplates } from './scheduler-templates';
+export type { CellTemplateContext } from './cell-template-context';
+export type { DateTemplateContext } from './date-template-context';
+export type { TimeTemplateContext } from './time-template-context';
+export type { TooltipTemplateContext } from './tooltip-template-context';
+export type { AgendaRowContext } from './agenda-row-context';
+export type { MoreListContext } from './more-list-context';
+export type { ScrollingMode } from './model/scrolling-mode';
+export type { SchedulerPresentation } from './scheduler-presentation';
+export type { SchedulerPresentationKind } from './scheduler-presentation-kind';
+export type { SchedulerTabletWhen } from './scheduler-tablet-when';
+export type { SchedulerPresentationChangingEventArgs } from './presentation-changing-event-args';
+export type { SchedulerPresentationChangedEventArgs } from './presentation-changed-event-args';
+export type { TimeZoomChangingEventArgs } from './time-zoom-changing-event-args';
+export type { TimeZoomChangedEventArgs } from './time-zoom-changed-event-args';
+export type { ICalendarExportOptions } from './icalendar-export-options';
+export type { ICalendarExportingEventArgs } from './icalendar-exporting-event-args';
+export type { ICalendarExportedEventArgs } from './icalendar-exported-event-args';
+export type { ICalendarImportingEventArgs } from './icalendar-importing-event-args';
+export type { ICalendarImportedEventArgs } from './icalendar-imported-event-args';
+export type { ICalendarImportResult } from './icalendar-import-result';
+export type { PrintingEventArgs } from './printing-event-args';
+export type { PrintedEventArgs } from './printed-event-args';

package/dist/components/scheduler/model/AppointmentStore.d.ts

@@ -0,0 +1,27 @@
+import type { data } from '@motifx-community/data';
+/** Where the store writes: the scheduler's array, or its data source. */
+export interface AppointmentStoreOptions<T> {
+    appointments: () => readonly T[];
+    source: () => data.DataSource<T, unknown> | null;
+    /** The field that holds an appointment's key (for the data source). */
+    keyField: () => string;
+    /** The array, or an appointment in it, changed in place (plain or reactive, it is read again). */
+    changed: (item: T) => void;
+}
+/**
+ * Adds, changes and deletes appointments where they come from: in the array itself (an added one is
+ * pushed, the object given itself; a changed one gets its new values; a deleted one is spliced out),
+ * or through the data source's adapter, whose rows then follow. The array may be plain or reactive.
+ */
+export declare class AppointmentStore<T> {
+    private readonly options;
+    constructor(options: AppointmentStoreOptions<T>);
+    /** Resolves to the appointment as it was saved: in the array, the object given. */
+    add(values: Partial<T>): Promise<T>;
+    update(item: T, changes: Partial<T>): Promise<void>;
+    remove(item: T): Promise<void>;
+    /** The appointments whose `field` holds `value` (the occurrences changed apart from a series): asked of the adapter, so rows not loaded are found too. */
+    rowsNaming(field: string, value: unknown): Promise<T[]>;
+    /** The adapter's key of a row (its own key settings), else the key field. */
+    keyOf(item: T): unknown;
+}

package/dist/components/scheduler/model/ICalendarBridge.d.ts

@@ -0,0 +1,44 @@
+import type { AppointmentEditor } from '../AppointmentEditor';
+import type { ICalendarImportResult } from '../icalendar-import-result';
+import type { SchedulerFields } from '../scheduler-fields';
+import type { SchedulerRange } from '../scheduler-range';
+import type { AppointmentStore } from './AppointmentStore';
+import type { SchedulerModel } from './SchedulerModel';
+/** What the bridge uses of its scheduler. */
+export interface ICalendarBridgeOptions<T> {
+    model: SchedulerModel<T>;
+    store: AppointmentStore<T>;
+    editor: AppointmentEditor<T>;
+    fields: () => SchedulerFields;
+    items: () => readonly T[];
+    timeZone: () => string | null;
+    hasSource: () => boolean;
+}
+/**
+ * Turns appointments into iCalendar events and back (RFC 5545). A timed appointment is written on
+ * its own zone's clock (else the scheduler's, else the browser's) with that zone's `VTIMEZONE`, an
+ * all-day one as dates; a series with its rule (`UNTIL` in UTC, as the RFC asks) and the times left
+ * out; an occurrence changed apart under its series' UID with the time it replaces (`RECURRENCE-ID`:
+ * the left-out time of the series nearest to it). Read back, every event is an appointment's values;
+ * adding them goes through the editor, so the data layer and the events see them as any other.
+ */
+export declare class ICalendarBridge<T> {
+    private readonly options;
+    /** The UID each value read came from, and the series UID of an occurrence changed apart. */
+    private readonly uids;
+    private readonly seriesUids;
+    constructor(options: ICalendarBridgeOptions<T>);
+    /** The appointments with a part in `range` (a series with an occurrence in it), or all of them. */
+    appointmentsIn(range: SchedulerRange | null): T[];
+    write(appointments: readonly T[], name: string): string;
+    /** The values of the appointments a file holds: the series and single ones first, then the occurrences changed apart. */
+    read(text: string): Partial<T>[];
+    /** Adds each appointment (one whose key is there already is changed); an occurrence changed apart names its series by the key it was saved with. */
+    save(appointments: readonly Partial<T>[]): Promise<ICalendarImportResult<T>>;
+    private touches;
+    private eventOf;
+    /** The time an occurrence changed apart replaces: the left-out time of its series nearest to it (not taken by another). */
+    private replaced;
+    /** A date of a file on the wall clock of `zone` (a date only stays one). */
+    private inZone;
+}

package/dist/components/scheduler/model/Occurrences.d.ts

@@ -0,0 +1,39 @@
+import { TimeZone } from '../../../parts/dates/time-zone';
+import type { RecurrenceRule } from '../../../parts/recurrence/recurrence-rule';
+import type { SchedulerFields } from '../scheduler-fields';
+import type { OccurrenceInfo } from './occurrence-info';
+/** What the occurrences read from their scheduler. */
+export interface OccurrencesOptions<T> {
+    fields: () => SchedulerFields;
+    /** The scheduler's time zone: a series without one of its own repeats on its clock. */
+    zone: () => TimeZone;
+    idOf: (item: T) => string;
+}
+/**
+ * The occurrences of the series among the appointments: each a plain object of the kit's with the
+ * series' fields and its own start and end, made once and kept while it is asked for again (so its
+ * box stays the same). A series repeats on the wall clock of its start's time zone (or the
+ * scheduler's), so it keeps its hour over summer time; an all-day series keeps its days. Times in
+ * its exception field are left out. The series' fields are read as they are, plain or reactive.
+ */
+export declare class Occurrences<T> {
+    private readonly options;
+    private readonly rules;
+    private readonly made;
+    private readonly used;
+    /** Where each occurrence comes from. */
+    private readonly info;
+    constructor(options: OccurrencesOptions<T>);
+    /** The rule of a series, or `null` for an appointment that happens once (or whose rule cannot be followed). */
+    ruleOf(item: T): RecurrenceRule | null;
+    /** Where an occurrence comes from; `null` for anything else. */
+    infoOf(item: T): OccurrenceInfo<T> | null;
+    /** The time zone a series repeats in. */
+    zoneOf(item: T): TimeZone;
+    /** The occurrences of a series that start before `to` and may reach `from` (the caller keeps the ones that touch). */
+    of(series: T, from: number, to: number): T[];
+    /** Forgets the occurrences not asked for since the last call (made again when they are). */
+    sweep(): void;
+    /** The occurrence object, kept by its series and start: its fields follow the series' each time it is read. */
+    private make;
+}

package/dist/components/scheduler/model/RecurrenceDraft.d.ts

@@ -0,0 +1,56 @@
+import { TimeZone } from '../../../parts/dates/time-zone';
+import type { RecurrenceFrequency } from '../../../parts/recurrence/recurrence-frequency';
+import type { RecurrenceRule } from '../../../parts/recurrence/recurrence-rule';
+/** A day of the week as the recurrence editor shows it: on or off. */
+export interface DraftDay {
+    /** 0 Sunday … 6 Saturday. */
+    day: number;
+    on: boolean;
+}
+/** What the recurrence editor shows: a rule taken apart into the choices it offers. */
+export interface DraftState {
+    frequency: 'never' | RecurrenceFrequency;
+    interval: number;
+    /** The seven days, from the first day of the week. */
+    days: DraftDay[];
+    /** A month (and a year) repeats on a day of the month, or on a weekday by its place. */
+    by: 'monthDay' | 'weekday';
+    /** 1 … 31, or -1 for the last day. */
+    monthDay: number;
+    /** 1 … 4 the first … fourth, -1 the last. */
+    nth: number;
+    weekday: number;
+    /** 1 January … 12 December. */
+    month: number;
+    end: 'never' | 'count' | 'until';
+    count: number;
+    /** The last day it may happen, a date of the browser's clock. */
+    until: Date | null;
+}
+/** What a rule is read and written for: where it starts, on which clock. */
+export interface DraftContext {
+    /** The start, as a date of the browser's clock with the series' fields. */
+    start: Date | null;
+    /** An all-day series ends on a date; a timed one at the end of that day on its clock. */
+    allDay: boolean;
+    zone: TimeZone;
+    firstDayOfWeek: number;
+}
+/**
+ * A rule as the recurrence editor's choices, and back: `read` takes a rule's text apart (the
+ * start gives what the rule leaves to it), `write` puts the choices together again. Parts the
+ * choices do not cover (`BYSETPOS`, `BYWEEKNO`…) stay as they were until a choice is changed, so a
+ * rule of its own is never rewritten by only being shown.
+ */
+export declare class RecurrenceDraft {
+    readonly state: DraftState;
+    private base;
+    constructor();
+    /** A text of every choice: it changes when (and only when) a choice does. */
+    key(): string;
+    /** The rule the text was read from, when it is one. */
+    get rule(): RecurrenceRule | null;
+    read(text: string, context: DraftContext): void;
+    /** The rule the choices make, as text; empty when it does not repeat. */
+    write(context: DraftContext): string;
+}

package/dist/components/scheduler/model/ResourceKind.d.ts

@@ -0,0 +1,35 @@
+import type { SchedulerResource } from '../scheduler-resource';
+/** An item's own work time; what it leaves out is the scheduler's. */
+export interface OwnWork {
+    start?: number;
+    end?: number;
+    days?: readonly number[];
+}
+/**
+ * A resource kind with its settings decided: its items and how to read them. The items and their
+ * fields are read as they are (plain or reactive alike); a change in place reaches it through the
+ * scheduler's refresh.
+ */
+export declare class ResourceKind<R = unknown> {
+    readonly def: SchedulerResource<R>;
+    private readonly rows;
+    /** The items by their value, made again when the list read is another one. */
+    private indexed;
+    private byValue;
+    constructor(def: SchedulerResource<R>, rows: () => readonly R[]);
+    get field(): string;
+    get label(): string;
+    get multiple(): boolean;
+    get useColorAsDefault(): boolean;
+    /** Its items, as a list of the kit's own (the items themselves in it). Reactive: follows the scheduler's refresh. */
+    get items(): readonly R[];
+    valueOf(item: R): unknown;
+    textOf(item: R): string;
+    colorOf(item: R | undefined): string;
+    /** The value of its item of the kind above it, when the kind says where (`parentExpr`). */
+    parentOf(item: R): unknown;
+    workOf(item: R | undefined): OwnWork;
+    /** The item with this value. */
+    find(value: unknown): R | undefined;
+    private expr;
+}

package/dist/components/scheduler/model/Resources.d.ts

@@ -0,0 +1,53 @@
+import type { SchedulerResource } from '../scheduler-resource';
+import type { ResourceEntry } from './resource-entry';
+import { ResourceKind } from './ResourceKind';
+import type { SchedulerGroup } from './scheduler-group';
+/**
+ * The resource kinds of a scheduler: their items (an array, or a data source loaded once and then
+ * followed), the values an appointment has of each, and the colour they give it. The items and
+ * their fields are read as they are, plain or reactive: a change in place shows after `refresh()`.
+ * Nothing here follows anything: a change is said (`refresh()`, `listChanged()`, a data source's
+ * change) and told to `onChanged` listeners.
+ */
+export declare class Resources {
+    private readonly list;
+    private readonly made;
+    /** Moves on each time the items are to be read again. */
+    private rows;
+    private readonly listeners;
+    /** Each kind's items as read last, and when. */
+    private readonly lastRows;
+    private readonly followed;
+    private stop;
+    constructor(list: () => readonly SchedulerResource<unknown>[]);
+    /** The kinds, in the order given. */
+    kinds(): ResourceKind<unknown>[];
+    kind(field: string): ResourceKind<unknown> | undefined;
+    /** Reads the items again: a change to them in place shows. */
+    refresh(): void;
+    /** The list of kinds was given anew: its data sources are loaded and followed, the rest let go. */
+    listChanged(): void;
+    /** Calls `listener` after the kinds or their items change; returns the function that stops it. */
+    onChanged(listener: () => void): () => void;
+    /** The values an appointment has of a field: a list for a kind with several, one or none otherwise. */
+    valuesOf(item: unknown, field: string): unknown[];
+    /** Every kind's values of an appointment, by field. */
+    allValuesOf(item: unknown): Record<string, unknown[]>;
+    /**
+     * The colour resources give an appointment: of the kind marked `useColorAsDefault`, else of the
+     * first kind whose item has one. In a group, the group's item of that kind.
+     */
+    colorOf(values: Record<string, unknown[]>, group?: SchedulerGroup | null, kinds?: ResourceKind<unknown>[]): string;
+    /** The items of an appointment, by kind, in the kinds' order (the ones it has). */
+    itemsOf(item: unknown): {
+        kind: ResourceKind<unknown>;
+        items: ResourceEntry[];
+    }[];
+    /** Loads each data source once and listens for its changes; call the result to stop. */
+    follow(): () => void;
+    private sources;
+    private changed;
+    /** A kind's items, as a list of the kit's own: read again when the list is another one, or after `refresh()`. */
+    private rowsOf;
+    private sync;
+}