@svgrid/grid 1.2.21 → 1.2.23

package/dist/datetime/date-format.js

@@ -0,0 +1,371 @@
+/**
+ * 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.
+ */
+/** Ordered longest-first so the scanner is greedy and unambiguous. */
+const TOKENS = [
+    'dddd', 'ddd', 'dd', 'd',
+    'MMMM', 'MMM', 'MM', 'M',
+    'yyyy', 'yy',
+    'HH', 'H',
+    'hh', 'h',
+    'mm', 'm',
+    'ss', 's',
+    'fff', 'ff', 'f',
+    'tt', 't',
+];
+/** Split a mask into an ordered list of token / literal parts. */
+export function tokenizeMask(mask) {
+    const parts = [];
+    let i = 0;
+    while (i < mask.length) {
+        const ch = mask[i];
+        // Backslash escape: next char is a literal.
+        if (ch === '\\' && i + 1 < mask.length) {
+            parts.push({ literal: mask[i + 1] });
+            i += 2;
+            continue;
+        }
+        // Single-quoted literal run.
+        if (ch === "'") {
+            let j = i + 1;
+            let lit = '';
+            while (j < mask.length && mask[j] !== "'") {
+                lit += mask[j];
+                j++;
+            }
+            parts.push({ literal: lit });
+            i = j + 1; // skip closing quote (or run to end)
+            continue;
+        }
+        // Greedy longest-token match.
+        let matched = null;
+        for (const t of TOKENS) {
+            if (mask.startsWith(t, i)) {
+                matched = t;
+                break;
+            }
+        }
+        if (matched) {
+            parts.push({ token: matched });
+            i += matched.length;
+        }
+        else {
+            parts.push({ literal: ch });
+            i += 1;
+        }
+    }
+    return parts;
+}
+const pad = (n, len) => String(Math.abs(n)).padStart(len, '0');
+// Intl name caches keyed by locale.
+const monthCache = new Map();
+const weekdayCache = new Map();
+const dayperiodCache = new Map();
+function monthNames(locale) {
+    let c = monthCache.get(locale);
+    if (!c) {
+        const long = new Intl.DateTimeFormat(locale, { month: 'long' });
+        const short = new Intl.DateTimeFormat(locale, { month: 'short' });
+        c = {
+            long: Array.from({ length: 12 }, (_, m) => long.format(new Date(2021, m, 1))),
+            short: Array.from({ length: 12 }, (_, m) => short.format(new Date(2021, m, 1))),
+        };
+        monthCache.set(locale, c);
+    }
+    return c;
+}
+function weekdayNames(locale) {
+    let c = weekdayCache.get(locale);
+    if (!c) {
+        const long = new Intl.DateTimeFormat(locale, { weekday: 'long' });
+        const short = new Intl.DateTimeFormat(locale, { weekday: 'short' });
+        // 2021-08-01 is a Sunday.
+        c = {
+            long: Array.from({ length: 7 }, (_, d) => long.format(new Date(2021, 7, 1 + d))),
+            short: Array.from({ length: 7 }, (_, d) => short.format(new Date(2021, 7, 1 + d))),
+        };
+        weekdayCache.set(locale, c);
+    }
+    return c;
+}
+function dayPeriods(locale) {
+    let c = dayperiodCache.get(locale);
+    if (!c) {
+        const f = new Intl.DateTimeFormat(locale, { hour: 'numeric', hour12: true });
+        const am = f.formatToParts(new Date(2021, 0, 1, 9)).find((p) => p.type === 'dayPeriod')?.value ?? 'AM';
+        const pm = f.formatToParts(new Date(2021, 0, 1, 21)).find((p) => p.type === 'dayPeriod')?.value ?? 'PM';
+        c = { am, pm };
+        dayperiodCache.set(locale, c);
+    }
+    return c;
+}
+/** Render `date` per `mask` in `locale`. */
+export function formatDate(date, mask, locale = 'en-US') {
+    const parts = tokenizeMask(mask);
+    const h24 = date.getHours();
+    const h12 = h24 % 12 === 0 ? 12 : h24 % 12;
+    const ms = date.getMilliseconds();
+    let out = '';
+    for (const p of parts) {
+        if ('literal' in p) {
+            out += p.literal;
+            continue;
+        }
+        switch (p.token) {
+            case 'd':
+                out += String(date.getDate());
+                break;
+            case 'dd':
+                out += pad(date.getDate(), 2);
+                break;
+            case 'ddd':
+                out += weekdayNames(locale).short[date.getDay()];
+                break;
+            case 'dddd':
+                out += weekdayNames(locale).long[date.getDay()];
+                break;
+            case 'M':
+                out += String(date.getMonth() + 1);
+                break;
+            case 'MM':
+                out += pad(date.getMonth() + 1, 2);
+                break;
+            case 'MMM':
+                out += monthNames(locale).short[date.getMonth()];
+                break;
+            case 'MMMM':
+                out += monthNames(locale).long[date.getMonth()];
+                break;
+            case 'yy':
+                out += pad(date.getFullYear() % 100, 2);
+                break;
+            case 'yyyy':
+                out += pad(date.getFullYear(), 4);
+                break;
+            case 'H':
+                out += String(h24);
+                break;
+            case 'HH':
+                out += pad(h24, 2);
+                break;
+            case 'h':
+                out += String(h12);
+                break;
+            case 'hh':
+                out += pad(h12, 2);
+                break;
+            case 'm':
+                out += String(date.getMinutes());
+                break;
+            case 'mm':
+                out += pad(date.getMinutes(), 2);
+                break;
+            case 's':
+                out += String(date.getSeconds());
+                break;
+            case 'ss':
+                out += pad(date.getSeconds(), 2);
+                break;
+            case 'f':
+                out += pad(ms, 3).slice(0, 1);
+                break;
+            case 'ff':
+                out += pad(ms, 3).slice(0, 2);
+                break;
+            case 'fff':
+                out += pad(ms, 3);
+                break;
+            case 't':
+                out += (h24 < 12 ? dayPeriods(locale).am : dayPeriods(locale).pm).slice(0, 1);
+                break;
+            case 'tt':
+                out += h24 < 12 ? dayPeriods(locale).am : dayPeriods(locale).pm;
+                break;
+            default: out += p.token;
+        }
+    }
+    return out;
+}
+const MAX_DIGITS = {
+    d: 2, dd: 2, M: 2, MM: 2, yy: 2, yyyy: 4,
+    H: 2, HH: 2, h: 2, hh: 2, m: 2, mm: 2, s: 2, ss: 2, f: 1, ff: 2, fff: 3,
+};
+function readDigits(str, at, max) {
+    let len = 0;
+    while (len < max && at + len < str.length && str[at + len] >= '0' && str[at + len] <= '9')
+        len++;
+    if (len === 0)
+        return null;
+    return { value: parseInt(str.slice(at, at + len), 10), len };
+}
+function matchName(str, at, names) {
+    // Longest-first so 'June' wins over a hypothetical 'Jun' prefix collision.
+    const ordered = names
+        .map((name, index) => ({ name, index }))
+        .sort((a, b) => b.name.length - a.name.length);
+    const lower = str.slice(at).toLowerCase();
+    for (const { name, index } of ordered) {
+        if (name && lower.startsWith(name.toLowerCase()))
+            return { index, len: name.length };
+    }
+    return null;
+}
+/**
+ * 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 function parseDate(str, mask, locale = 'en-US', yearCutoff = 2029, base) {
+    const parts = tokenizeMask(mask);
+    const acc = {};
+    let i = 0;
+    const s = str;
+    for (const p of parts) {
+        if ('literal' in p) {
+            // Literals must match (whitespace-insensitive at the boundary).
+            for (const ch of p.literal) {
+                if (ch === ' ') {
+                    while (s[i] === ' ')
+                        i++;
+                    continue;
+                }
+                if (s[i] !== ch)
+                    return null;
+                i++;
+            }
+            continue;
+        }
+        const tok = p.token;
+        switch (tok) {
+            case 'ddd':
+            case 'dddd': {
+                const m = matchName(s, i, weekdayNames(locale)[tok === 'ddd' ? 'short' : 'long']);
+                if (!m)
+                    return null;
+                i += m.len; // weekday is informational; day-of-month drives the date
+                break;
+            }
+            case 'MMM':
+            case 'MMMM': {
+                const m = matchName(s, i, monthNames(locale)[tok === 'MMM' ? 'short' : 'long']);
+                if (!m)
+                    return null;
+                acc.month = m.index;
+                i += m.len;
+                break;
+            }
+            case 't':
+            case 'tt': {
+                const dp = dayPeriods(locale);
+                const lower = s.slice(i).toLowerCase();
+                if (lower.startsWith(dp.pm.toLowerCase())) {
+                    acc.isPm = true;
+                    i += dp.pm.length;
+                }
+                else if (lower.startsWith(dp.am.toLowerCase())) {
+                    acc.isPm = false;
+                    i += dp.am.length;
+                }
+                else if (lower.startsWith(dp.pm.slice(0, 1).toLowerCase())) {
+                    acc.isPm = true;
+                    i += 1;
+                }
+                else if (lower.startsWith(dp.am.slice(0, 1).toLowerCase())) {
+                    acc.isPm = false;
+                    i += 1;
+                }
+                else
+                    return null;
+                break;
+            }
+            default: {
+                const r = readDigits(s, i, MAX_DIGITS[tok] ?? 2);
+                if (!r)
+                    return null;
+                i += r.len;
+                const v = r.value;
+                switch (tok) {
+                    case 'd':
+                    case 'dd':
+                        acc.day = v;
+                        break;
+                    case 'M':
+                    case 'MM':
+                        acc.month = v - 1;
+                        break;
+                    case 'yy':
+                        acc.year = v <= yearCutoff % 100 ? 2000 + v : 1900 + v;
+                        break;
+                    case 'yyyy':
+                        acc.year = v;
+                        break;
+                    case 'H':
+                    case 'HH':
+                        acc.hour = v;
+                        break;
+                    case 'h':
+                    case 'hh':
+                        acc.hour12 = v;
+                        break;
+                    case 'm':
+                    case 'mm':
+                        acc.minute = v;
+                        break;
+                    case 's':
+                    case 'ss':
+                        acc.second = v;
+                        break;
+                    case 'f':
+                        acc.ms = v * 100;
+                        break;
+                    case 'ff':
+                        acc.ms = v * 10;
+                        break;
+                    case 'fff':
+                        acc.ms = v;
+                        break;
+                }
+            }
+        }
+    }
+    // Trailing input that the mask did not consume is a mismatch.
+    if (i !== s.length && s.slice(i).trim() !== '')
+        return null;
+    const b = base ?? new Date(1970, 0, 1);
+    let hour = acc.hour;
+    if (hour == null && acc.hour12 != null) {
+        hour = acc.hour12 % 12;
+        if (acc.isPm)
+            hour += 12;
+    }
+    const year = acc.year ?? b.getFullYear();
+    const month = acc.month ?? b.getMonth();
+    const day = acc.day ?? b.getDate();
+    const result = new Date(year, month, day, hour ?? b.getHours(), acc.minute ?? b.getMinutes(), acc.second ?? b.getSeconds(), acc.ms ?? b.getMilliseconds());
+    // Reject impossible dates the constructor silently rolls over (e.g. Feb 31).
+    if ((acc.day != null && result.getDate() !== day) ||
+        (acc.month != null && result.getMonth() !== month)) {
+        return null;
+    }
+    return isNaN(result.getTime()) ? null : result;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * date-restrict - predicates for calendar constraints: min/max bounds,
+ * `restrictedDates` (non-selectable), and `importantDates` (highlighted but
+ * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
+ */
+import { type DateLike } from './date-core';
+export type RestrictOptions = {
+    min?: DateLike | null;
+    max?: DateLike | null;
+    /** Individual dates (or predicate) that cannot be selected. */
+    restrictedDates?: ReadonlyArray<DateLike> | ((d: Date) => boolean) | null;
+};
+/** True when `d` is outside the inclusive [min, max] day range. */
+export declare function isOutOfRange(d: Date, min?: DateLike | null, max?: DateLike | null): boolean;
+/** True when `d` is explicitly restricted (by list membership or predicate). */
+export declare function isRestricted(d: Date, restrictedDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null): boolean;
+/**
+ * True when `d` cannot be selected: out of [min, max] OR restricted. This is
+ * the single predicate the calendar/pickers use to disable a day.
+ */
+export declare function isDisabledDay(d: Date, opts: RestrictOptions): boolean;
+/** True when `d` is flagged important (highlighted). Never affects selectability. */
+export declare function isImportant(d: Date, importantDates?: ReadonlyArray<DateLike> | ((day: Date) => boolean) | null): boolean;

