@svgrid/grid 1.2.21 → 1.2.23

package/dist/cell-render.d.ts

@@ -6,6 +6,10 @@ export declare function createCellRender<TFeatures extends TableFeatures = Table
     computeRowClass: (row: Row<TData>, rowIndex: number) => string;
     computeCellClass: (row: Row<TData>, column: Column<TData>) => string;
     computeCellTooltip: (row: Row<TData>, column: Column<TData>) => string | null;
+    computeCellValidity: (row: Row<TData>, column: Column<TData>) => {
+        invalid: boolean;
+        message: string | null;
+    };
     computeCellNote: (row: Row<TData>, column: Column<TData>) => string | null;
     getColumnEditorOptions: (column: Column<TData>, row?: Row<TData> | null) => CellEditorOption[];
     formatListCellValue: (column: Column<TData>, value: unknown, row?: Row<TData> | null) => string;

package/dist/cell-render.js

@@ -5,7 +5,7 @@ import { normalizeEditorOptions, } from "./index";
 import "./sv-grid-scrollbar";
 import { formatNumericWithConfig, getDateFormatter, resolveDatePattern, } from "./cell-formatting";
 import { resolveCellFormat, } from "./conditional-formatting";
-import { resolveClassList, getOptionLabel, asDate, } from "./SvGrid.helpers";
+import { getCellKey, resolveClassList, getOptionLabel, asDate, } from "./SvGrid.helpers";
 import { getPinnedCellValue, } from "./cell-values";
 export function createCellRender(ctx) {
     function cellConditionalFormat(row, column, value) {
@@ -69,6 +69,39 @@ export function createCellRender(ctx) {
         }
         return null;
     }
+    /**
+     * Resolve per-cell validity via the column's declarative `validate` hook.
+     * Runs for every rendered cell so pre-existing bad data is flagged on load.
+     * Returns `{ invalid, message }` - `invalid` drives the red highlight class,
+     * `message` (when present) becomes the cell's tooltip.
+     */
+    function computeCellValidity(row, column) {
+        const rule = column.columnDef.validate;
+        if (typeof rule !== "function")
+            return { invalid: false, message: null };
+        // Read the edit-aware value: inline edits land in `editedCellValues`
+        // (keyed rowId:colId) and are NOT written into the row's memoized value
+        // cache, so `getCellValueByColumnId` would return the stale pre-edit value
+        // and validation would never re-run after an edit. Consult the overlay
+        // first - same rule the display path (getCellDisplayValue) and summaries
+        // use - so a cell re-validates live as the user types.
+        const edited = ctx.editedCellValues ?? {};
+        const key = getCellKey(row.id, column.id);
+        const value = key in edited ? edited[key] : row.getCellValueByColumnId(column.id);
+        const out = rule({
+            value,
+            row: row.original,
+            rowIndex: row.index,
+            column,
+        });
+        // Valid: null / undefined / true. Invalid: false or a message string.
+        if (out == null || out === true)
+            return { invalid: false, message: null };
+        if (out === false)
+            return { invalid: true, message: null };
+        const msg = String(out);
+        return { invalid: true, message: msg.trim() ? msg : null };
+    }
     /**
      * Resolve a per-cell note (a longer comment / annotation). Notes
      * come from the grid's `notes` prop - a `{ [rowId]: { [columnId]: string } }`
@@ -236,6 +269,7 @@ export function createCellRender(ctx) {
         computeRowClass,
         computeCellClass,
         computeCellTooltip,
+        computeCellValidity,
         computeCellNote,
         getColumnEditorOptions,
         formatListCellValue,

package/dist/clipboard.js

@@ -355,6 +355,7 @@ export function createClipboard(ctx) {
         const endCol = Math.max(anchor.colIndex, focus.colIndex);
         const next = ctx.internalData.slice();
         let mutated = false;
+        const changes = [];
         for (let r = startRow; r <= endRow; r += 1) {
             const row = ctx.allRows[r];
             if (!row || isGroupRow(row))
@@ -381,8 +382,18 @@ export function createClipboard(ctx) {
                 // else. parseEditorValue handles the per-type coercion.
                 const editorType = (column.columnDef.editorType ??
                     "text");
-                updated[column.columnDef.field] = parseEditorValue(editorType, "");
+                const field = column.columnDef.field;
+                const oldValue = updated[field];
+                const cleared = parseEditorValue(editorType, "");
+                updated[field] = cleared;
                 rowChanged = true;
+                changes.push({
+                    rowIndex: dataIndex,
+                    columnId: column.id,
+                    oldValue,
+                    newValue: cleared,
+                    row: updated,
+                });
             }
             if (rowChanged) {
                 next[dataIndex] = updated;
@@ -392,6 +403,13 @@ export function createClipboard(ctx) {
         if (mutated) {
             ctx.internalData = next;
             ctx.grid.store.setState((prev) => ({ ...prev }));
+            // Fire onCellValueChange per cleared cell - same as paste's writeCellRaw -
+            // so consumers (formula engines, autosave) recompute. Clear IS a value
+            // change; without this, a HyperFormula-backed grid wouldn't re-evaluate.
+            if (ctx.props.onCellValueChange) {
+                for (const ch of changes)
+                    ctx.props.onCellValueChange(ch);
+            }
         }
         return mutated;
     }

package/dist/collaboration.d.ts

@@ -43,6 +43,8 @@ export type CollabMessage = {
 export type CollabTransport = {
     post(msg: CollabMessage): void;
     subscribe(handler: (msg: CollabMessage) => void): () => void;
+    /** Release any underlying resource (e.g. a BroadcastChannel). Optional. */
+    dispose?(): void;
 };
 export type Collaboration = {
     /** Broadcast where this user's cursor is (or null when it leaves). */

package/dist/collaboration.js

@@ -14,6 +14,9 @@ export function broadcastChannelTransport(name) {
             channel.addEventListener('message', listener);
             return () => channel.removeEventListener('message', listener);
         },
+        dispose() {
+            channel?.close();
+        },
     };
 }
 export function createCollaboration(options) {
@@ -93,6 +96,7 @@ export function createCollaboration(options) {
             unsubscribe();
             if (pruneTimer)
                 clearInterval(pruneTimer);
+            transport.dispose?.(); // release the channel (BroadcastChannel etc.)
         },
     };
 }

