@svgrid/enterprise 3.1.21 → 3.1.22

package/dist/designer/index.html

@@ -4,17 +4,17 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>SvGrid Studio - Designer</title>
-    <script type="module" crossorigin src="./assets/index-DLJjuVA4.js"></script>
+    <script type="module" crossorigin src="./assets/index-ICCQKTGR.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-Dd_uD5pT.js">
     <link rel="modulepreload" crossorigin href="./assets/disclose-version-CIm4S9xS.js">
     <link rel="modulepreload" crossorigin href="./assets/cell-formatting-JoxA0t65.js">
     <link rel="modulepreload" crossorigin href="./assets/SvGrid.helpers-BF2QRcNt.js">
     <link rel="modulepreload" crossorigin href="./assets/sv-grid-scrollbar-B9N6Wuj0.js">
+    <link rel="modulepreload" crossorigin href="./assets/grid-extension.svelte-G1ng0xd2.js">
     <link rel="modulepreload" crossorigin href="./assets/editor-contract-Bpoa7A5g.js">
     <link rel="modulepreload" crossorigin href="./assets/date-format-B8JbEtIG.js">
     <link rel="modulepreload" crossorigin href="./assets/list-option-BP_dWS66.js">
     <link rel="modulepreload" crossorigin href="./assets/SvListBox-fn160gSB.js">
-    <link rel="modulepreload" crossorigin href="./assets/grid-extension.svelte-BZ7AqyJI.js">
     <link rel="modulepreload" crossorigin href="./assets/editor-registry-BjP16H0v.js">
     <link rel="modulepreload" crossorigin href="./assets/preload-helper-HclGiUj8.js">
     <link rel="modulepreload" crossorigin href="./assets/popover-CUkLsvRX.js">
@@ -45,7 +45,7 @@
     <link rel="stylesheet" crossorigin href="./assets/SvMenuList-DJ47ba1h.css">
     <link rel="stylesheet" crossorigin href="./assets/SvGridChart-BgLuPO7I.css">
     <link rel="stylesheet" crossorigin href="./assets/SvGridChartPanel-4Pc8y5yO.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-WCxj6WfJ.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-9APkRkTg.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/expressions/compile.js

@@ -21,6 +21,7 @@
  *      constants.
  */
 import { compileExcelFilter } from '@svgrid/grid/filtering';
