@svgrid/enterprise 3.1.1 → 3.1.2

package/dist/sveltekit/in-memory.js

@@ -2,13 +2,16 @@ import { resolveIdField } from '../schema.js';
 import { planQuery } from './query-plan.js';
 import { compilePredicate } from '../expressions/compile.js';
 import { aggregateRows } from '../sources/aggregate.js';
-function asString(v) {
+// asString, matchesPredicate and sortRows are exported for the columnar
+// engine behind the worker data source, which must answer exactly as this
+// reference does. They are not part of the package API.
+export function asString(v) {
     return v == null ? '' : String(v);
 }
 function num(v) {
     return typeof v === 'number' ? v : Number(v);
 }
-function matchesPredicate(row, p) {
+export function matchesPredicate(row, p) {
     const cell = row[p.field];
     switch (p.op) {
         case 'eq':
@@ -103,28 +106,42 @@ function grandTotalOf(all, plan, expression) {
 function aggregate(rows, field, fn) {
     if (fn === 'count')
         return rows.length;
-    const nums = [];
+    // One pass, no spread: `Math.min(...nums)` throws a RangeError once a
+    // group holds more than about 150,000 values (V8's argument limit).
+    let count = 0;
+    let sum = 0;
+    let min = Infinity;
+    let max = -Infinity;
     for (const row of rows) {
         const n = Number(row[field]);
-        if (Number.isFinite(n))
-            nums.push(n);
+        if (!Number.isFinite(n))
+            continue;
+        count += 1;
+        sum += n;
+        if (n < min)
+            min = n;
+        if (n > max)
+            max = n;
     }
-    if (nums.length === 0)
+    if (count === 0)
         return null;
     switch (fn) {
         case 'sum':
-            return nums.reduce((s, n) => s + n, 0);
+            return sum;
         case 'avg':
-            return nums.reduce((s, n) => s + n, 0) / nums.length;
+            return sum / count;
         case 'min':
-            return Math.min(...nums);
+            return min;
         case 'max':
-            return Math.max(...nums);
+            return max;
         default:
             return null;
     }
 }
-function sortRows(rows, orderBy) {
+// What `localeCompare` with no arguments does, without building a collator
+// per comparison - which is most of the cost of sorting a large array.
+const collator = new Intl.Collator();
+export function sortRows(rows, orderBy) {
     if (orderBy.length === 0)
         return rows;
     // Stable multi-key sort: decorate with index, compare keys in order, fall back to index.
@@ -138,7 +155,7 @@ function sortRows(rows, orderBy) {
             if (typeof av === 'number' && typeof bv === 'number')
                 cmp = av - bv;
             else
-                cmp = asString(av).localeCompare(asString(bv));
+                cmp = collator.compare(asString(av), asString(bv));
             if (cmp !== 0)
                 return desc ? -cmp : cmp;
         }
@@ -146,106 +163,137 @@ function sortRows(rows, orderBy) {
     })
         .map((d) => d.row);
 }
-export function createInMemoryDataSource(initial, schema) {
+/** Results kept by `cacheResults`: a handful of sort / filter / group states. */
+const RESULT_CACHE_SIZE = 8;
+export function createInMemoryDataSource(initial, schema, options = {}) {
     let store = [...initial];
     const idField = resolveIdField(schema);
-    return {
-        async getRows(request) {
-            const plan = planQuery(schema, request);
-            let filtered = store.filter((r) => matches(r, plan));
-            // Advanced filter. `planQuery` only admits an expression whose columns
-            // are all on the schema, so reaching here means it is safe to run. If it
-            // was rejected, or fails to compile, we must NOT acknowledge it - the
-            // grid then tells the user the filter did not run rather than showing a
-            // superset that looks filtered.
-            let appliedExpression = false;
-            let expressionPredicate = null;
-            if (plan.expression) {
-                const predicate = compilePredicate(plan.expression, {
-                    getValue: (row, columnId) => row[columnId],
-                    rows: filtered,
-                });
-                if (predicate) {
-                    filtered = filtered.filter(predicate);
-                    expressionPredicate = predicate;
-                    appliedExpression = true;
-                }
+    // Every write reassigns `store`, so a cache filled from an older array is
+    // stale by identity alone.
+    const cache = new Map();
+    let cacheStore = null;
+    function prepare(plan) {
+        if (!options.cacheResults)
+            return run(plan);
+        if (cacheStore !== store) {
+            cache.clear();
+            cacheStore = store;
+        }
+        // The range is the only part of a plan that does not change the result.
+        const key = JSON.stringify({ ...plan, limit: 0, offset: 0 });
+        const hit = cache.get(key);
+        if (hit) {
+            // Re-insert so the Map's order is least-recently used first.
+            cache.delete(key);
+            cache.set(key, hit);
+            return hit;
+        }
+        const prepared = run(plan);
+        cache.set(key, prepared);
+        if (cache.size > RESULT_CACHE_SIZE)
+            cache.delete(cache.keys().next().value);
+        return prepared;
+    }
+    function run(plan) {
+        let filtered = store.filter((r) => matches(r, plan));
+        // Advanced filter. `planQuery` only admits an expression whose columns
+        // are all on the schema, so reaching here means it is safe to run. If it
+        // was rejected, or fails to compile, we must NOT acknowledge it - the
+        // grid then tells the user the filter did not run rather than showing a
+        // superset that looks filtered.
+        let appliedExpression = false;
+        let expressionPredicate = null;
+        if (plan.expression) {
+            const predicate = compilePredicate(plan.expression, {
+                getValue: (row, columnId) => row[columnId],
+                rows: filtered,
+            });
+            if (predicate) {
+                filtered = filtered.filter(predicate);
+                expressionPredicate = predicate;
+                appliedExpression = true;
             }
-            // The grand total spans everything the FILTERS admit - the whole
-            // store minus the filters and the expression, but NOT minus the group
-            // path, which only scopes this request.
-            const grandTotal = plan.grandTotal
-                ? { grandTotal: grandTotalOf(store, plan, expressionPredicate) }
-                : {};
-            // Grouped request: return one row per distinct key at this level, each
-            // carrying the requested aggregates. The chosen path is already in
-            // `plan.where`, so `filtered` is exactly this group's slice of the data.
-            // Reference behaviour for what a SQL backend does with `planToSql`'s
-            // `select` / `groupByText` / `countText`.
-            if (plan.groupBy) {
-                const groupField = plan.groupBy;
-                const buckets = new Map();
-                for (const row of filtered) {
-                    const key = asString(row[groupField]);
-                    const bucket = buckets.get(key);
-                    if (bucket)
-                        bucket.push(row);
-                    else
-                        buckets.set(key, [row]);
-                }
-                // Pivoting: every aggregate is computed once per distinct pivot key
-                // path inside the group, under a field named from the path, and the
-                // field list goes back so the grid can build the columns.
-                const pivotPaths = new Set();
-                const groups = [...buckets.entries()].map(([key, rows]) => {
-                    const out = { [groupField]: key };
-                    aggregateInto(out, rows, plan, pivotPaths);
-                    // What opening this group would show: distinct keys of the next
-                    // level, or the rows themselves at the innermost group level.
-                    out.childCount = plan.childGroupBy
-                        ? new Set(rows.map((r) => asString(r[plan.childGroupBy]))).size
-                        : rows.length;
-                    return out;
-                });
-                // The pivoted fields in a fixed order - key paths in plain string
-                // order, aggregations as requested under each - so the grid builds
-                // the same columns whatever order the groups came in. Every group
-                // row carries every field; a cell with no rows under it is null, the
-                // way a conditional aggregate answers in SQL.
-                const pivotFields = [...pivotPaths]
-                    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
-                    .flatMap((path) => (plan.aggregations ?? []).map((agg) => `${path}_${agg.field}`));
-                for (const g of groups) {
-                    for (const f of pivotFields)
-                        if (!(f in g))
-                            g[f] = null;
-                }
-                // Sort by the group key unless the request sorted on a column we
-                // actually produced (the key or an aggregate).
-                const produced = new Set([
-                    groupField,
-                    ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
-                ]);
-                const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
-                const sorted = groupOrder.length
-                    ? sortRows(groups, groupOrder)
-                    : sortRows(groups, [{ field: groupField, desc: false }]);
-                return {
-                    rows: sorted.slice(plan.offset, plan.offset + plan.limit),
-                    // The count is DISTINCT GROUPS, not underlying rows - the grid sizes
-                    // its scrollbar and paging from this.
-                    rowCount: sorted.length,
-                    appliedExpression,
-                    ...grandTotal,
-                    ...(plan.pivotBy?.length ? { pivotResultFields: pivotFields } : {}),
-                };
+        }
+        // The grand total spans everything the FILTERS admit - the whole
+        // store minus the filters and the expression, but NOT minus the group
+        // path, which only scopes this request.
+        const grandTotal = plan.grandTotal
+            ? { grandTotal: grandTotalOf(store, plan, expressionPredicate) }
+            : {};
+        // Grouped request: return one row per distinct key at this level, each
+        // carrying the requested aggregates. The chosen path is already in
+        // `plan.where`, so `filtered` is exactly this group's slice of the data.
+        // Reference behaviour for what a SQL backend does with `planToSql`'s
+        // `select` / `groupByText` / `countText`.
+        if (plan.groupBy) {
+            const groupField = plan.groupBy;
+            const buckets = new Map();
+            for (const row of filtered) {
+                const key = asString(row[groupField]);
+                const bucket = buckets.get(key);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    buckets.set(key, [row]);
+            }
+            // Pivoting: every aggregate is computed once per distinct pivot key
+            // path inside the group, under a field named from the path, and the
+            // field list goes back so the grid can build the columns.
+            const pivotPaths = new Set();
+            const groups = [...buckets.entries()].map(([key, rows]) => {
+                const out = { [groupField]: key };
+                aggregateInto(out, rows, plan, pivotPaths);
+                // What opening this group would show: distinct keys of the next
+                // level, or the rows themselves at the innermost group level.
+                out.childCount = plan.childGroupBy
+                    ? new Set(rows.map((r) => asString(r[plan.childGroupBy]))).size
+                    : rows.length;
+                return out;
+            });
+            // The pivoted fields in a fixed order - key paths in plain string
+            // order, aggregations as requested under each - so the grid builds
+            // the same columns whatever order the groups came in. Every group
+            // row carries every field; a cell with no rows under it is null, the
+            // way a conditional aggregate answers in SQL.
+            const pivotFields = [...pivotPaths]
+                .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+                .flatMap((path) => (plan.aggregations ?? []).map((agg) => `${path}_${agg.field}`));
+            for (const g of groups) {
+                for (const f of pivotFields)
+                    if (!(f in g))
+                        g[f] = null;
             }
-            const sortedLeaves = sortRows(filtered, plan.orderBy);
+            // Sort by the group key unless the request sorted on a column we
+            // actually produced (the key or an aggregate).
+            const produced = new Set([
+                groupField,
+                ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
+            ]);
+            const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
+            const sorted = groupOrder.length
+                ? sortRows(groups, groupOrder)
+                : sortRows(groups, [{ field: groupField, desc: false }]);
             return {
-                rows: sortedLeaves.slice(plan.offset, plan.offset + plan.limit),
-                rowCount: sortedLeaves.length,
+                rows: sorted,
                 appliedExpression,
                 ...grandTotal,
+                ...(plan.pivotBy?.length ? { pivotFields } : {}),
+            };
+        }
+        return { rows: sortRows(filtered, plan.orderBy), appliedExpression, ...grandTotal };
+    }
+    return {
+        async getRows(request) {
+            const plan = planQuery(schema, request);
+            const prepared = prepare(plan);
+            return {
+                rows: prepared.rows.slice(plan.offset, plan.offset + plan.limit),
+                // On a grouped request the count is DISTINCT GROUPS, not underlying
+                // rows - the grid sizes its scrollbar and paging from this.
+                rowCount: prepared.rows.length,
+                appliedExpression: prepared.appliedExpression,
+                ...(prepared.grandTotal !== undefined ? { grandTotal: prepared.grandTotal } : {}),
+                ...(prepared.pivotFields ? { pivotResultFields: prepared.pivotFields } : {}),
             };
         },
         async createRow(input) {

package/dist/sveltekit/index.d.ts

@@ -1,5 +1,5 @@
 export { planQuery, coerce, BUILTIN_AGGREGATORS, type QueryPlan, type PlanPredicate, type PlanOp, type PlanAggregate, type PlanOptions, } from './query-plan.js';
-export { createInMemoryDataSource } from './in-memory.js';
+export { createInMemoryDataSource, type InMemoryDataSourceOptions } from './in-memory.js';
 export { createKitDataSource, createKitHandlers, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, } from './transport.js';
 export { planToSql, type SqlDialect, type SqlPlan } from './sql.js';
 export { createSqlDataSource, type SqlExecutor, type SqlDataSourceConfig, } from './sql-source.js';

package/dist/version.d.ts

@@ -10,4 +10,17 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export declare const SVGRID_VERSION = "3.1.1";
+export declare const SVGRID_VERSION = "3.1.2";
+/**
+ * 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.
+ *
+ * A scaffolded app depends on BOTH packages, and pinning the grid to this
+ * package's version asked npm for `@svgrid/grid@^3.1.1`, which has never been
+ * published. Every `svgrid-studio init` therefore produced an app whose very
+ * next step, `npm install`, failed with ERESOLVE. Found 2026-10-05 by
+ * scaffolding one and running the install.
+ *
+ * `version.test.ts` asserts this matches packages/grid/package.json.
+ */
+export declare const GRID_VERSION = "3.0.8";

package/dist/version.js

@@ -10,4 +10,17 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export const SVGRID_VERSION = '3.1.1';
+export const SVGRID_VERSION = '3.1.2';
+/**
+ * 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.
+ *
+ * A scaffolded app depends on BOTH packages, and pinning the grid to this
+ * package's version asked npm for `@svgrid/grid@^3.1.1`, which has never been
+ * published. Every `svgrid-studio init` therefore produced an app whose very
+ * next step, `npm install`, failed with ERESOLVE. Found 2026-10-05 by
+ * scaffolding one and running the install.
+ *
+ * `version.test.ts` asserts this matches packages/grid/package.json.
+ */
+export const GRID_VERSION = '3.0.8';