package/dist/core.d.ts

@@ -173,7 +173,7 @@ export type ColumnDef<TFeatures extends TableFeatures, TData extends RowData> =
      * and `columnGroupShow: 'closed'` children show until the user expands it.
      */
     openByDefault?: boolean;
-    editorType?: 'text' | 'number' | 'date' | 'datetime' | 'time' | 'password' | 'checkbox' | 'list' | 'chips' | 'select' | 'rich-select' | 'autocomplete' | 'textarea' | 'color' | 'rating';
+    editorType?: 'text' | 'number' | 'date' | 'datetime' | 'time' | 'date-native' | 'datetime-native' | 'time-native' | 'password' | 'checkbox' | 'list' | 'chips' | 'select' | 'rich-select' | 'autocomplete' | 'textarea' | 'color' | 'rating';
     /**
      * Custom in-cell editor. Receives the cell context PLUS a `commit(value)`
      * and `cancel()` helper. Use when none of the built-in `editorType`s fit;
@@ -191,6 +191,27 @@ export type ColumnDef<TFeatures extends TableFeatures, TData extends RowData> =
      * string skips the tooltip.
      */
     tooltip?: string | ((ctx: CellContext<TData>) => string | null | undefined);
+    /**
+     * Declarative per-cell validation (Handsontable-style). Runs for EVERY
+     * rendered cell - including values already present in `data` on load, not
+     * just on edit - so bad data is flagged immediately. Invalid cells get the
+     * `sv-grid-cell-invalid` class (red highlight) and the returned message as
+     * their tooltip.
+     *
+     * Return value:
+     *   - `null` / `undefined` / `true` → valid (no highlight)
+     *   - `false`                       → invalid, no message
+     *   - a non-empty `string`          → invalid, string is the tooltip
+     *
+     * The value keeps rendering as-is (the grid does NOT roll it back); pair
+     * with `onCellValueChange` if you also want to reject the commit.
+     */
+    validate?: (params: {
+        value: unknown;
+        row: TData;
+        rowIndex: number;
+        column: Column<TData>;
+    }) => string | boolean | null | undefined;
     /**
      * Gate editing per column or per cell.
      *

package/dist/countries.d.ts

@@ -0,0 +1,15 @@
+/**
+ * countries - a compact country reference for SvPhoneInput / SvCountryInput.
+ * ISO 3166-1 alpha-2 code, display name, E.164 dial code, and a flag emoji
+ * (derived from the code so no image assets are needed). This is a curated
+ * common-set; extend `COUNTRIES` for full coverage.
+ */
+export type Country = {
+    code: string;
+    name: string;
+    dial: string;
+};
+/** Regional-indicator flag emoji from an ISO alpha-2 code. */
+export declare function flagEmoji(code: string): string;
+export declare const COUNTRIES: Country[];
+export declare const COUNTRY_BY_CODE: Map<string, Country>;

