@svgrid/enterprise 3.1.8 → 3.1.9

package/dist/fields/filter-model.js

@@ -0,0 +1,446 @@
+/**
+ * The view bar's filter: conditions on fields, each with the operators that
+ * fit its type ("has any of" for a multiple select, "is within the past
+ * week" for a date), joined by "and" or "or", one level of groups deep.
+ *
+ * It is the grid's advanced filter (`api.setAdvancedFilter`) with its own
+ * expression kind, `fieldFilter`, so it is saved and restored with the rest
+ * of the grid's state.
+ */
+/**
+ * A person condition's value meaning whoever is signed in (`setCurrentUser`)
+ * when the filter runs, so one "My tasks" view works for everyone. With
+ * nobody signed in it matches no one.
+ */
+export const ME = '@me';
+// Who `ME` is. `enableFields` points it at the signed-in user; this module
+// stays free of Svelte state so it runs anywhere (the server runner too).
+let currentUserId = () => undefined;
+export function resolveMeWith(fn) {
+    currentUserId = fn;
+}
+export const isGroup = (c) => Array.isArray(c.conditions);
+const TEXT_TYPES = new Set(['text', 'longText', 'url', 'email', 'phone', 'barcode']);
+const NUMBER_TYPES = new Set(['number', 'currency', 'percent', 'rating', 'duration', 'autoNumber', 'count']);
+const DATE_TYPES = new Set(['date', 'createdTime', 'lastModifiedTime']);
+// Their values are whatever they compute, so the column's cellDataType says what they compare as.
+// A numeric rollup (SUM, COUNT...) has cellDataType 'number'; one without it
+// is a list joined as text (ARRAYJOIN, CONCATENATE), or AND / OR, a checkbox.
+const COMPUTED_TYPES = { formula: 'text', lookup: 'text', rollup: 'text' };
+const BOOLEAN_ROLLUPS = new Set(['AND', 'OR']);
+/** What a column's cellDataType compares as, or null when it does not say. */
+function kindOfData(def) {
+    const d = def.cellDataType;
+    if (d === 'number')
+        return 'number';
+    if (d === 'date' || d === 'dateString')
+        return 'date';
+    if (d === 'boolean')
+        return 'checkbox';
+    return null;
+}
+/**
+ * The kind of comparison a column gets; null for one that cannot be filtered
+ * (a button). A built-in type decides it; a computed type (formula, lookup,
+ * rollup), a type the app registered, and a plain column follow the
+ * column's cellDataType, as the footer summaries do.
+ */
+export function filterKindOf(def) {
+    const t = def.fieldType;
+    if (t === 'button')
+        return null;
+    if (t === 'singleSelect')
+        return 'select';
+    if (t === 'multiSelect')
+        return 'multi';
+    if (t === 'user' || t === 'createdBy' || t === 'lastModifiedBy')
+        return def.fieldProps?.multiple ? 'multi' : 'select';
+    if (t === 'checkbox')
+        return 'checkbox';
+    if (t === 'attachment')
+        return 'files';
+    if (t === 'link')
+        return 'link';
+    if (t && DATE_TYPES.has(t))
+        return 'date';
+    if (t && NUMBER_TYPES.has(t))
+        return 'number';
+    if (t && TEXT_TYPES.has(t))
+        return 'text';
+    if (t === 'rollup' && !def.cellDataType && BOOLEAN_ROLLUPS.has(String(def.fieldProps?.aggregation)))
+        return 'checkbox';
+    // A formula formatted as a number or a date compares as one, as its footer summaries do.
+    const result = t === 'formula' ? def.fieldProps?.result : undefined;
+    if (result === 'number' || result === 'currency' || result === 'percent')
+        return 'number';
+    if (result === 'date')
+        return 'date';
+    return kindOfData(def) ?? (t ? COMPUTED_TYPES[t] : undefined) ?? 'text';
+}
+const EMPTY_OPS = [
+    { op: 'isEmpty', label: 'is empty' },
+    { op: 'isNotEmpty', label: 'is not empty' },
+];
+/** The operators a kind offers, in the order the menu shows them. */
+export function operatorsFor(kind) {
+    switch (kind) {
+        case 'number':
+            return [
+                { op: 'eq', label: '=' },
+                { op: 'neq', label: '≠' },
+                { op: 'lt', label: '<' },
+                { op: 'gt', label: '>' },
+                { op: 'lte', label: '≤' },
+                { op: 'gte', label: '≥' },
+                ...EMPTY_OPS,
+            ];
+        case 'select':
+            return [
+                { op: 'is', label: 'is' },
+                { op: 'isNot', label: 'is not' },
+                { op: 'isAnyOf', label: 'is any of' },
+                { op: 'isNoneOf', label: 'is none of' },
+                ...EMPTY_OPS,
+            ];
+        case 'multi':
+            return [
+                { op: 'hasAnyOf', label: 'has any of' },
+                { op: 'hasAllOf', label: 'has all of' },
+                { op: 'isExactly', label: 'is exactly' },
+                { op: 'hasNoneOf', label: 'has none of' },
+                ...EMPTY_OPS,
+            ];
+        case 'checkbox':
+            return [{ op: 'is', label: 'is' }];
+        case 'date':
+            return [
+                { op: 'is', label: 'is' },
+                { op: 'isBefore', label: 'is before' },
+                { op: 'isAfter', label: 'is after' },
+                { op: 'isOnOrBefore', label: 'is on or before' },
+                { op: 'isOnOrAfter', label: 'is on or after' },
+                { op: 'isWithin', label: 'is within' },
+                ...EMPTY_OPS,
+            ];
+        case 'files':
+            return [{ op: 'contains', label: 'file name contains' }, ...EMPTY_OPS];
+        case 'link':
+        case 'text':
+            return [
+                { op: 'contains', label: 'contains' },
+                { op: 'notContains', label: 'does not contain' },
+                { op: 'is', label: 'is' },
+                { op: 'isNot', label: 'is not' },
+                ...EMPTY_OPS,
+            ];
+    }
+}
+/** The value a new condition starts with for an operator. */
+export function defaultValue(kind, op) {
+    if (op === 'isEmpty' || op === 'isNotEmpty')
+        return undefined;
+    if (kind === 'checkbox')
+        return true;
+    if (kind === 'date')
+        return op === 'isWithin' ? { span: 'pastWeek' } : { mode: 'today' };
+    if (kind === 'select' && (op === 'is' || op === 'isNot'))
+        return '';
+    if (kind === 'select' || kind === 'multi')
+        return [];
+    return '';
+}
+/** A new condition on a column, with its first operator. */
+export function newCondition(column, def) {
+    const kind = filterKindOf(def);
+    if (!kind)
+        return null;
+    const op = operatorsFor(kind)[0].op;
+    const table = kind === 'link' && typeof def.fieldProps?.table === 'string' ? def.fieldProps.table : undefined;
+    return { column, kind, op, value: defaultValue(kind, op), ...(table ? { table } : {}) };
+}
+/** Whether a condition says enough to filter: an empty value is a condition still being written. */
+export function isComplete(c) {
+    if (c.op === 'isEmpty' || c.op === 'isNotEmpty' || c.kind === 'checkbox')
+        return true;
+    const v = c.value;
+    if (v == null)
+        return false;
+    if (Array.isArray(v))
+        return v.length > 0;
+    if (typeof v === 'string')
+        return v.trim() !== '';
+    if (c.kind === 'date' && typeof v === 'object') {
+        const t = v;
+        if (t.mode === 'exactDate')
+            return !!t.date;
+        if (t.span === 'pastDays' || t.span === 'nextDays')
+            return Number(t.days) > 0;
+    }
+    return true;
+}
+/** How many complete conditions a filter has (the view bar's count). */
+export function conditionCount(filter) {
+    if (!filter)
+        return 0;
+    let n = 0;
+    for (const c of filter.conditions) {
+        if (isGroup(c))
+            n += c.conditions.filter(isComplete).length;
+        else if (isComplete(c))
+            n += 1;
+    }
+    return n;
+}
+const fold = (s) => String(s ?? '').trim().toLocaleLowerCase();
+const list = (v) => v == null || v === '' ? [] : Array.isArray(v) ? v.map((x) => String(x && typeof x === 'object' ? (x.id ?? x.name ?? '') : x)) : [String(v)];
+const isBlank = (v) => v == null || v === '' || (Array.isArray(v) && v.length === 0) || (typeof v === 'number' && Number.isNaN(v));
+const DAY = 86400000;
+/** A value's day as a count of local days, or null. */
+export function dayOf(v) {
+    if (v == null || v === '')
+        return null;
+    let d;
+    if (v instanceof Date)
+        d = v;
+    else if (typeof v === 'number')
+        d = new Date(v);
+    else {
+        const s = String(v);
+        // A bare date is that day where the user is, not midnight UTC.
+        const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+        d = m ? new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])) : new Date(s);
+    }
+    if (Number.isNaN(d.getTime()))
+        return null;
+    return Math.floor((d.getTime() - d.getTimezoneOffset() * 60000) / DAY);
+}
+function targetDay(t, today) {
+    switch (t.mode) {
+        case 'today':
+            return today;
+        case 'tomorrow':
+            return today + 1;
+        case 'yesterday':
+            return today - 1;
+        case 'oneWeekAgo':
+            return today - 7;
+        case 'oneWeekFromNow':
+            return today + 7;
+        case 'oneMonthAgo':
+            return today - 30;
+        case 'oneMonthFromNow':
+            return today + 30;
+        case 'exactDate':
+            return dayOf(t.date);
+    }
+}
+function spanDays(s, today) {
+    const n = Math.max(1, Math.floor(Number(s.days) || 1));
+    switch (s.span) {
+        case 'pastWeek':
+            return [today - 7, today];
+        case 'pastMonth':
+            return [today - 30, today];
+        case 'pastYear':
+            return [today - 365, today];
+        case 'nextWeek':
+            return [today, today + 7];
+        case 'nextMonth':
+            return [today, today + 30];
+        case 'nextYear':
+            return [today, today + 365];
+        case 'pastDays':
+            return [today - n, today];
+        case 'nextDays':
+            return [today, today + n];
+    }
+}
+/** One condition as a test of a cell value. */
+export function compileCondition(c, linkNames, now = new Date()) {
+    if (c.op === 'isEmpty')
+        return isBlank;
+    if (c.op === 'isNotEmpty')
+        return (v) => !isBlank(v);
+    switch (c.kind) {
+        case 'number': {
+            const b = Number(c.value);
+            if (!Number.isFinite(b))
+                return () => true;
+            const num = (v) => (isBlank(v) ? NaN : Number(v));
+            const cmp = {
+                eq: (a) => a === b,
+                neq: (a) => a !== b,
+                lt: (a) => a < b,
+                gt: (a) => a > b,
+                lte: (a) => a <= b,
+                gte: (a) => a >= b,
+            };
+            const f = cmp[c.op] ?? (() => true);
+            // An empty cell is no number: it matches only "not equal".
+            return (v) => {
+                const a = num(v);
+                return Number.isNaN(a) ? c.op === 'neq' : f(a);
+            };
+        }
+        case 'checkbox': {
+            const want = c.value !== false;
+            return (v) => !!v === want;
+        }
+        case 'select':
+        case 'multi': {
+            const me = currentUserId();
+            const values = list(c.value).map((x) => (x === ME && me != null ? me : x));
+            const wanted = new Set(values);
+            if (c.op === 'is')
+                return (v) => list(v)[0] === values[0];
+            if (c.op === 'isNot')
+                return (v) => list(v)[0] !== values[0];
+            if (c.op === 'isAnyOf' || c.op === 'hasAnyOf')
+                return (v) => list(v).some((x) => wanted.has(x));
+            if (c.op === 'isNoneOf' || c.op === 'hasNoneOf')
+                return (v) => !list(v).some((x) => wanted.has(x));
+            if (c.op === 'hasAllOf')
+                return (v) => {
+                    const have = new Set(list(v));
+                    return [...wanted].every((x) => have.has(x));
+                };
+            if (c.op === 'isExactly')
+                return (v) => {
+                    const have = new Set(list(v));
+                    return have.size === wanted.size && [...wanted].every((x) => have.has(x));
+                };
+            return () => true;
+        }
+        case 'date': {
+            const today = dayOf(now);
+            if (c.op === 'isWithin') {
+                const [lo, hi] = spanDays((c.value ?? { span: 'pastWeek' }), today);
+                return (v) => {
+                    const d = dayOf(v);
+                    return d != null && d >= lo && d <= hi;
+                };
+            }
+            const t = targetDay((c.value ?? { mode: 'today' }), today);
+            if (t == null)
+                return () => true;
+            const cmp = {
+                is: (d) => d === t,
+                isBefore: (d) => d < t,
+                isAfter: (d) => d > t,
+                isOnOrBefore: (d) => d <= t,
+                isOnOrAfter: (d) => d >= t,
+            };
+            const f = cmp[c.op] ?? (() => true);
+            return (v) => {
+                const d = dayOf(v);
+                return d != null && f(d);
+            };
+        }
+        case 'files': {
+            const needle = fold(c.value);
+            return (v) => (Array.isArray(v) ? v : []).some((a) => fold(a?.name).includes(needle));
+        }
+        case 'link':
+        case 'text': {
+            const needle = fold(c.value);
+            const text = (v) => c.kind === 'link' && c.table && linkNames
+                ? fold(linkNames(c.table, v).join(', '))
+                : fold(Array.isArray(v) ? v.map((x) => (x && typeof x === 'object' ? (x.name ?? '') : x)).join(', ') : v);
+            if (c.op === 'contains')
+                return (v) => text(v).includes(needle);
+            if (c.op === 'notContains')
+                return (v) => !text(v).includes(needle);
+            if (c.op === 'is')
+                return (v) => text(v) === needle;
+            if (c.op === 'isNot')
+                return (v) => text(v) !== needle;
+            return () => true;
+        }
+    }
+}
+/** A whole filter as a row test; incomplete conditions are left out. Null when nothing filters. */
+export function compileFieldFilter(filter, getValue, linkNames, now) {
+    const one = (c) => {
+        const test = compileCondition(c, linkNames, now);
+        return (row) => test(getValue(row, c.column));
+    };
+    const join = (conj, parts) => conj === 'or' ? (row) => parts.some((p) => p(row)) : (row) => parts.every((p) => p(row));
+    const parts = [];
+    for (const c of filter.conditions) {
+        if (isGroup(c)) {
+            const inner = c.conditions.filter(isComplete).map(one);
+            if (inner.length)
+                parts.push(join(c.conjunction, inner));
+        }
+        else if (isComplete(c))
+            parts.push(one(c));
+    }
+    return parts.length ? join(filter.conjunction, parts) : null;
+}
+// ---- As words ---------------------------------------------------------------
+const DAY_WORDS = {
+    today: 'today',
+    tomorrow: 'tomorrow',
+    yesterday: 'yesterday',
+    oneWeekAgo: 'one week ago',
+    oneWeekFromNow: 'one week from now',
+    oneMonthAgo: 'one month ago',
+    oneMonthFromNow: 'one month from now',
+};
+const SPAN_WORDS = {
+    pastWeek: 'the past week',
+    pastMonth: 'the past month',
+    pastYear: 'the past year',
+    nextWeek: 'the next week',
+    nextMonth: 'the next month',
+    nextYear: 'the next year',
+};
+function valueWords(c) {
+    if (c.op === 'isEmpty' || c.op === 'isNotEmpty')
+        return '';
+    if (c.kind === 'checkbox')
+        return c.value === false ? 'unchecked' : 'checked';
+    if (c.kind === 'date') {
+        if (c.op === 'isWithin') {
+            const s = (c.value ?? { span: 'pastWeek' });
+            if (s.span === 'pastDays')
+                return `the past ${s.days ?? 0} days`;
+            if (s.span === 'nextDays')
+                return `the next ${s.days ?? 0} days`;
+            return SPAN_WORDS[s.span] ?? s.span;
+        }
+        const t = (c.value ?? { mode: 'today' });
+        return t.mode === 'exactDate' ? t.date : (DAY_WORDS[t.mode] ?? t.mode);
+    }
+    const word = (v) => (v === ME ? 'me' : String(v));
+    return Array.isArray(c.value) ? c.value.map(word).join(', ') : word(c.value ?? '');
+}
+/** One condition as words: "Status is Done", "Due date is before today". */
+export function describeCondition(c, name = (id) => id) {
+    const op = operatorsFor(c.kind).find((o) => o.op === c.op)?.label ?? c.op;
+    return [name(c.column), op, valueWords(c)].filter(Boolean).join(' ');
+}
+/** A filter as words, groups in parentheses; incomplete conditions are left out. */
+export function describeFieldFilter(filter, name) {
+    const parts = [];
+    for (const c of filter.conditions) {
+        if (isGroup(c)) {
+            const inner = c.conditions.filter(isComplete).map((x) => describeCondition(x, name));
+            if (inner.length)
+                parts.push(inner.length > 1 ? `(${inner.join(` ${c.conjunction} `)})` : inner[0]);
+        }
+        else if (isComplete(c))
+            parts.push(describeCondition(c, name));
+    }
+    return parts.length ? parts.join(` ${filter.conjunction} `) : 'every record';
+}
+/** The columns a filter's complete conditions read, each once. */
+export function fieldFilterColumns(filter) {
+    const out = new Set();
+    for (const c of filter.conditions) {
+        for (const x of isGroup(c) ? c.conditions : [c])
+            if (isComplete(x))
+                out.add(x.column);
+    }
+    return [...out];
+}

