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

package/dist/components/scheduler/view/AppointmentDrag.d.ts

@@ -0,0 +1,66 @@
+import type { Draft } from '../model/draft';
+import type { ResolvedView } from '../model/resolved-view';
+import type { SchedulerModel } from '../model/SchedulerModel';
+/** What is dragged: the whole appointment, or its start or its end. */
+export type DragMode = 'move' | 'start' | 'end';
+/** What the drag uses of its scheduler. */
+export interface DragHost<T> {
+    root(): HTMLElement;
+    scroller(): HTMLElement | null;
+    model: SchedulerModel<T>;
+    view(): ResolvedView;
+    snapMinutes(): number;
+    minDuration(): number;
+    canCopy(): boolean;
+    setDraft(draft: Draft<T> | null): void;
+    /** `false` stops it before it begins. */
+    starting(mode: DragMode, draft: Draft<T>): boolean;
+    /** `false`: it may not go there. */
+    over(mode: DragMode, draft: Draft<T>): boolean;
+    /** Let go: saves it (or not); the draft goes when this settles. */
+    drop(mode: DragMode, draft: Draft<T>): Promise<void>;
+}
+/**
+ * Moves and resizes appointments with the pointer. It builds nothing: while a drag goes on it
+ * writes a draft (where the appointment would go) that the layout shows with the appointment's own
+ * box, and it listens on the document until the pointer is let go. Escape takes it back, Ctrl drops
+ * a copy, the scroll box scrolls near its edges, a finger starts it with a long press.
+ */
+export declare class AppointmentDrag<T> {
+    private readonly host;
+    private press;
+    private draft;
+    private last;
+    private stopScroll;
+    /** The click that ends a drag is not a click on the appointment. */
+    private endedAt;
+    constructor(host: DragHost<T>);
+    /** A drag is going on (a finger's then keeps the page from scrolling). */
+    get active(): boolean;
+    /** Whether a click now is the end of a drag. */
+    get justEnded(): boolean;
+    /**
+     * A press on an appointment (or on one of its edges) in a group: it becomes a drag once the pointer
+     * moves; a finger's once it is held (`now`: a handle, once it moves).
+     */
+    begin(item: T, mode: DragMode, e: PointerEvent, group?: number, now?: boolean): void;
+    /** Stops a drag and takes the appointment back. */
+    cancel(): void;
+    dispose(): void;
+    private onMove;
+    private onUp;
+    private onCancel;
+    private onKey;
+    private start;
+    private stop;
+    /** Works out where the appointment would go for the pointer now, and shows it there. */
+    private follow;
+    private moved;
+    private resized;
+    /** A time on the snap step from the day's start on the clock (`up`: the step that has it, its end). */
+    private snap;
+    /** The cell under a point of the screen: its day, and the time there for a cell of the hours. */
+    private cellAt;
+    /** Near an edge of the scroll box it scrolls, a frame at a time, and the draft follows. */
+    private scrollNearEdges;
+}

package/dist/components/scheduler/view/AppointmentTooltip.d.ts

@@ -0,0 +1,40 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+    /** The appointment shown: the object itself. */
+    item: () => T | null;
+    canEdit: (item: T) => boolean;
+    canDelete: (item: T) => boolean;
+    edit: (item: T) => void;
+    remove: (item: T) => void;
+}
+/**
+ * What a click on an appointment shows: its colour, text, time (and on its own zone's clock), how it repeats, its
+ * resources and its description, with Edit and Delete. Its fields are read as they are; `refresh` shows them again. It
+ * follows nothing: it draws itself when it is made and on `refresh`.
+ */
+export declare class AppointmentTooltip<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private editButton;
+    private deleteButton;
+    private parts;
+    private readonly itemsOf;
+    constructor(props: Props<T>);
+    onConfigured(): void;
+    /** Shows the appointment again: another one, or its fields read again. */
+    refresh(): void;
+    draw(): void;
+    private when;
+    /** How it repeats, or that it was changed apart from its series. */
+    private repeats;
+    /** Its time on its own zone's clock, when that is not the scheduler's. */
+    private ownTime;
+    /** A line per kind of resource it has: the kind's name, then its items with their colours. */
+    private makeLine;
+    private drawLine;
+    /** Its own colour, else its resources'. */
+    private color;
+}
+export {};