package/dist/countries.js

@@ -0,0 +1,61 @@
+/** Regional-indicator flag emoji from an ISO alpha-2 code. */
+export function flagEmoji(code) {
+    return code
+        .toUpperCase()
+        .replace(/./g, (c) => String.fromCodePoint(127397 + c.charCodeAt(0)));
+}
+export const COUNTRIES = [
+    { code: 'US', name: 'United States', dial: '+1' },
+    { code: 'CA', name: 'Canada', dial: '+1' },
+    { code: 'GB', name: 'United Kingdom', dial: '+44' },
+    { code: 'IE', name: 'Ireland', dial: '+353' },
+    { code: 'FR', name: 'France', dial: '+33' },
+    { code: 'DE', name: 'Germany', dial: '+49' },
+    { code: 'ES', name: 'Spain', dial: '+34' },
+    { code: 'PT', name: 'Portugal', dial: '+351' },
+    { code: 'IT', name: 'Italy', dial: '+39' },
+    { code: 'NL', name: 'Netherlands', dial: '+31' },
+    { code: 'BE', name: 'Belgium', dial: '+32' },
+    { code: 'CH', name: 'Switzerland', dial: '+41' },
+    { code: 'AT', name: 'Austria', dial: '+43' },
+    { code: 'SE', name: 'Sweden', dial: '+46' },
+    { code: 'NO', name: 'Norway', dial: '+47' },
+    { code: 'DK', name: 'Denmark', dial: '+45' },
+    { code: 'FI', name: 'Finland', dial: '+358' },
+    { code: 'PL', name: 'Poland', dial: '+48' },
+    { code: 'CZ', name: 'Czechia', dial: '+420' },
+    { code: 'GR', name: 'Greece', dial: '+30' },
+    { code: 'BG', name: 'Bulgaria', dial: '+359' },
+    { code: 'RO', name: 'Romania', dial: '+40' },
+    { code: 'UA', name: 'Ukraine', dial: '+380' },
+    { code: 'RU', name: 'Russia', dial: '+7' },
+    { code: 'TR', name: 'Turkey', dial: '+90' },
+    { code: 'IL', name: 'Israel', dial: '+972' },
+    { code: 'AE', name: 'United Arab Emirates', dial: '+971' },
+    { code: 'SA', name: 'Saudi Arabia', dial: '+966' },
+    { code: 'IN', name: 'India', dial: '+91' },
+    { code: 'PK', name: 'Pakistan', dial: '+92' },
+    { code: 'CN', name: 'China', dial: '+86' },
+    { code: 'HK', name: 'Hong Kong', dial: '+852' },
+    { code: 'JP', name: 'Japan', dial: '+81' },
+    { code: 'KR', name: 'South Korea', dial: '+82' },
+    { code: 'SG', name: 'Singapore', dial: '+65' },
+    { code: 'MY', name: 'Malaysia', dial: '+60' },
+    { code: 'TH', name: 'Thailand', dial: '+66' },
+    { code: 'ID', name: 'Indonesia', dial: '+62' },
+    { code: 'PH', name: 'Philippines', dial: '+63' },
+    { code: 'VN', name: 'Vietnam', dial: '+84' },
+    { code: 'AU', name: 'Australia', dial: '+61' },
+    { code: 'NZ', name: 'New Zealand', dial: '+64' },
+    { code: 'ZA', name: 'South Africa', dial: '+27' },
+    { code: 'NG', name: 'Nigeria', dial: '+234' },
+    { code: 'EG', name: 'Egypt', dial: '+20' },
+    { code: 'KE', name: 'Kenya', dial: '+254' },
+    { code: 'MA', name: 'Morocco', dial: '+212' },
+    { code: 'BR', name: 'Brazil', dial: '+55' },
+    { code: 'AR', name: 'Argentina', dial: '+54' },
+    { code: 'CL', name: 'Chile', dial: '+56' },
+    { code: 'CO', name: 'Colombia', dial: '+57' },
+    { code: 'MX', name: 'Mexico', dial: '+52' },
+];
+export const COUNTRY_BY_CODE = new Map(COUNTRIES.map((c) => [c.code, c]));

package/dist/datetime/date-core.d.ts