package/dist/fields/format.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Display formats for number-like and date fields, as the field editor offers
+ * them: decimal places, which characters separate thousands and decimals, a
+ * large-number abbreviation (1.2K, 3.4M), a currency symbol, duration as
+ * h:mm(:ss(.S)), dates as local / friendly / US / European / ISO with a 12- or
+ * 24-hour time, in local time or one shared time zone.
+ */
+export type Separators = 'local' | 'comma-period' | 'period-comma' | 'space-comma' | 'space-period';
+export type Abbreviation = 'none' | 'thousand' | 'million' | 'billion';
+export type NumberFormatProps = {
+    /** Decimal places, 0..8. */
+    precision?: number;
+    separators?: Separators;
+    /** Group thousands. Default true. */
+    showThousands?: boolean;
+    abbreviation?: Abbreviation;
+};
+export declare function toNumber(value: unknown): number | null;
+/** A number as the field shows it, without a currency symbol or percent sign. */
+export declare function formatNumber(value: number, p: NumberFormatProps): string;
+/** The thousands and decimal characters a field's `separators` setting means. */
+export declare function separatorChars(sep?: Separators): {
+    group: string;
+    decimal: string;
+};
+/**
+ * A number from what someone typed into a number, currency or percent cell,
+ * read with the field's own separators: "$1,200.50", "1.200,50 €" (with
+ * period-comma), "-15%", "2.5k", "3M". The currency symbol, a percent sign and
+ * spaces are ignored; a K, M or B suffix multiplies. Null when it is not a
+ * number.
+ */
+export declare function parseNumberText(text: string, p?: {
+    separators?: Separators;
+    symbol?: string;
+}): number | null;
+export type NumberFieldKind = 'number' | 'currency' | 'percent';
+export type NumberFieldProps = {
+    format?: 'integer' | 'decimal' | 'currency' | 'percent';
+    precision?: number;
+    separators?: Separators;
+    symbol?: string;
+    symbolPosition?: 'before' | 'after';
+    allowNegative?: boolean;
+    points?: boolean;
+};
+/** Which of the three a number field is: its format, or an older currency / percent column's type. */
+export declare function numberKind(fieldType: unknown, p: NumberFieldProps): NumberFieldKind;
+/**
+ * How a number, currency or percent field stores what is typed: `places` to
+ * round the typed number to (an integer field: 0), and `scale` between the
+ * typed number and the stored one (100 for a percent field holding
+ * fractions: 75 typed is 0.75 stored).
+ */
+export declare function numberFieldShape(kind: NumberFieldKind, p: NumberFieldProps): {
+    places: number;
+    scale: number;
+};
+/** The stored value for typed or pasted text: parsed, rounded, scaled. Null when it is not a number. */
+export declare function numberFromText(text: string, kind: NumberFieldKind, p: NumberFieldProps): number | null;
+/**
+ * Round half away from zero, as people do: 2450.555 to 2 places is 2450.56.
+ * toFixed works on the binary value (2450.55499...) and rounds it down.
+ */
+export declare function roundTo(n: number, places: number): number;
+/**
+ * A stored number as the edit box shows it: no grouping, the field's decimal
+ * character, and float noise trimmed (0.1 + 0.2 shows 0.3).
+ */
+export declare function numberEditText(value: number, p?: {
+    separators?: Separators;
+}): string;
+/**
+ * Currency: the symbol before the number with the minus before both
+ * ("-$5.00"), or after it with a space ("-5,00 €").
+ */
+export declare function formatCurrency(value: number, p: NumberFormatProps & {
+    symbol?: string;
+    symbolPosition?: 'before' | 'after';
+}): string;
+/** Percent: `value` is a fraction (0.75 shows 75%) unless `points` says 0..100. */
+export declare function formatPercent(value: number, p: NumberFormatProps & {
+    points?: boolean;
+}): string;
+export type DurationFormat = 'h:mm' | 'h:mm:ss' | 'h:mm:ss.S' | 'h:mm:ss.SS' | 'h:mm:ss.SSS';
+/** Seconds as h:mm, h:mm:ss or h:mm:ss with tenths, hundredths or thousandths. */
+export declare function formatDuration(seconds: number, format?: DurationFormat): string;
+/** "1:30" -> 5400, "1:30:15.5" -> 5415.5, "90" -> 5400 (minutes), "2h 15m" -> 8100. */
+export declare function parseDuration(text: unknown): number | null;
+export type DateFormatName = 'local' | 'friendly' | 'us' | 'european' | 'iso';
+export type DateFieldProps = {
+    dateFormat?: DateFormatName;
+    /** Show the time too. */
+    time?: boolean;
+    timeFormat?: '12hour' | '24hour';
+    /** Show every date in GMT instead of the viewer's time zone. */
+    gmt?: boolean;
+    /** Append the time zone. */
+    showTimeZone?: boolean;
+};
+export declare function toDate(value: unknown): Date | null;
+/**
+ * The date editor's text format (the grid's date-format tokens) for a date
+ * field, so an edit shows the date as the cell does: "MMMM d, yyyy" for
+ * friendly in English, "M/d/yyyy" for US. Local and friendly follow `Intl`,
+ * read from the parts it gives for a sample date.
+ */
+export declare function dateEditTokens(p: DateFieldProps): string;
+export declare function formatDate(value: unknown, p: DateFieldProps): string;