package/dist/datetime/date-restrict.js

@@ -0,0 +1,50 @@
+/**
+ * date-restrict - predicates for calendar constraints: min/max bounds,
+ * `restrictedDates` (non-selectable), and `importantDates` (highlighted but
+ * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
+ */
+import { compareDay, isSameDay, toDate } from './date-core';
+function normalizeList(list) {
+    if (!list)
+        return [];
+    const out = [];
+    for (const item of list) {
+        const d = toDate(item);
+        if (d)
+            out.push(d);
+    }
+    return out;
+}
+/** True when `d` is outside the inclusive [min, max] day range. */
+export function isOutOfRange(d, min, max) {
+    const lo = toDate(min ?? null);
+    const hi = toDate(max ?? null);
+    if (lo && compareDay(d, lo) < 0)
+        return true;
+    if (hi && compareDay(d, hi) > 0)
+        return true;
+    return false;
+}
+/** True when `d` is explicitly restricted (by list membership or predicate). */
+export function isRestricted(d, restrictedDates) {
+    if (!restrictedDates)
+        return false;
+    if (typeof restrictedDates === 'function')
+        return restrictedDates(d);
+    return normalizeList(restrictedDates).some((r) => isSameDay(r, d));
+}
+/**
+ * True when `d` cannot be selected: out of [min, max] OR restricted. This is
+ * the single predicate the calendar/pickers use to disable a day.
+ */
+export function isDisabledDay(d, opts) {
+    return isOutOfRange(d, opts.min, opts.max) || isRestricted(d, opts.restrictedDates);
+}
+/** True when `d` is flagged important (highlighted). Never affects selectability. */
+export function isImportant(d, importantDates) {
+    if (!importantDates)
+        return false;
+    if (typeof importantDates === 'function')
+        return importantDates(d);
+    return normalizeList(importantDates).some((r) => isSameDay(r, d));
+}

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