@@ -0,0 +1,88 @@
+/**
+ * date-core - framework-free date math shared by SvCalendar, SvTimePicker and
+ * SvDateTimePicker. No Svelte, no DOM: pure functions over the native `Date`
+ * so it is trivially unit- and mutation-testable and reusable standalone.
+ *
+ * Conventions:
+ * - A "day" is compared by local calendar date (year/month/date), ignoring the
+ *   time-of-day, unless a helper says otherwise.
+ * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
+ *   `firstDayOfWeek`.
+ */
+export type DateLike = Date | number | string;
+/** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
+export declare function toDate(value: DateLike | null | undefined): Date | null;
+/** A new Date at local midnight of the same calendar day (time stripped). */
+export declare function startOfDay(d: Date): Date;
+/** First day (midnight) of the month `d` falls in. */
+export declare function startOfMonth(d: Date): Date;
+/** Last day (midnight) of the month `d` falls in. */
+export declare function endOfMonth(d: Date): Date;
+/** Number of days in the month `d` falls in. */
+export declare function daysInMonth(d: Date): number;
+/**
+ * Start of the week containing `d`, honoring `firstDayOfWeek` (0-6). Returns a
+ * local-midnight Date on or before `d`.
+ */
+export declare function startOfWeek(d: Date, firstDayOfWeek?: number): Date;
+/** True when both dates are the same local calendar day. */
+export declare function isSameDay(a: Date | null, b: Date | null): boolean;
+/** True when both dates are in the same year+month. */
+export declare function isSameMonth(a: Date | null, b: Date | null): boolean;
+/** -1 / 0 / 1 comparison by calendar day (time-of-day ignored). */
+export declare function compareDay(a: Date, b: Date): number;
+/** Add `n` days (can be negative), returning a new Date. */
+export declare function addDays(d: Date, n: number): Date;
+/**
+ * Add `n` calendar months, clamping the day-of-month so 31 Jan + 1 month = 28/29
+ * Feb rather than spilling into March (matches how calendars paginate).
+ */
+export declare function addMonths(d: Date, n: number): Date;
+/** Add `n` years, clamping Feb-29 to Feb-28 on non-leap targets. */
+export declare function addYears(d: Date, n: number): Date;
+/** Clamp `d` to the inclusive [min, max] range (either bound may be null). */
+export declare function clampDate(d: Date, min: Date | null, max: Date | null): Date;
+/**
+ * ISO 8601 week number (1-53) for `d`. Week 1 is the week containing the first
+ * Thursday of the year; weeks start Monday. Independent of `firstDayOfWeek`,
+ * matching Smart's `weekNumbers` column which is always ISO.
+ */
+export declare function isoWeek(d: Date): number;
+/**
+ * The [start, end] years of the decade block that `year` belongs to, as Smart
+ * renders it: a 12-cell page running from the decade start minus 1 to plus 10
+ * (one leading + one trailing year for context). We expose the canonical
+ * decade [Y0, Y0+9] and let the view pad.
+ */
+export declare function decadeRange(year: number): {
+    start: number;
+    end: number;
+};
+/** The [start, end] years of the century block (100-year) `year` belongs to. */
+export declare function centuryRange(year: number): {
+    start: number;
+    end: number;
+};
+export type MonthMatrixCell = {
+    date: Date;
+    /** In the displayed month (vs. leading/trailing days of adjacent months). */
+    inMonth: boolean;
+    /** ISO week number of the row this cell sits in. */
+    week: number;
+};
+/**
+ * Build a month grid of `weeks` rows x 7 columns starting at `firstDayOfWeek`,
+ * padded with the trailing days of the previous month and leading days of the
+ * next so every row is full. `weeks` defaults to 6 (the max any month needs),
+ * matching Smart's fixed-height calendar.
+ */
+export declare function monthMatrix(monthDate: Date, firstDayOfWeek?: number, weeks?: number): MonthMatrixCell[][];
+/**
+ * Ordered weekday indexes (0-6) for a header row starting at `firstDayOfWeek`.
+ * e.g. firstDayOfWeek=1 -> [1,2,3,4,5,6,0].
+ */
+export declare function weekdayOrder(firstDayOfWeek?: number): number[];
+/** Merge a calendar day with a time-of-day taken from `time`, returning a new Date. */
+export declare function withTime(day: Date, time: Date): Date;
+/** Snap a minute value to the nearest lower multiple of `interval` (>=1). */
+export declare function snapMinute(minute: number, interval: number): number;

package/dist/datetime/date-core.js