+import { compileRelativeDateFilter, isRelativeDateOperator } from '../relative-date-core.js';
 import { getPredicateKind } from './kinds.js';
 const num = (v) => typeof v === 'number' ? v : v == null || v === '' ? NaN : Number(v);
 const BUILTINS = {
@@ -258,13 +259,16 @@ function compileInternal(expr, opts, aggs) {
             return test ?? (() => true);
         }
         case 'cmp': {
-            // The needle-side work happens once, here.
-            const test = compileExcelFilter({
-                id: expr.column,
-                operator: expr.op,
-                value: expr.value,
-                valueTo: expr.valueTo,
-            }, { locale: opts.locale });
+            // The needle-side work happens once, here. The relative date operators
+            // are this package's, not the grid's.
+            const test = isRelativeDateOperator(expr.op)
+                ? compileRelativeDateFilter(expr.op)
+                : compileExcelFilter({
+                    id: expr.column,
+                    operator: expr.op,
+                    value: expr.value,
+                    valueTo: expr.valueTo,
+                }, { locale: opts.locale });
             const column = expr.column;
             return (row) => test(opts.getValue(row, column));
         }

package/dist/expressions/evaluate.js

@@ -4,6 +4,7 @@
  * exactly; scalar maths and change detection are handled here.
  */
 import { applyExcelFilter } from '@svgrid/grid/filtering';
+import { compileRelativeDateFilter, isRelativeDateOperator } from '../relative-date-core.js';
 import { getPredicateKind } from './kinds.js';
 function readValue(ctx, row, columnId) {
     if (ctx.getValue)
@@ -168,6 +169,9 @@ export function evaluatePredicate(expr, ctx) {
         case 'not':
             return !evaluatePredicate(expr.expr, ctx);
         case 'cmp':
+            // The relative date operators are this package's, not the grid's.
+            if (isRelativeDateOperator(expr.op))
+                return compileRelativeDateFilter(expr.op)(readValue(ctx, ctx.row, expr.column));
             return applyExcelFilter(readValue(ctx, ctx.row, expr.column), { id: expr.column, operator: expr.op, value: expr.value, valueTo: expr.valueTo }, { locale: ctx.locale });
         case 'scalarCmp':
             return compareScalar(evaluateScalar(expr.left, ctx), expr.op, evaluateScalar(expr.right, ctx));

package/dist/expressions/expression-columns.d.ts

@@ -27,7 +27,10 @@ export declare const OPERATORS: ReadonlyArray<OperatorMeta>;
 export declare function operatorMeta(op: ExcelFilterOperator): OperatorMeta;
 /** Operators valid for a column type (defaults to the text set). */
 export declare function operatorsForType(type: ExprColumnType | undefined): OperatorMeta[];
-/** Whether an operator needs no value input. Delegates to the grid catalogue. */
+/**
+ * Whether an operator needs no value input: the grid catalogue's, or one of
+ * the relative date operators this package adds.
+ */
 export declare function isValueless(op: ExcelFilterOperator): boolean;
 /** Whether an operator takes a multi-value token list. */
 export declare function isSetOperator(op: ExcelFilterOperator): boolean;

package/dist/expressions/expression-columns.js

@@ -16,6 +16,7 @@
 // Imported from the `/filtering` subpath, not the package root: the root would
 // drag SvGrid.svelte into a module that is otherwise pure logic.
 import { isRangeOperator as gridIsRangeOperator, isSetOperator as gridIsSetOperator, isValuelessOperator as gridIsValuelessOperator, } from '@svgrid/grid/filtering';
+import { isRelativeDateOperator } from '../relative-date-core.js';
 const TEXT = ['text'];
 const NUM = ['number'];
 const DATES = ['date', 'datetime'];
@@ -40,11 +41,16 @@ const OPERATOR_PRESENTATION = [
     { value: 'notIn', label: 'Not in', types: ['text', 'number'] },
     { value: 'isBlank', label: 'Is blank', types: ALL },
     { value: 'isNotBlank', label: 'Is not blank', types: ALL },
+    { value: 'today', label: 'Is today', types: DATES },
+    { value: 'beforeToday', label: 'Before today', types: DATES },
+    { value: 'afterToday', label: 'After today', types: DATES },
+    { value: 'next7Days', label: 'In the next 7 days', types: DATES },
+    { value: 'last7Days', label: 'In the last 7 days', types: DATES },
 ];
 /** The full operator catalogue, ordered as the editor should present it. */
 export const OPERATORS = OPERATOR_PRESENTATION.map((op) => ({
     ...op,
-    ...(gridIsValuelessOperator(op.value) ? { valueless: true } : {}),
+    ...(isValueless(op.value) ? { valueless: true } : {}),
     ...(gridIsSetOperator(op.value) ? { set: true } : {}),
     ...(gridIsRangeOperator(op.value) ? { range: true } : {}),
 }));
@@ -58,9 +64,12 @@ export function operatorsForType(type) {
     const t = type ?? 'text';
     return OPERATORS.filter((op) => op.types.includes(t));
 }
-/** Whether an operator needs no value input. Delegates to the grid catalogue. */
+/**
+ * Whether an operator needs no value input: the grid catalogue's, or one of
+ * the relative date operators this package adds.
+ */
 export function isValueless(op) {
-    return gridIsValuelessOperator(op);
+    return gridIsValuelessOperator(op) || isRelativeDateOperator(op);
 }
 /** Whether an operator takes a multi-value token list. */
 export function isSetOperator(op) {

package/dist/expressions/parse.js

@@ -5,7 +5,19 @@ const KEYWORDS = new Set([
     'AND', 'OR', 'NOT', 'TRUE', 'FALSE', 'NULL',
     'CONTAINS', 'STARTSWITH', 'ENDSWITH', 'MATCHES',
     'IN', 'BETWEEN', 'ISBLANK', 'ISNOTBLANK',
+    'ISTODAY', 'BEFORETODAY', 'AFTERTODAY', 'INNEXT7DAYS', 'INLAST7DAYS',
 ]);
+/** The operators that take no value, written after the column: `Due ISTODAY`. */
+const POSTFIX_OPS = {
+    ISBLANK: 'isBlank',
+    ISNOTBLANK: 'isNotBlank',
+    ISTODAY: 'today',
+    BEFORETODAY: 'beforeToday',
+    AFTERTODAY: 'afterToday',
+    INNEXT7DAYS: 'next7Days',
+    INLAST7DAYS: 'last7Days',
+};
+const POSTFIX_KEYWORD = Object.fromEntries(Object.entries(POSTFIX_OPS).map(([kw, op]) => [op, kw]));
 const AGG_KEYWORDS = new Set(['SUM', 'AVG', 'COUNT']);
 function tokenize(input) {
     const tokens = [];
@@ -192,9 +204,10 @@ class Parser {
         const left = this.parseScalar();
         const t = this.peek();
         // Postfix valueless keyword ops.
-        if (this.isKw('ISBLANK') || this.isKw('ISNOTBLANK')) {
-            const op = this.next().value === 'ISBLANK' ? 'isBlank' : 'isNotBlank';
-            return { kind: 'cmp', column: this.expectColumn(left), op };
+        const postfix = t.kind === 'kw' ? POSTFIX_OPS[t.value] : undefined;
+        if (postfix) {
+            this.next();
+            return { kind: 'cmp', column: this.expectColumn(left), op: postfix };
         }
         // Keyword text/set/range ops.
         if (t.kind === 'kw') {
@@ -424,10 +437,9 @@ export function stringifyPredicate(expr, columns = []) {
             return getPredicateKind(expr.type)?.describe?.(expr.payload, (id) => columnLabel(columns, id)) ?? `[${expr.type}]`;
         case 'cmp': {
             const col = columnRefText(columns, expr.column);
-            if (expr.op === 'isBlank')
-                return `${col} ISBLANK`;
-            if (expr.op === 'isNotBlank')
-                return `${col} ISNOTBLANK`;
+            const postfix = POSTFIX_KEYWORD[expr.op];
+            if (postfix)
+                return `${col} ${postfix}`;
             if (expr.op === 'between')
                 return `${col} BETWEEN ${litText(expr.value)} AND ${litText(expr.valueTo)}`;
             if (expr.op === 'in' || expr.op === 'notIn') {

package/dist/filter-labels.d.ts

@@ -0,0 +1,16 @@
+type FacetOption = {
+    value: string;
+    label: string;
+    hint?: string;
+};
+/**
+ * The checklist as the cells show it. Exported for tests and for a custom
+ * menu; `enableFilterLabels` wires it into every grid.
+ */
+export declare function labelFacetOptions(ctrl: any, column: any, options: ReadonlyArray<FacetOption>): FacetOption[];
+/**
+ * Label every grid's filter checklists as their cells show them. Idempotent;
+ * also invoked by {@link installEnterprise}.
+ */
+export declare function enableFilterLabels(): void;
+export {};

package/dist/filter-labels.js

@@ -0,0 +1,83 @@
+/**
+ * Filter checklist labels - the column filter's value list shows each value
+ * the way its cell shows it, while the filter still matches the raw value. A
+ * status stored as MARKED_AS_FAILED and drawn as "Failed" is offered as
+ * "Failed", so a column's accessor can stay the raw value that sorting needs.
+ *
+ * The label comes from the first of these the column has: a `cell` renderer
+ * that returns a string, static `editorOptions` labels, then `formatter` /
+ * `format`. Text values are ordered by label; number and date values stay in
+ * value order. It plugs into the grid's `facetOptions` seam, which runs in the
+ * menu chunk.
+ *
+ * ```ts
+ * import { enableFilterLabels } from '@svgrid/enterprise'
+ * enableFilterLabels()
+ * ```
+ */
+import { columnDataType, registerGridExtension } from '@svgrid/grid';
+import { hasValidLicense } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
+/** The text a cell shows for `raw` in `row`, or null when the column draws markup only. */
+function cellText(ctrl, column, raw, row) {
+    const def = column.columnDef;
+    if (typeof def.cell === 'function') {
+        const rendered = def.cell({
+            cell: { id: `${row.id}_${column.id}`, row, column, getValue: () => raw, getContext: () => ({}) },
+            row,
+            column,
+            table: ctrl.grid,
+            getValue: () => raw,
+        });
+        if (typeof rendered === 'string' || typeof rendered === 'number')
+            return String(rendered);
+    }
+    // Static lists only: a function or promise source would fetch.
+    if (Array.isArray(def.editorOptions))
+        return ctrl.formatListCellValue(column, raw, row);
+    if (def.formatter || def.format)
+        return ctrl.formatCellValue(column, raw, row);
+    return null;
+}
+/**
+ * The checklist as the cells show it. Exported for tests and for a custom
+ * menu; `enableFilterLabels` wires it into every grid.
+ */
+export function labelFacetOptions(ctrl, column, options) {
+    // One row per distinct value, found once per menu open.
+    const wanted = new Set(options.map((o) => o.value));
+    const rowFor = new Map();
+    for (const row of ctrl.grid.getRowModel().rows) {
+        if (rowFor.size === wanted.size)
+            break;
+        const raw = row.getCellValueByColumnId(column.id);
+        const key = String(raw ?? '');
+        if (wanted.has(key) && !rowFor.has(key))
+            rowFor.set(key, { raw, row });
+    }
+    const out = options.map((o) => {
+        const hit = o.value === '' ? undefined : rowFor.get(o.value);
+        const text = hit ? cellText(ctrl, column, hit.raw, hit.row) : null;
+        return text == null ? o : { ...o, label: text };
+    });
+    // Numbers and dates keep value order ("$1,000" would collate before "$200").
+    const type = columnDataType(column.columnDef);
+    if (type === 'number' || type === 'date' || type === 'dateString')
+        return out;
+    return out.sort((a, b) => a.value === '' || b.value === ''
+        ? (a.value === '' ? 0 : 1) - (b.value === '' ? 0 : 1)
+        : a.label.localeCompare(b.label, undefined, { numeric: true }));
+}
+let enabled = false;
+/**
+ * Label every grid's filter checklists as their cells show them. Idempotent;
+ * also invoked by {@link installEnterprise}.
+ */
+export function enableFilterLabels() {
+    if (enabled)
+        return;
+    enabled = true;
+    registerGridExtension({ facetOptions: labelFacetOptions });
+    if (!hasValidLicense())
+        emitUnlicensedNudge();
+}

package/dist/index.d.ts

@@ -12,6 +12,10 @@ export { enableBoardView, SvGridBoard } from './board.js';
 export { enableGalleryView, SvGridGallery } from './gallery.js';
 export * from './gantt/index.js';
 export { enableSelectionBar, SvGridSelectionBar } from './selection-bar.js';
+export { enableRelativeDateFilters, resolveRelativeDateFilter, compileRelativeDateFilter, isRelativeDateOperator, relativeDateOperators, RELATIVE_DATE_OPERATOR_IDS, type RelativeDateOperator, } from './relative-dates.js';
+export { enableFilterLabels, labelFacetOptions } from './filter-labels.js';
+export { enableRowCount, getRowCounts, SvGridRowCount } from './row-count.js';
+export { blanksLast, blanksFirst, type BlanksSortType } from './sort-blanks.js';
 export { applyBulkEdit, bulkEditableFields, bulkEditInitialValues, coerceBulkValue, type BulkEditField, type BulkEditResult } from './bulk-edit.js';
 export { default as SvGridBulkEditDrawer } from './SvGridBulkEditDrawer.svelte';
 export { enablePivot } from './pivot-enable.js';

package/dist/index.js

@@ -33,6 +33,13 @@ export * from './gantt/index.js';
 // the renderer so `<SvGrid selectionBar={...}>` floats a bar over the grid while
 // rows are selected. The prop + its config types live in @svgrid/grid.
 export { enableSelectionBar, SvGridSelectionBar } from './selection-bar.js';
+// Filter and sort additions for every grid (Pro), each through a grid seam so
+// the free grid carries none of it: relative date operators, checklist labels
+// taken from the cells, a status-bar row count, and blanks held at one end.
+export { enableRelativeDateFilters, resolveRelativeDateFilter, compileRelativeDateFilter, isRelativeDateOperator, relativeDateOperators, RELATIVE_DATE_OPERATOR_IDS, } from './relative-dates.js';
+export { enableFilterLabels, labelFacetOptions } from './filter-labels.js';
+export { enableRowCount, getRowCounts, SvGridRowCount } from './row-count.js';
+export { blanksLast, blanksFirst } from './sort-blanks.js';
 // Bulk edit engine behind the bar's `editFields` button - exported so an app
 // can drive the same write from its own UI.
 export { applyBulkEdit, bulkEditableFields, bulkEditInitialValues, coerceBulkValue } from './bulk-edit.js';

package/dist/install.js

@@ -12,6 +12,9 @@ import { enableBoardView } from './board.js';
 import { enableGalleryView } from './gallery.js';
 import { enableGanttView } from './gantt/gantt.js';
 import { enableSelectionBar } from './selection-bar.js';
+import { enableRelativeDateFilters } from './relative-dates.js';
+import { enableFilterLabels } from './filter-labels.js';
+import { enableRowCount } from './row-count.js';
 import { enableAdvancedFilter } from './advanced-filter-enable.js';
 import { enablePivot } from './pivot-enable.js';
 import { registerSheetKeymap } from './sheet-enable.js';
@@ -52,6 +55,11 @@ export function installEnterprise(api) {
     // Register the Gantt view (no-op without the `gantt` prop).
     enableGanttView();
     enableSelectionBar();
+    // Relative date operators, cell-text checklist labels and the status-bar row
+    // count (each a no-op until a grid uses it).
+    enableRelativeDateFilters();
+    enableFilterLabels();
+    enableRowCount();
     // Register the export engine so built-in AI exports (aiExport) can write the
     // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
     registerExportProvider(exportGrid);

package/dist/node/studio.js

@@ -2242,8 +2242,15 @@ var kinds = /* @__PURE__ */ new Map();
 function getPredicateKind(type) {
 	return kinds.get(type);
 }
-//#endregion
-//#region src/expressions/parse.ts
+Object.fromEntries(Object.entries({
+	ISBLANK: "isBlank",
+	ISNOTBLANK: "isNotBlank",
+	ISTODAY: "today",
+	BEFORETODAY: "beforeToday",
+	AFTERTODAY: "afterToday",
+	INNEXT7DAYS: "next7Days",
+	INLAST7DAYS: "last7Days"
+}).map(([kw, op]) => [op, kw]));
 /** Every column id referenced anywhere in a predicate (deduped, in order). */
 function collectColumnRefs(expr) {
 	const out = /* @__PURE__ */ new Set();
@@ -9336,7 +9343,7 @@ var GENERATED_UI_SURFACE = {
 				"key": "statusBar",
 				"label": "Status Bar",
 				"type": "boolean",
-				"description": "Excel-style status bar under the grid showing live aggregates of the selected cell range (count, numeric count, sum, average, min, max). `true` shows the default set; pass `{ aggregates: [...] }` to choose which. Requires `enableCellSelection`.",
+				"description": "Excel-style status bar under the grid showing live aggregates of the selected cell range (count, numeric count, sum, average, min, max). `true` shows the default set; pass `{ aggregates: [...] }` to choose which. The aggregates need `enableCellSelection`. `rows: true` adds a row count that is always shown, \"250 rows\" or \"12 of 250 rows\" while filters hide some, once `@svgrid/enterprise`'s `enableRowCount()` has run. `{ rows: true, aggregates: [] }` shows the count alone.",
 				"group": "common"
 			},
 			{
@@ -16499,7 +16506,7 @@ function hasFieldConditions(schema) {
 *
 * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
 */
-var SVGRID_VERSION = "3.1.21";
+var SVGRID_VERSION = "3.1.22";
 /**
 * The version of `@svgrid/grid`, which releases on its own line: enterprise is
 * on 3.1.x while the grid is on 3.0.x.
@@ -16512,7 +16519,7 @@ var SVGRID_VERSION = "3.1.21";
 *
 * `version.test.ts` asserts this matches packages/grid/package.json.
 */
-var GRID_VERSION = "3.0.20";
+var GRID_VERSION = "3.0.21";
 //#endregion
 //#region src/studio/emit-project.ts
 var has = (blocks, kind) => blocks.some((b) => b.config.kind === kind);

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

@@ -0,0 +1,40 @@
+/**
+ * The relative date operators' semantics, with no grid import: what the
+ * filter menu (relative-dates.ts) and the expression engine both run, so a
+ * server that evaluates expressions loads none of the grid.
+ */
+declare module '@svgrid/grid/filtering' {
+    interface FilterOperatorExtensions {
+        today: true;
+        beforeToday: true;
+        afterToday: true;
+        next7Days: true;
+        last7Days: true;
+    }
+}
+/** The relative date operator ids, in menu order. */
+export declare const RELATIVE_DATE_OPERATOR_IDS: readonly ["today", "beforeToday", "afterToday", "next7Days", "last7Days"];
+export type RelativeDateOperator = (typeof RELATIVE_DATE_OPERATOR_IDS)[number];
+/** Whether `op` is one of the relative date operators. */
+export declare function isRelativeDateOperator(op: string): op is RelativeDateOperator;
+/**
+ * The test for one relative date operator. "Today" is read once, here, so a
+ * page left open past midnight keeps the old day until the filter changes.
+ * A blank or unparseable cell never matches.
+ */
+export declare function compileRelativeDateFilter(op: RelativeDateOperator, now?: Date): (cellValue: unknown) => boolean;
+/**
+ * A relative date filter as the absolute one it means today, for a backend
+ * with no "today" of its own: `beforeToday` becomes `lessThan` today's date,
+ * `next7Days` becomes `between` today and a week out, and so on, with dates as
+ * local 'YYYY-MM-DD'. Any other filter is returned as it is.
+ *
+ * A server data source gets this applied for it. Under `externalFilter` the
+ * `onFiltersChange` payload keeps the relative operator, so a saved view still
+ * means "overdue" tomorrow; call this when you build the query.
+ */
+export declare function resolveRelativeDateFilter<T extends {
+    operator: string;
+    value?: unknown;
+    valueTo?: unknown;
+}>(filter: T, now?: Date): T;

package/dist/relative-date-core.js

@@ -0,0 +1,85 @@
+/** The relative date operator ids, in menu order. */
+export const RELATIVE_DATE_OPERATOR_IDS = ['today', 'beforeToday', 'afterToday', 'next7Days', 'last7Days'];
+const DAY_MS = 86400000;
+/** Whether `op` is one of the relative date operators. */
+export function isRelativeDateOperator(op) {
+    return RELATIVE_DATE_OPERATOR_IDS.includes(op);
+}
+/**
+ * A value as a count of local calendar days, or NaN. A bare 'YYYY-MM-DD' is
+ * that day in local time; `new Date()` would read it as UTC midnight, the day
+ * before anywhere west of Greenwich.
+ */
+function localDayNumber(value) {
+    let d;
+    if (value instanceof Date)
+        d = value;
+    else if (typeof value === 'number')
+        d = new Date(value);
+    else if (typeof value === 'string' && value.trim()) {
+        const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+        d = m ? new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])) : new Date(value);
+    }
+    else
+        return NaN;
+    if (Number.isNaN(d.getTime()))
+        return NaN;
+    return Math.round(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / DAY_MS);
+}
+/** The inclusive range of local day numbers an operator keeps. */
+function dayRange(op, now) {
+    const t = localDayNumber(now);
+    switch (op) {
+        case 'today':
+            return [t, t];
+        case 'beforeToday':
+            return [-Infinity, t - 1];
+        case 'afterToday':
+            return [t + 1, Infinity];
+        case 'next7Days':
+            return [t, t + 7];
+        case 'last7Days':
+            return [t - 7, t];
+    }
+}
+/** Local 'YYYY-MM-DD' for a day number from `localDayNumber`. */
+function isoFromDayNumber(day) {
+    return new Date(day * DAY_MS).toISOString().slice(0, 10);
+}
+/**
+ * The test for one relative date operator. "Today" is read once, here, so a
+ * page left open past midnight keeps the old day until the filter changes.
+ * A blank or unparseable cell never matches.
+ */
+export function compileRelativeDateFilter(op, now = new Date()) {
+    const [lo, hi] = dayRange(op, now);
+    return (cellValue) => {
+        const day = localDayNumber(cellValue);
+        return day >= lo && day <= hi;
+    };
+}
+/**
+ * A relative date filter as the absolute one it means today, for a backend
+ * with no "today" of its own: `beforeToday` becomes `lessThan` today's date,
+ * `next7Days` becomes `between` today and a week out, and so on, with dates as
+ * local 'YYYY-MM-DD'. Any other filter is returned as it is.
+ *
+ * A server data source gets this applied for it. Under `externalFilter` the
+ * `onFiltersChange` payload keeps the relative operator, so a saved view still
+ * means "overdue" tomorrow; call this when you build the query.
+ */
+export function resolveRelativeDateFilter(filter, now = new Date()) {
+    if (!isRelativeDateOperator(filter.operator))
+        return filter;
+    const op = filter.operator;
+    const [lo, hi] = dayRange(op, now);
+    const out = { ...filter };
+    delete out.valueTo;
+    if (op === 'beforeToday')
+        Object.assign(out, { operator: 'lessThan', value: isoFromDayNumber(hi + 1) });
+    else if (op === 'afterToday')
+        Object.assign(out, { operator: 'greaterThan', value: isoFromDayNumber(lo - 1) });
+    else
+        Object.assign(out, { operator: 'between', value: isoFromDayNumber(lo), valueTo: isoFromDayNumber(hi) });
+    return out;
+}

package/dist/relative-dates.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Relative date filters - five date operators measured from today, in whole
+ * local days: Today, Before today (overdue), After today, Next 7 days and
+ * Last 7 days. They take no value, so picking one in a date column's filter
+ * menu filters at once. They plug into the grid's `filterOperators` seam, so a
+ * grid without this module carries none of the code.
+ *
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
+ *
+ * ```ts
+ * import { enableRelativeDateFilters } from '@svgrid/enterprise'
+ * enableRelativeDateFilters()
+ * // then: a column with cellDataType 'date' or 'dateString' offers them
+ * api.setFilter('due', { operator: 'beforeToday' })
+ * ```
+ */
+import { type GridFilterOperator } from '@svgrid/grid';
+import { type RelativeDateOperator } from './relative-date-core.js';
+export { RELATIVE_DATE_OPERATOR_IDS, isRelativeDateOperator, compileRelativeDateFilter, resolveRelativeDateFilter, type RelativeDateOperator, } from './relative-date-core.js';
+/** The operators as the grid's `filterOperators` seam takes them. */
+export declare const relativeDateOperators: Record<RelativeDateOperator, GridFilterOperator>;
+/**
+ * Add the relative date operators to every grid's date filters. Idempotent:
+ * call it once at app start or from each component that uses them. Also
+ * invoked by {@link installEnterprise}.
+ */
+export declare function enableRelativeDateFilters(): void;

package/dist/relative-dates.js

@@ -0,0 +1,61 @@
+/**
+ * Relative date filters - five date operators measured from today, in whole
+ * local days: Today, Before today (overdue), After today, Next 7 days and
+ * Last 7 days. They take no value, so picking one in a date column's filter
+ * menu filters at once. They plug into the grid's `filterOperators` seam, so a
+ * grid without this module carries none of the code.
+ *
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
+ *
+ * ```ts
+ * import { enableRelativeDateFilters } from '@svgrid/enterprise'
+ * enableRelativeDateFilters()
+ * // then: a column with cellDataType 'date' or 'dateString' offers them
+ * api.setFilter('due', { operator: 'beforeToday' })
+ * ```
+ */
+import { getGridExtension, registerGridExtension } from '@svgrid/grid';
+import { hasValidLicense } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
+import { compileRelativeDateFilter, resolveRelativeDateFilter, } from './relative-date-core.js';
+export { RELATIVE_DATE_OPERATOR_IDS, isRelativeDateOperator, compileRelativeDateFilter, resolveRelativeDateFilter, } from './relative-date-core.js';
+const LABELS = {
+    today: 'Today',
+    beforeToday: 'Before today',
+    afterToday: 'After today',
+    next7Days: 'Next 7 days',
+    last7Days: 'Last 7 days',
+};
+function operator(op) {
+    return {
+        label: LABELS[op],
+        types: ['date'],
+        valueless: true,
+        compile: () => compileRelativeDateFilter(op),
+        toServer: (filter) => resolveRelativeDateFilter(filter),
+    };
+}
+/** The operators as the grid's `filterOperators` seam takes them. */
+export const relativeDateOperators = {
+    today: operator('today'),
+    beforeToday: operator('beforeToday'),
+    afterToday: operator('afterToday'),
+    next7Days: operator('next7Days'),
+    last7Days: operator('last7Days'),
+};
+let enabled = false;
+/**
+ * Add the relative date operators to every grid's date filters. Idempotent:
+ * call it once at app start or from each component that uses them. Also
+ * invoked by {@link installEnterprise}.
+ */
+export function enableRelativeDateFilters() {
+    if (enabled)
+        return;
+    enabled = true;
+    // Another module may have added operators of its own; keep them.
+    registerGridExtension({ filterOperators: { ...getGridExtension()?.filterOperators, ...relativeDateOperators } });
+    if (!hasValidLicense())
+        emitUnlicensedNudge();
+}

package/dist/row-count.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Row count - "250 rows", or "12 of 250 rows" while filters hide some, at the
+ * start of the grid's status bar, and the same two numbers from code.
+ *
+ * ```ts
+ * import { enableRowCount, getRowCounts } from '@svgrid/enterprise'
+ * enableRowCount()
+ * // <SvGrid {data} {columns} statusBar={{ rows: true, aggregates: [] }} />
+ * const { total, filtered } = getRowCounts(api)
+ * ```
+ */
+import { type RowData, type SvGridApi, type TableFeatures } from '@svgrid/grid';
+/**
+ * Draw the row count in every grid whose `statusBar` sets `rows: true`.
+ * Idempotent; also invoked by {@link installEnterprise}.
+ */
+export declare function enableRowCount(): void;
+/**
+ * How many rows the grid holds (`total`) and how many pass the current
+ * filters (`filtered`), for an "X of Y" of your own. Pagination changes
+ * neither. With grouping on, `filtered` counts the group rows too. Under
+ * `externalPagination` both come from the `rowCount` you pass.
+ */
+export declare function getRowCounts<TFeatures extends TableFeatures, TData extends RowData>(api: SvGridApi<TFeatures, TData>): {
+    total: number;
+    filtered: number;
+};
+export { default as SvGridRowCount } from './SvGridRowCount.svelte';