@@ -0,0 +1,25 @@
+export type SelectionMode = 'none' | 'default' | 'one' | 'zeroOrOne' | 'oneExtended' | 'many' | 'zeroOrMany' | 'oneOrMany' | 'week' | 'range';
+export type SelectionModifiers = {
+    ctrl?: boolean;
+    shift?: boolean;
+};
+export type SelectionState = {
+    /** Selected days (deduped, sorted ascending), always local-midnight. */
+    dates: Date[];
+    /** Anchor for shift-extend (oneExtended). */
+    anchor: Date | null;
+    /** Pending range start (range mode, between first and second click). */
+    rangeStart: Date | null;
+};
+export declare const emptySelection: () => SelectionState;
+/** True when `day` is in `dates` (by calendar day). */
+export declare function isSelected(dates: ReadonlyArray<Date>, day: Date): boolean;
+/** Inclusive ordered list of day-midnight dates from a..b (either order). */
+export declare function rangeDays(a: Date, b: Date): Date[];
+/**
+ * Apply a click on `clicked` to `state` under `mode`. `firstDayOfWeek` only
+ * matters for `week` mode. Returns a fresh state (never mutates the input).
+ */
+export declare function selectDate(state: SelectionState, clicked: Date, mode: SelectionMode, modifiers?: SelectionModifiers, firstDayOfWeek?: number): SelectionState;
+/** Whether a mode ever holds more than one date (drives multi-select UI hints). */
+export declare function isMultiSelectMode(mode: SelectionMode): boolean;