@@ -0,0 +1,165 @@
+/**
+ * date-core - framework-free date math shared by SvCalendar, SvTimePicker and
+ * SvDateTimePicker. No Svelte, no DOM: pure functions over the native `Date`
+ * so it is trivially unit- and mutation-testable and reusable standalone.
+ *
+ * Conventions:
+ * - A "day" is compared by local calendar date (year/month/date), ignoring the
+ *   time-of-day, unless a helper says otherwise.
+ * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
+ *   `firstDayOfWeek`.
+ */
+/** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
+export function toDate(value) {
+    if (value == null)
+        return null;
+    const d = value instanceof Date ? new Date(value.getTime()) : new Date(value);
+    return isNaN(d.getTime()) ? null : d;
+}
+/** A new Date at local midnight of the same calendar day (time stripped). */
+export function startOfDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}
+/** First day (midnight) of the month `d` falls in. */
+export function startOfMonth(d) {
+    return new Date(d.getFullYear(), d.getMonth(), 1);
+}
+/** Last day (midnight) of the month `d` falls in. */
+export function endOfMonth(d) {
+    return new Date(d.getFullYear(), d.getMonth() + 1, 0);
+}
+/** Number of days in the month `d` falls in. */
+export function daysInMonth(d) {
+    return endOfMonth(d).getDate();
+}
+/**
+ * Start of the week containing `d`, honoring `firstDayOfWeek` (0-6). Returns a
+ * local-midnight Date on or before `d`.
+ */
+export function startOfWeek(d, firstDayOfWeek = 0) {
+    const start = startOfDay(d);
+    const diff = (start.getDay() - firstDayOfWeek + 7) % 7;
+    start.setDate(start.getDate() - diff);
+    return start;
+}
+/** True when both dates are the same local calendar day. */
+export function isSameDay(a, b) {
+    if (!a || !b)
+        return false;
+    return (a.getFullYear() === b.getFullYear() &&
+        a.getMonth() === b.getMonth() &&
+        a.getDate() === b.getDate());
+}
+/** True when both dates are in the same year+month. */
+export function isSameMonth(a, b) {
+    if (!a || !b)
+        return false;
+    return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth();
+}
+/** -1 / 0 / 1 comparison by calendar day (time-of-day ignored). */
+export function compareDay(a, b) {
+    const av = startOfDay(a).getTime();
+    const bv = startOfDay(b).getTime();
+    return av < bv ? -1 : av > bv ? 1 : 0;
+}
+/** Add `n` days (can be negative), returning a new Date. */
+export function addDays(d, n) {
+    const r = new Date(d.getTime());
+    r.setDate(r.getDate() + n);
+    return r;
+}
+/**
+ * Add `n` calendar months, clamping the day-of-month so 31 Jan + 1 month = 28/29
+ * Feb rather than spilling into March (matches how calendars paginate).
+ */
+export function addMonths(d, n) {
+    const day = d.getDate();
+    const r = new Date(d.getFullYear(), d.getMonth() + n, 1, d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+    r.setDate(Math.min(day, daysInMonth(r)));
+    return r;
+}
+/** Add `n` years, clamping Feb-29 to Feb-28 on non-leap targets. */
+export function addYears(d, n) {
+    return addMonths(d, n * 12);
+}
+/** Clamp `d` to the inclusive [min, max] range (either bound may be null). */
+export function clampDate(d, min, max) {
+    if (min && d.getTime() < min.getTime())
+        return new Date(min.getTime());
+    if (max && d.getTime() > max.getTime())
+        return new Date(max.getTime());
+    return d;
+}
+/**
+ * ISO 8601 week number (1-53) for `d`. Week 1 is the week containing the first
+ * Thursday of the year; weeks start Monday. Independent of `firstDayOfWeek`,
+ * matching Smart's `weekNumbers` column which is always ISO.
+ */
+export function isoWeek(d) {
+    // Shift to the Thursday of this week, then count weeks from Jan 1.
+    const date = startOfDay(d);
+    const day = (date.getDay() + 6) % 7; // Mon=0..Sun=6
+    date.setDate(date.getDate() - day + 3); // Thursday of this week
+    const firstThursday = new Date(date.getFullYear(), 0, 4);
+    const firstDay = (firstThursday.getDay() + 6) % 7;
+    firstThursday.setDate(firstThursday.getDate() - firstDay + 3);
+    const diffMs = date.getTime() - firstThursday.getTime();
+    return 1 + Math.round(diffMs / (7 * 24 * 3600 * 1000));
+}
+/**
+ * The [start, end] years of the decade block that `year` belongs to, as Smart
+ * renders it: a 12-cell page running from the decade start minus 1 to plus 10
+ * (one leading + one trailing year for context). We expose the canonical
+ * decade [Y0, Y0+9] and let the view pad.
+ */
+export function decadeRange(year) {
+    const start = Math.floor(year / 10) * 10;
+    return { start, end: start + 9 };
+}
+/** The [start, end] years of the century block (100-year) `year` belongs to. */
+export function centuryRange(year) {
+    const start = Math.floor(year / 100) * 100;
+    return { start, end: start + 99 };
+}
+/**
+ * Build a month grid of `weeks` rows x 7 columns starting at `firstDayOfWeek`,
+ * padded with the trailing days of the previous month and leading days of the
+ * next so every row is full. `weeks` defaults to 6 (the max any month needs),
+ * matching Smart's fixed-height calendar.
+ */
+export function monthMatrix(monthDate, firstDayOfWeek = 0, weeks = 6) {
+    const first = startOfMonth(monthDate);
+    const gridStart = startOfWeek(first, firstDayOfWeek);
+    const rows = [];
+    let cursor = gridStart;
+    for (let r = 0; r < weeks; r++) {
+        const row = [];
+        const weekNo = isoWeek(cursor);
+        for (let c = 0; c < 7; c++) {
+            row.push({
+                date: cursor,
+                inMonth: cursor.getMonth() === first.getMonth() && cursor.getFullYear() === first.getFullYear(),
+                week: weekNo,
+            });
+            cursor = addDays(cursor, 1);
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+/**
+ * Ordered weekday indexes (0-6) for a header row starting at `firstDayOfWeek`.
+ * e.g. firstDayOfWeek=1 -> [1,2,3,4,5,6,0].
+ */
+export function weekdayOrder(firstDayOfWeek = 0) {
+    return Array.from({ length: 7 }, (_, i) => (firstDayOfWeek + i) % 7);
+}
+/** Merge a calendar day with a time-of-day taken from `time`, returning a new Date. */
+export function withTime(day, time) {
+    return new Date(day.getFullYear(), day.getMonth(), day.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
+}
+/** Snap a minute value to the nearest lower multiple of `interval` (>=1). */
+export function snapMinute(minute, interval) {
+    const step = Math.max(1, Math.floor(interval));
+    return Math.floor(minute / step) * step;
+}

package/dist/datetime/date-format.d.ts

@@ -0,0 +1,39 @@
+/**
+ * date-format - a small .NET/Smart-style date format-token engine used for
+ * `formatString` display and for parsing the masked DateTimePicker input. It is
+ * locale-aware for names (month/weekday, AM/PM) via `Intl`, and framework-free.
+ *
+ * Supported tokens (case-sensitive, matching Smart's `formatString`):
+ *   d    dd            day of month           (5, 05)
+ *   ddd  dddd          weekday name           (Mon, Monday)  [locale]
+ *   M    MM            month number           (6, 06)
+ *   MMM  MMMM          month name             (Jun, June)    [locale]
+ *   yy   yyyy          year                   (26, 2026)
+ *   H    HH            hour 24                 (7, 07)
+ *   h    hh            hour 12                 (7, 07)
+ *   m    mm            minute
+ *   s    ss            second
+ *   f    ff   fff      fractional seconds      (tenths..millis)
+ *   t    tt            AM/PM designator        (A, AM)        [locale]
+ *
+ * Anything else is a literal. Wrap literal letters in single quotes ('T') or
+ * escape with a backslash (\T) to keep them out of token matching.
+ */
+type Part = {
+    token: string;
+} | {
+    literal: string;
+};
+/** Split a mask into an ordered list of token / literal parts. */
+export declare function tokenizeMask(mask: string): Part[];
+/** Render `date` per `mask` in `locale`. */
+export declare function formatDate(date: Date, mask: string, locale?: string): string;
+/**
+ * Parse `str` against `mask` in `locale`. Returns a Date or null if the string
+ * does not satisfy the mask. `yearCutoff` disambiguates 2-digit years: values
+ * <= (yearCutoff % 100) map to 2000s, above to 1900s (Smart's default 1926 ->
+ * a 26 pivot). `base` supplies fields the mask omits (defaults to epoch-zero
+ * local midnight so a time-only mask yields a today-agnostic time).
+ */
+export declare function parseDate(str: string, mask: string, locale?: string, yearCutoff?: number, base?: Date): Date | null;
+export {};