package/dist/components/scheduler/view/CellAttributes.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentBase } from '@motifx/core';
+/** A cell's attributes, each written only when it changes. */
+export declare class CellAttributes {
+    private readonly c;
+    constructor(c: ComponentBase);
+    put(name: string, value: string | null): this;
+    flag(name: string, on: boolean): this;
+}

package/dist/components/scheduler/view/CellWriter.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentBase } from '@motifx/core';
+import { CellAttributes } from './CellAttributes';
+/**
+ * The cells of a big grid, written once when they are made and again only when what they show changes: a cell
+ * has no bindings of its own (thousands of them would each follow the same few values), the view calls `writeLook`
+ * or `writeFocus` from one watch of those values, and listens once for all its cells (`placeOf`).
+ */
+export declare class CellWriter<K> {
+    /** Writes what the cell shows: its place, its day and time, its words. */
+    private readonly look;
+    /** Writes whether the keys are on the cell and whether it is selected. */
+    private readonly focus;
+    private readonly cells;
+    private readonly keys;
+    constructor(
+    /** Writes what the cell shows: its place, its day and time, its words. */
+    look: (key: K, cell: CellAttributes) => void, 
+    /** Writes whether the keys are on the cell and whether it is selected. */
+    focus: (key: K, cell: CellAttributes) => void);
+    /** A cell was made: written at once. */
+    add(id: number, key: K, c: ComponentBase): void;
+    /** Every cell went (they are made again). */
+    clear(): void;
+    /** A cell went: let go of it (not of another made for the same place since). */
+    delete(id: number, c: ComponentBase): void;
+    /** Every cell's key, to see which show something else now (`write` them). */
+    forEach(fn: (key: K, id: number) => void): void;
+    /** A cell again, all of it: its key shows something else now. */
+    write(id: number): void;
+    writeLook(): void;
+    /** The focus and the selection again: of every cell, or (`ids`) of those only. */
+    writeFocus(ids?: Iterable<number>): void;
+    /** The cell an event is on (`selector` names the cells). */
+    placeOf(e: Event, selector: string): K | undefined;
+}

package/dist/components/scheduler/view/GroupHeads.d.ts

@@ -0,0 +1,32 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+    /** The columns start after the time ruler (the day views). */
+    ruler: boolean;
+}
+/**
+ * The heads of the groups over the columns: a row per level of resources (the rooms, then the people), each head over
+ * the columns of its item. Under `groupByDate` they stand under the dates (the view orders the rows); a template may
+ * draw a head's content. It follows nothing: its view draws it.
+ */
+export declare class GroupHeads<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private rows;
+    /** The heads of each row. */
+    private readonly cellsOf;
+    private readonly drawn;
+    constructor(props: Props<T>);
+    onConfigured(): void;
+    draw(): void;
+    private makeRow;
+    private drawRow;
+    private makeHead;
+    /** The content: the template's, else a swatch and the text. */
+    private fill;
+    private drawHead;
+    /** What a header template is given: each read reads the head as it is now. */
+    private headerContext;
+}
+export {};

package/dist/components/scheduler/view/KeyedParts.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentBase } from '@motifx/core';
+/**
+ * A list of parts kept by hand, with no binding: `show(items)` makes the parts of keys that came, takes away the
+ * parts of keys that went, keeps the order, and has the parts that stay draw themselves again. The parts sit in
+ * `host` from `start()` on, before whatever comes after them there.
+ */
+export declare class KeyedParts<I, P extends ComponentBase> {
+    private readonly host;
+    private readonly keyOf;
+    private readonly make;
+    private readonly draw;
+    private readonly start;
+    /** A part was taken away (it is disposed). */
+    private readonly gone;
+    private readonly parts;
+    constructor(host: ComponentBase, keyOf: (item: I) => string, make: (item: I) => P, draw: (part: P, item: I) => void, start?: () => number, 
+    /** A part was taken away (it is disposed). */
+    gone?: (part: P, key: string) => void);
+    /** How many parts are shown. */
+    get size(): number;
+    /** The part of a key, if it is shown. */
+    get(key: string): P | undefined;
+    show(items: readonly I[]): void;
+    /** Every part draws itself again. */
+    drawAll(items: readonly I[]): void;
+    clear(): void;
+}