package/dist/datetime/date-selection.js

@@ -0,0 +1,94 @@
+/**
+ * date-selection - implements every Smart calendar `selectionMode` as a pure
+ * reducer over the current selection. The calendar component owns pointer/key
+ * handling and delegates the "what gets selected" decision here so the rules
+ * are unit-testable in isolation.
+ */
+import { addDays, compareDay, isSameDay, startOfDay, startOfWeek } from './date-core';
+export const emptySelection = () => ({ dates: [], anchor: null, rangeStart: null });
+/** True when `day` is in `dates` (by calendar day). */
+export function isSelected(dates, day) {
+    return dates.some((d) => isSameDay(d, day));
+}
+/** Inclusive ordered list of day-midnight dates from a..b (either order). */
+export function rangeDays(a, b) {
+    const lo = compareDay(a, b) <= 0 ? startOfDay(a) : startOfDay(b);
+    const hi = compareDay(a, b) <= 0 ? startOfDay(b) : startOfDay(a);
+    const out = [];
+    let cursor = lo;
+    while (compareDay(cursor, hi) <= 0) {
+        out.push(cursor);
+        cursor = addDays(cursor, 1);
+    }
+    return out;
+}
+function sortDedup(dates) {
+    const uniq = [];
+    for (const d of dates)
+        if (!uniq.some((u) => isSameDay(u, d)))
+            uniq.push(startOfDay(d));
+    uniq.sort((a, b) => a.getTime() - b.getTime());
+    return uniq;
+}
+function toggle(dates, day) {
+    return isSelected(dates, day) ? dates.filter((d) => !isSameDay(d, day)) : [...dates, startOfDay(day)];
+}
+/**
+ * Apply a click on `clicked` to `state` under `mode`. `firstDayOfWeek` only
+ * matters for `week` mode. Returns a fresh state (never mutates the input).
+ */
+export function selectDate(state, clicked, mode, modifiers = {}, firstDayOfWeek = 0) {
+    const day = startOfDay(clicked);
+    const single = () => ({ dates: [day], anchor: day, rangeStart: null });
+    switch (mode) {
+        case 'none':
+            return { ...state };
+        case 'default':
+        case 'one':
+            return single();
+        case 'zeroOrOne':
+            // Toggle: clicking the sole selected day clears it.
+            return isSelected(state.dates, day) && state.dates.length === 1
+                ? emptySelection()
+                : single();
+        case 'many':
+        case 'zeroOrMany': {
+            const next = sortDedup(toggle(state.dates, day));
+            return { dates: next, anchor: day, rangeStart: null };
+        }
+        case 'oneOrMany': {
+            const toggled = toggle(state.dates, day);
+            // Never allow emptying below one.
+            const next = toggled.length === 0 ? [day] : toggled;
+            return { dates: sortDedup(next), anchor: day, rangeStart: null };
+        }
+        case 'oneExtended': {
+            if (modifiers.shift && state.anchor) {
+                return { dates: rangeDays(state.anchor, day), anchor: state.anchor, rangeStart: null };
+            }
+            if (modifiers.ctrl) {
+                const toggled = sortDedup(toggle(state.dates, day));
+                return { dates: toggled, anchor: day, rangeStart: null };
+            }
+            return single();
+        }
+        case 'week': {
+            const start = startOfWeek(day, firstDayOfWeek);
+            const days = Array.from({ length: 7 }, (_, i) => addDays(start, i));
+            return { dates: days, anchor: start, rangeStart: null };
+        }
+        case 'range': {
+            // First click sets the start; second click completes the range.
+            if (!state.rangeStart) {
+                return { dates: [day], anchor: day, rangeStart: day };
+            }
+            return { dates: rangeDays(state.rangeStart, day), anchor: state.rangeStart, rangeStart: null };
+        }
+        default:
+            return single();
+    }
+}
+/** Whether a mode ever holds more than one date (drives multi-select UI hints). */
+export function isMultiSelectMode(mode) {
+    return mode === 'many' || mode === 'zeroOrMany' || mode === 'oneOrMany' || mode === 'oneExtended' || mode === 'week' || mode === 'range';
+}