package/dist/components/scheduler/view/MonthView.d.ts

@@ -0,0 +1,58 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+}
+/**
+ * The month view: a row per week, a cell per day of each group (one grid, arrows move by a day and by a week), and over
+ * each week its appointments as bars and chips in lines. Lines past the room a week has become "+N more" on each day
+ * they leave out.
+ *
+ * It follows nothing. The month is small: whatever the model tells, the view draws itself again (each part only what
+ * it shows), as it does on `reState()` and when an option or a text it shows changes.
+ */
+export declare class MonthView<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private grid;
+    private lane;
+    private date;
+    private readonly watch;
+    private parts;
+    private readonly nameDrawn;
+    /** The cells of each week row. */
+    private readonly cellsOf;
+    /** The column each cell and each "+N more" button stands for, as last drawn. */
+    private readonly columnOf;
+    /** The day number of each cell. */
+    private readonly numberOf;
+    private readonly layerOf;
+    /** The cell template the cells were made with: another one makes them again. */
+    private cellTemplate;
+    constructor(props: Props<T>);
+    private get host();
+    onConfigured(): void;
+    onMounted(): void;
+    /** How many lines of appointments fit in a week, under its day numbers. */
+    private measure;
+    /** All of the view, as the model has it now. */
+    draw(): void;
+    private makeParts;
+    /** The weeks' cells, made again for another cell template; the template draws into each cell, after its number. */
+    private makeWeeks;
+    private makeCell;
+    private drawCell;
+    private makeName;
+    /** A weekday head's content: the template's, else the weekday. */
+    private fillName;
+    private drawName;
+    private makeLayer;
+    private drawLayer;
+    private makeMore;
+    private drawMore;
+    /** What a date template is given: each read reads the head as it is now. */
+    private dateContext;
+    /** What a cell template is given: each read reads the column the cell shows now. */
+    private cellContext;
+}
+export {};

package/dist/components/scheduler/view/MoreList.d.ts

@@ -0,0 +1,32 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+/** What the "+N more" list shows: a day and all of its appointments. */
+export interface MoreListState<T> {
+    date: Date | null;
+    items: T[];
+}
+interface Props<T> {
+    host: SchedulerHost<T>;
+    /** The day and its appointments, the objects themselves; the list is drawn again when they change. */
+    state: {
+        value: MoreListState<T>;
+    };
+    choose: (item: T, e: MouseEvent) => void;
+}
+/**
+ * The list that "+N more" opens: the day, then each appointment of it with its time. It follows nothing: the
+ * scheduler draws it when it opens it; an appointment's fields are read as they are.
+ */
+export declare class MoreList<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private title;
+    private items;
+    private readonly itemDrawn;
+    constructor(props: Props<T>);
+    onConfigured(): void;
+    draw(): void;
+    private makeItem;
+    private drawItem;
+}
+export {};

package/dist/components/scheduler/view/SchedulerFormat.d.ts

@@ -0,0 +1,43 @@
+import { TimeZone } from '../../../parts/dates/time-zone';
+import type { SchedulerViewType } from '../scheduler-view-type';
+/**
+ * Dates and times as the scheduler writes them, in its locale and on its clock (`Intl` with its
+ * time zone); the formatters are made once per locale and zone.
+ */
+export declare class SchedulerFormat {
+    private readonly locale;
+    private readonly zone;
+    private made;
+    private formats;
+    /** Time ranges written already (every box writes one, again each time it is drawn). */
+    private ranges;
+    constructor(locale: () => string, zone?: () => TimeZone);
+    /** A formatter on the scheduler's clock (`own`: on another zone's; `'UTC'` for a time of no day). */
+    private get;
+    /** "Mon" */
+    weekday(date: Date): string;
+    /** "Monday" */
+    weekdayLong(date: Date): string;
+    /** "27" */
+    dayNumber(date: Date): string;
+    /** "Monday, 27 October 2026" */
+    fullDate(date: Date): string;
+    /** "October 2026" */
+    monthYear(date: Date): string;
+    /** "October" */
+    month(date: Date): string;
+    /** "27 Oct" */
+    monthDay(date: Date): string;
+    /** "09:00" or "9:00 AM", by the locale; on another zone's clock with `zone`. */
+    time(date: Date, zone?: string): string;
+    /** "09:00 – 10:30" */
+    timeRange(start: Date, end: Date, zone?: string): string;
+    /** "9 AM" or "09", the label of the hour row `minutes` after midnight. */
+    hour(minutes: number): string;
+    /** "GMT+3", the offset of a zone at a moment. */
+    offset(zone: string, at: Date): string;
+    /** A time zone as a picker lists it: "(GMT+3) Europe/Istanbul". */
+    zoneName(zone: string, at: Date): string;
+    /** The text over the view: a day, a range of days or a month. `end` is not included. */
+    range(type: SchedulerViewType, start: Date, end: Date): string;
+}

package/dist/components/scheduler/view/SchedulerTouch.d.ts

@@ -0,0 +1,38 @@
+import type { TouchHost } from './touch-host';
+/**
+ * The scheduler's finger gestures, on its own element with every listener there before a finger
+ * lands (only then can a gesture keep the page still): a swipe sideways over the view goes to the
+ * next or the previous days (a box that can still scroll that way scrolls first), two fingers zoom
+ * the time scale (the hours of the day views, the cells of a timeline), and a drag of an
+ * appointment keeps the page from scrolling. It also marks the scheduler while a finger is in use,
+ * so nothing it touched stays looking hovered, and keeps a long press from opening the page's menu.
+ */
+export declare class SchedulerTouch {
+    private readonly host;
+    private swipe;
+    private pinch;
+    private swipedAt;
+    private finger;
+    constructor(host: TouchHost);
+    /** Whether a click now is the end of a swipe. */
+    get justSwiped(): boolean;
+    /** Listens on the scheduler's element; the function returned stops. */
+    attach(): () => void;
+    private onPointer;
+    private onMenu;
+    private onStart;
+    private onMove;
+    private onEnd;
+    /** Ends a swipe: `next` moves on that way (`true` the next days, `false` the previous ones); `null` goes back. */
+    private stopSwipe;
+    /** A finger moving toward the start (left, or right in a right-to-left page) brings the next days. */
+    private towardNext;
+    private reach;
+    /** Whether the view's scroll box can still scroll toward the next days (or the previous ones). */
+    private canScroll;
+    private startPinch;
+    private movePinch;
+    private stopPinch;
+    /** The view a touch began in, `null` outside it (the bar, a sheet). */
+    private inContent;
+}

package/dist/components/scheduler/view/TimeView.d.ts