package/dist/datetime/mask.d.ts

@@ -0,0 +1,21 @@
+/**
+ * mask - a tiny pattern-mask engine shared by SvMaskedInput / SvPhoneInput.
+ * Pattern tokens:
+ *   #  a digit (0-9)
+ *   A  a letter (a-z A-Z)
+ *   *  a letter or digit
+ * Any other character is a literal that is auto-inserted. Framework-free.
+ */
+/**
+ * Apply `pattern` to raw input `value`, inserting literals and dropping chars
+ * that don't fit the next token. Returns the formatted string and the count of
+ * consumed input characters (useful for caret math).
+ */
+export declare function applyMask(value: string, pattern: string): {
+    formatted: string;
+    filled: number;
+};
+/** Strip literals, returning only the data characters the user supplied. */
+export declare function unmask(value: string, pattern: string): string;
+/** True when every token position in the pattern is filled. */
+export declare function isMaskComplete(value: string, pattern: string): boolean;

package/dist/datetime/mask.js

@@ -0,0 +1,90 @@
+/**
+ * mask - a tiny pattern-mask engine shared by SvMaskedInput / SvPhoneInput.
+ * Pattern tokens:
+ *   #  a digit (0-9)
+ *   A  a letter (a-z A-Z)
+ *   *  a letter or digit
+ * Any other character is a literal that is auto-inserted. Framework-free.
+ */
+const isDigit = (c) => c >= '0' && c <= '9';
+const isAlpha = (c) => /[a-zA-Z]/.test(c);
+function matches(token, ch) {
+    if (token === '#')
+        return isDigit(ch);
+    if (token === 'A')
+        return isAlpha(ch);
+    if (token === '*')
+        return isDigit(ch) || isAlpha(ch);
+    return false;
+}
+const isToken = (c) => c === '#' || c === 'A' || c === '*';
+/**
+ * Apply `pattern` to raw input `value`, inserting literals and dropping chars
+ * that don't fit the next token. Returns the formatted string and the count of
+ * consumed input characters (useful for caret math).
+ */
+export function applyMask(value, pattern) {
+    let out = '';
+    let vi = 0;
+    let filled = 0;
+    for (let pi = 0; pi < pattern.length; pi++) {
+        const token = pattern[pi];
+        if (!isToken(token)) {
+            // Literal: emit it only once we have (or will have) more input to place.
+            out += token;
+            // Skip a matching literal the user may have typed.
+            if (value[vi] === token)
+                vi++;
+            continue;
+        }
+        // Advance through input until a char fits this token.
+        while (vi < value.length && !matches(token, value[vi]))
+            vi++;
+        if (vi >= value.length)
+            break; // no more input for this token
+        out += value[vi];
+        vi++;
+        filled++;
+    }
+    // Drop any trailing literals with no following data char.
+    return { formatted: trimTrailingLiterals(out), filled };
+}
+function trimTrailingLiterals(out) {
+    // Count how many token-positions are filled; cut the string at the last
+    // filled data char plus any literals strictly before the next token.
+    let lastData = -1;
+    for (let i = 0; i < out.length; i++) {
+        const c = out[i];
+        if (isDigit(c) || isAlpha(c))
+            lastData = i;
+    }
+    if (lastData < 0)
+        return '';
+    // Keep literals that sit between data chars but trim the tail after last data.
+    return out.slice(0, lastData + 1);
+}
+/** Strip literals, returning only the data characters the user supplied. */
+export function unmask(value, pattern) {
+    let out = '';
+    let vi = 0;
+    for (let pi = 0; pi < pattern.length && vi < value.length; pi++) {
+        const token = pattern[pi];
+        if (!isToken(token)) {
+            if (value[vi] === token)
+                vi++;
+            continue;
+        }
+        while (vi < value.length && !matches(token, value[vi]))
+            vi++;
+        if (vi < value.length) {
+            out += value[vi];
+            vi++;
+        }
+    }
+    return out;
+}
+/** True when every token position in the pattern is filled. */
+export function isMaskComplete(value, pattern) {
+    const tokenCount = [...pattern].filter(isToken).length;
+    return unmask(value, pattern).length >= tokenCount;
+}

package/dist/editing.d.ts

@@ -21,7 +21,7 @@ export declare function createEditing<TFeatures extends TableFeatures = TableFea
     cancelFullRowEdit: () => void;
     saveEditingCell: () => void;
     applyHistoryStep: (step: HistoryStep, direction: "undo" | "redo") => void;
-    updateEditingCellValue: (value: string) => void;
+    updateEditingCellValue: (value: unknown) => void;
     onEditorKeyDown: (event: KeyboardEvent) => void;
     focusOnMount: (node: HTMLInputElement | HTMLTextAreaElement) => void;
     onCellDoubleClick: (rowIndex: number, colIndex: number) => void;