@@ -0,0 +1,101 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+}
+/**
+ * The day, week and work week views: the dates on top (with the heads of the groups over them, or under them by date),
+ * the all-day panel under them, then the hours down with a column per day of each group. The cells are one grid
+ * (arrows, Shift to select); the appointments lie over it in their own layer, each placed by its piece. Changing the
+ * date fills the same rows and columns in place. With many groups only the columns in view (and a screen on each side)
+ * are built, each at its own column of the grid.
+ *
+ * It follows nothing: it draws what the model says changed (the focus its cells, the window the parts it shows, the
+ * clock the layer, anything else all of it), on `reState()` and when an option or a text it shows changes.
+ */
+export declare class TimeView<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private headEl;
+    private scroller;
+    private cellsEl;
+    private stopFollow;
+    /** How many columns are built on each side of the ones in view: none at first, more each frame up to a screen. */
+    private side;
+    private stopGrow;
+    private places;
+    private writer;
+    private lit;
+    private ranged;
+    private parts;
+    private readonly dateDrawn;
+    private readonly hourDrawn;
+    /** The column each "+N more" button stands for, as last drawn. */
+    private readonly moreOf;
+    /** The cell template the cells were made with: another one makes them again. */
+    private cellTemplate;
+    constructor(props: Props<T>);
+    private get host();
+    onConfigured(): void;
+    onMounted(): void;
+    onDisposing(): void;
+    private changed;
+    /** All of the view, as the model has it now. */
+    draw(): void;
+    /** The window moved along the columns: the places that show another column, and the parts it shows. */
+    private drawWindow;
+    /** What the window shows of the heads, the all-day bars and the layer. */
+    private drawShown;
+    /** The appointments over the cells, and the line at the time it is now. */
+    private drawLayer;
+    /** The places of the rows' cells, as many as the columns built. */
+    private shownPlaces;
+    /** The rows' cells, made again for another cell template. */
+    private makeCells;
+    /** The rows of cells and the cells in each, one per place. */
+    private drawCells;
+    /** A place's cell; a cell template draws into it once it is made, and follows the column shown there. */
+    private makeCell;
+    private writeLook;
+    /** What decides the column of each place: read once for all of them. */
+    private windowNow;
+    /** The column a place shows: in a big view the window's column that falls on it, else its own. */
+    private columnAt;
+    private placeOf;
+    private idOf;
+    /** The window moved, or the columns changed: the places that show another column now. */
+    private movePlaces;
+    /** The cells the focus left and the one it is on; every cell while a range is selected. */
+    private writeFocus;
+    private focused;
+    private cellTime;
+    private work;
+    /** After a scroll, the window follows at the next frame (once however many scroll events come). */
+    private followSoon;
+    /**
+     * In a big view: builds the columns in view and a screen's worth on each side, and moves on when the view nears their
+     * edge. The first frame builds only the columns in view; the ones on each side come in the frames after it.
+     */
+    private follow;
+    /** After the frame is drawn: half a screen more on each side. */
+    private growSoon;
+    /** The parts that stay for the life of the view; the lists in them are drawn by `draw`. */
+    private makeParts;
+    private makeDate;
+    /** A date head's content: the template's, else the weekday and the number. */
+    private fillDate;
+    private drawDate;
+    private makeHour;
+    /** An hour's content: the template's, else its text. */
+    private fillHour;
+    private drawHour;
+    private makeMore;
+    private drawMore;
+    /** What a date template is given: each read reads the head as it is now. */
+    private dateContext;
+    /** What a time template is given. */
+    private timeContext;
+    /** What a cell template is given: each read reads the column shown at the cell's place now. */
+    private cellContext;
+}
+export {};

package/dist/components/scheduler/view/TimelineLine.d.ts

@@ -0,0 +1,77 @@
+import { Component, type ComponentBase } from '@motifx/core';
+import type { CellTemplateContext } from '../cell-template-context';
+import type { TimelineRow } from '../model/timeline-row';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+    row: TimelineRow<T>;
+    /** Draws each cell's content; decided when the rows are made. */
+    cellTemplate: ((context: CellTemplateContext) => ComponentBase) | null;
+    /** The rows the virtual list keeps off screen (`true`), by the row's own number. */
+    away: Record<number, boolean>;
+}
+/**
+ * A row of a timeline: its group's names on the start side (staying there while the time scrolls), its cells along
+ * the time (only the ones built, each placed at its own cell), and over them its appointments, each on its lane, with
+ * "+N more" per day and the line at the time it is now.
+ *
+ * It follows nothing. It draws itself when it is made, when its view tells it to (`draw`), on `reState()`, and as the
+ * model says: the focus and the selection move, the window moves along the time, the time it is now moves on. A row
+ * the virtual list keeps off screen draws what it missed when it is back.
+ */
+export declare class TimelineLine<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private readonly id;
+    /** Something changed while the row was off screen. */
+    private stale;
+    private ticks;
+    private pieces;
+    private lit;
+    private ranged;
+    private cells;
+    private cellParts;
+    private boxes;
+    private mores;
+    private heads;
+    private now;
+    /** The day each "+N more" button stands for, as last drawn. */
+    private readonly moreOf;
+    /** The header template each head was filled with: another one (another view, another prop) fills it again. */
+    private readonly headTemplates;
+    private row;
+    constructor(props: Props<T>);
+    private get host();
+    /** The key of the row it draws. */
+    get rowKey(): string;
+    /** The row again, after the layout: its place in the model may be another object of the same key. */
+    show(row: TimelineRow<T>): void;
+    onConfigured(): void;
+    onActivated(): void;
+    onDeactivated(): void;
+    /** All of the row, as the model has it now. */
+    draw(): void;
+    /** What the window shows along the time: the cells, the boxes, "+N more", the line at the time it is now. */
+    private drawWindow;
+    private drawNow;
+    private per;
+    private columnOf;
+    private focused;
+    private time;
+    private work;
+    private label;
+    /**
+     * The focus or the selection moved: the cells it left and the one it is on; every cell of the row while a range is
+     * selected on it (a selection stays in its anchor's row).
+     */
+    private writeFocus;
+    private makeCell;
+    /** What a cell template is given: each read reads the cell as it is now. */
+    private cellContext;
+    private makeHead;
+    private fillHead;
+    private drawHead;
+    private makeMore;
+    private drawMore;
+}
+export {};

package/dist/components/scheduler/view/TimelineScale.d.ts

@@ -0,0 +1,22 @@
+import { Component } from '@motifx/core';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+}
+/**
+ * The head of a timeline, standing at the top while the rows scroll: over the resource column the names of the kinds
+ * grouped by, over the cells two tiers (the days over their hours; the months over their days). Only the heads over
+ * the cells built are built; a template may draw a day or an hour. It follows nothing: its view draws it, and the
+ * window moving along the time draws its tiers.
+ */
+export declare class TimelineScale<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private corner;
+    private readonly tiers;
+    constructor(props: Props<T>);
+    onConfigured(): void;
+    draw(): void;
+    private drawTiers;
+}
+export {};

package/dist/components/scheduler/view/TimelineScaleCell.d.ts

@@ -0,0 +1,37 @@
+import { Component } from '@motifx/core';
+import type { ScaleCell } from '../model/scale-cell';
+import type { SchedulerHost } from './scheduler-host';
+interface Props<T> {
+    host: SchedulerHost<T>;
+    cell: ScaleCell;
+    tier: 'upper' | 'lower';
+}
+/**
+ * A head cell of a timeline: a month or a day over the cells (upper tier), a day or an hour (lower tier). It follows
+ * nothing: it draws itself when it is made, when the scale hands it its cell again (`show`), on `reState()` and when an
+ * option or a text it shows changes; a template may draw a day or an hour.
+ */
+export declare class TimelineScaleCell<T> extends Component<HTMLDivElement, Props<T>> {
+    /** Its parts are made (in `onConfigured`): until then a draw has nothing to draw on. */
+    private made;
+    private cell;
+    private content;
+    /** The template the content was filled with: another one (another view, another prop) fills it again. */
+    private template;
+    private readonly texts;
+    constructor(props: Props<T>);
+    /** The cell again, after the window or the layout moved: drawn where it is now. */
+    show(cell: ScaleCell): void;
+    onConfigured(): void;
+    /** The template this cell's kind uses, if any. */
+    private templateNow;
+    /** The content: the template's, else the texts the cell writes (the kind of a cell never changes). */
+    private fill;
+    draw(): void;
+    private span;
+    /** What a date template is given: each read reads the cell as it is now. */
+    private dateContext;
+    /** What a time template is given. */
+    private timeContext;
+}
+export {};