argus-table 0.2.2 → 0.4.0

package/dist/core/src/table/filtered-row-model.js

@@ -0,0 +1,48 @@
+import { valueVersion } from "./sorted-row-model.js";
+// ../core/src/table/filtered-row-model.ts
+var predicates = /* @__PURE__ */ new WeakMap();
+/** Sets the test the filtered row model of `table` keeps rows by. */
+function setRowPredicate(table, predicate) {
+	predicates.set(table, predicate);
+}
+/**
+* The filtered row model, in place of TanStack's column filtering feature, which
+* would cost bundle size and read values through `row.getValue()` (slow in Firefox,
+* see sorted-row-model.ts). The model compiles the filters into one row test
+* (`rowPredicate` in filters/filter.ts) and this keeps the rows it passes, reading
+* values through the columns' accessors.
+*
+* It filters again when the test, the rows or the values (`valuesChanged`) change;
+* the sorted row model then sorts again, since its source is new. The rows are the
+* same `Row` objects. `rowsById` stays the unfiltered map: only TanStack's
+* `getRow(id)` reads it, and the model finds rows by their index instead.
+*/
+function filteredRowModel() {
+	return (table) => {
+		let last;
+		return () => {
+			const source = table.getPreFilteredRowModel();
+			const predicate = predicates.get(table);
+			if (!predicate) return source;
+			const version = valueVersion(table);
+			const prev = last;
+			if (prev?.predicate === predicate && prev.source === source && prev.version === version) return prev.model;
+			const rows = source.rows.filter((row) => predicate(row.original, row.index));
+			const model = {
+				rows,
+				flatRows: rows,
+				rowsById: source.rowsById
+			};
+			last = {
+				predicate,
+				source,
+				version,
+				model
+			};
+			return model;
+		};
+	};
+}
+export { filteredRowModel, setRowPredicate };
+
+//# sourceMappingURL=filtered-row-model.js.map

package/dist/core/src/table/filtered-row-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-row-model.js","names":[],"sources":["../../../../../core/src/table/filtered-row-model.ts"],"sourcesContent":["import type { RowData, RowModel, Table, TableFeatures } from '@tanstack/table-core';\nimport type { RowPredicate } from '../filters/filter.js';\nimport { valueVersion } from './sorted-row-model.js';\n\n// The row test of each table, set by the model whenever filters, the quick filter or\n// the columns change: a new function filters again, `undefined` keeps every row.\nconst predicates = new WeakMap<object, RowPredicate<never> | undefined>();\n\n/** Sets the test the filtered row model of `table` keeps rows by. */\nexport function setRowPredicate<TData>(\n  table: object,\n  predicate: RowPredicate<TData> | undefined,\n): void {\n  predicates.set(table, predicate);\n}\n\n/**\n * The filtered row model, in place of TanStack's column filtering feature, which\n * would cost bundle size and read values through `row.getValue()` (slow in Firefox,\n * see sorted-row-model.ts). The model compiles the filters into one row test\n * (`rowPredicate` in filters/filter.ts) and this keeps the rows it passes, reading\n * values through the columns' accessors.\n *\n * It filters again when the test, the rows or the values (`valuesChanged`) change;\n * the sorted row model then sorts again, since its source is new. The rows are the\n * same `Row` objects. `rowsById` stays the unfiltered map: only TanStack's\n * `getRow(id)` reads it, and the model finds rows by their index instead.\n */\nexport function filteredRowModel<TFeatures extends TableFeatures, TData extends RowData>() {\n  return (table: Table<TFeatures, TData>) => {\n    let last:\n      | {\n          predicate: unknown;\n          source: RowModel<TFeatures, TData>;\n          version: number | undefined;\n          model: RowModel<TFeatures, TData>;\n        }\n      | undefined;\n    return (): RowModel<TFeatures, TData> => {\n      const source = table.getPreFilteredRowModel();\n      const predicate = predicates.get(table) as RowPredicate<TData> | undefined;\n      if (!predicate) return source;\n      const version = valueVersion(table);\n      const prev = last;\n      if (prev?.predicate === predicate && prev.source === source && prev.version === version) {\n        return prev.model;\n      }\n      const rows = source.rows.filter((row) => predicate(row.original, row.index));\n      const model = { rows, flatRows: rows, rowsById: source.rowsById };\n      last = { predicate, source, version, model };\n      return model;\n    };\n  };\n}\n"],"mappings":";;AAMA,IAAM,6BAAa,IAAI,QAAiD;;AAGxE,SAAgB,gBACd,OACA,WACM;CACN,WAAW,IAAI,OAAO,SAAS;AACjC;;;;;;;;;;;;;AAcA,SAAgB,mBAA2E;CACzF,QAAQ,UAAmC;EACzC,IAAI;EAQJ,aAAyC;GACvC,MAAM,SAAS,MAAM,uBAAuB;GAC5C,MAAM,YAAY,WAAW,IAAI,KAAK;GACtC,IAAI,CAAC,WAAW,OAAO;GACvB,MAAM,UAAU,aAAa,KAAK;GAClC,MAAM,OAAO;GACb,IAAI,MAAM,cAAc,aAAa,KAAK,WAAW,UAAU,KAAK,YAAY,SAC9E,OAAO,KAAK;GAEd,MAAM,OAAO,OAAO,KAAK,QAAQ,QAAQ,UAAU,IAAI,UAAU,IAAI,KAAK,CAAC;GAC3E,MAAM,QAAQ;IAAE;IAAM,UAAU;IAAM,UAAU,OAAO;GAAS;GAChE,OAAO;IAAE;IAAW;IAAQ;IAAS;GAAM;GAC3C,OAAO;EACT;CACF;AACF"}

package/dist/core/src/table/sorted-row-model.js

@@ -1,5 +1,14 @@
 import { column_getCanSort, column_getSortFn } from "@tanstack/table-core/static-functions";
 // ../core/src/table/sorted-row-model.ts
+var valueVersions = /* @__PURE__ */ new WeakMap();
+/** Makes the filtered and sorted row models of `table` filter and sort again on their next read. */
+function valuesChanged(table) {
+	valueVersions.set(table, (valueVersions.get(table) ?? 0) + 1);
+}
+/** The values version of `table`, bumped by `valuesChanged()`. */
+function valueVersion(table) {
+	return valueVersions.get(table);
+}
 /**
 * The sorted row model, in place of TanStack's `createSortedRowModel()`, giving the
 * same order: the same sort functions (`auto` included), `sortUndefined`,
@@ -24,12 +33,14 @@ function sortedRowModel() {
 		return () => {
 			const source = table.getPreSortedRowModel();
 			const sorting = table.options.state?.sorting;
+			const version = valueVersion(table);
 			const prev = last;
-			if (prev && prev.sorting === sorting && prev.source === source) return prev.model;
+			if (prev && prev.sorting === sorting && prev.source === source && prev.version === version) return prev.model;
 			const model = sortRows(table, source, sorting ?? []);
 			last = {
 				sorting,
 				source,
+				version,
 				model
 			};
 			return model;
@@ -81,6 +92,6 @@ function sortRows(table, source, sorting) {
 		rowsById: source.rowsById
 	};
 }
-export { sortedRowModel };
+export { sortedRowModel, valueVersion, valuesChanged };
 
 //# sourceMappingURL=sorted-row-model.js.map

package/dist/core/src/table/sorted-row-model.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-row-model.js","names":[],"sources":["../../../../../core/src/table/sorted-row-model.ts"],"sourcesContent":["import type {\n  ColumnDef_RowSorting,\n  RowData,\n  RowModel,\n  SortFnDef,\n  Table,\n  TableFeatures,\n} from '@tanstack/table-core';\nimport { column_getCanSort, column_getSortFn } from '@tanstack/table-core/static-functions';\n\ntype Sorting = readonly { id: string; desc: boolean }[];\n\ninterface SortKey {\n  /** Each row's value by its position in the unsorted rows, resolved for `compare`. */\n  keys: unknown[];\n  compare: (a: unknown, b: unknown) => number;\n  /** -1 flips `compare` (descending, inverted). */\n  sign: number;\n  sortUndefined: false | -1 | 1 | 'first' | 'last' | undefined;\n}\n\n/**\n * The sorted row model, in place of TanStack's `createSortedRowModel()`, giving the\n * same order: the same sort functions (`auto` included), `sortUndefined`,\n * `invertSorting`, ties by row index.\n *\n * It reads each row's value once, through the column's accessor, and sorts the row\n * positions by those values. TanStack's model calls `row.getValue()` four times per\n * comparison, and its row methods take rest arguments (`function (...args)`): in\n * Firefox that slows a large sort down by orders of magnitude (750k rows: 176 s\n * against 0.9 s for the same comparator without rest arguments). Reading values\n * once is also faster everywhere, most of all for text, which is lowercased once\n * per row instead of twice per comparison.\n *\n * The registered sort functions come from `constructSortFn`: each carries a value\n * comparator (`sort`, which compares values only) and a normalizer\n * (`resolveDataValue`). The rows are flat (no sub-rows), so there is nothing to\n * sort below them.\n */\nexport function sortedRowModel<TFeatures extends TableFeatures, TData extends RowData>() {\n  return (table: Table<TFeatures, TData>) => {\n    let last:\n      | { sorting: unknown; source: RowModel<TFeatures, TData>; model: RowModel<TFeatures, TData> }\n      | undefined;\n    return (): RowModel<TFeatures, TData> => {\n      const source = table.getPreSortedRowModel();\n      const sorting = (table.options.state as { sorting?: Sorting } | undefined)?.sorting;\n      const prev = last;\n      if (prev && prev.sorting === sorting && prev.source === source) return prev.model;\n      const model = sortRows(table, source, sorting ?? []);\n      last = { sorting, source, model };\n      return model;\n    };\n  };\n}\n\nfunction sortRows<TFeatures extends TableFeatures, TData extends RowData>(\n  table: Table<TFeatures, TData>,\n  source: RowModel<TFeatures, TData>,\n  sorting: Sorting,\n): RowModel<TFeatures, TData> {\n  const rows = source.rows;\n  const sortKeys: SortKey[] = [];\n  for (const { id, desc } of sorting) {\n    const column = table.getColumn(id);\n    if (!column || !column_getCanSort(column)) continue;\n    const fn = column_getSortFn(column) as unknown as SortFnDef<TFeatures, TData>;\n    const def = column.columnDef as ColumnDef_RowSorting<TFeatures, TData>;\n    const read = column.accessorFn;\n    const resolve = fn.resolveDataValue;\n    const sortUndefined = def.sortUndefined;\n    sortKeys.push({\n      keys: rows.map((row) => {\n        const value = read?.(row.original, row.index);\n        // Undefined stays undefined where `sortUndefined` places it.\n        return resolve && !(value === undefined && sortUndefined)\n          ? (resolve(value) as unknown)\n          : value;\n      }),\n      compare: fn.sort as (a: unknown, b: unknown) => number,\n      sign: (desc ? -1 : 1) * (def.invertSorting ? -1 : 1),\n      sortUndefined,\n    });\n  }\n  if (!sortKeys.length || !rows.length) return source;\n\n  const compare = (i: number, j: number): number => {\n    for (const { keys, compare, sign, sortUndefined } of sortKeys) {\n      const a = keys[i];\n      const b = keys[j];\n      let result = 0;\n      if (sortUndefined && (a === undefined || b === undefined)) {\n        if (a === undefined && b === undefined) continue;\n        if (sortUndefined === 'first') return a === undefined ? -1 : 1;\n        if (sortUndefined === 'last') return a === undefined ? 1 : -1;\n        result = a === undefined ? sortUndefined : -sortUndefined;\n      }\n      if (result === 0) result = compare(a, b);\n      if (result !== 0) return result * sign;\n    }\n    return (rows[i]?.index ?? i) - (rows[j]?.index ?? j);\n  };\n\n  const sorted = rows\n    .map((_, i) => i)\n    .sort(compare)\n    .map((i) => rows[i])\n    .filter((row) => row !== undefined);\n  return { rows: sorted, flatRows: sorted, rowsById: source.rowsById };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,iBAAyE;CACvF,QAAQ,UAAmC;EACzC,IAAI;EAGJ,aAAyC;GACvC,MAAM,SAAS,MAAM,qBAAqB;GAC1C,MAAM,UAAW,MAAM,QAAQ,OAA6C;GAC5E,MAAM,OAAO;GACb,IAAI,QAAQ,KAAK,YAAY,WAAW,KAAK,WAAW,QAAQ,OAAO,KAAK;GAC5E,MAAM,QAAQ,SAAS,OAAO,QAAQ,WAAW,CAAC,CAAC;GACnD,OAAO;IAAE;IAAS;IAAQ;GAAM;GAChC,OAAO;EACT;CACF;AACF;AAEA,SAAS,SACP,OACA,QACA,SAC4B;CAC5B,MAAM,OAAO,OAAO;CACpB,MAAM,WAAsB,CAAC;CAC7B,KAAK,MAAM,EAAE,IAAI,UAAU,SAAS;EAClC,MAAM,SAAS,MAAM,UAAU,EAAE;EACjC,IAAI,CAAC,UAAU,CAAC,kBAAkB,MAAM,GAAG;EAC3C,MAAM,KAAK,iBAAiB,MAAM;EAClC,MAAM,MAAM,OAAO;EACnB,MAAM,OAAO,OAAO;EACpB,MAAM,UAAU,GAAG;EACnB,MAAM,gBAAgB,IAAI;EAC1B,SAAS,KAAK;GACZ,MAAM,KAAK,KAAK,QAAQ;IACtB,MAAM,QAAQ,OAAO,IAAI,UAAU,IAAI,KAAK;IAE5C,OAAO,WAAW,EAAE,UAAU,KAAA,KAAa,iBACtC,QAAQ,KAAK,IACd;GACN,CAAC;GACD,SAAS,GAAG;GACZ,OAAO,OAAO,KAAK,MAAM,IAAI,gBAAgB,KAAK;GAClD;EACF,CAAC;CACH;CACA,IAAI,CAAC,SAAS,UAAU,CAAC,KAAK,QAAQ,OAAO;CAE7C,MAAM,WAAW,GAAW,MAAsB;EAChD,KAAK,MAAM,EAAE,MAAM,SAAS,MAAM,mBAAmB,UAAU;GAC7D,MAAM,IAAI,KAAK;GACf,MAAM,IAAI,KAAK;GACf,IAAI,SAAS;GACb,IAAI,kBAAkB,MAAM,KAAA,KAAa,MAAM,KAAA,IAAY;IACzD,IAAI,MAAM,KAAA,KAAa,MAAM,KAAA,GAAW;IACxC,IAAI,kBAAkB,SAAS,OAAO,MAAM,KAAA,IAAY,KAAK;IAC7D,IAAI,kBAAkB,QAAQ,OAAO,MAAM,KAAA,IAAY,IAAI;IAC3D,SAAS,MAAM,KAAA,IAAY,gBAAgB,CAAC;GAC9C;GACA,IAAI,WAAW,GAAG,SAAS,QAAQ,GAAG,CAAC;GACvC,IAAI,WAAW,GAAG,OAAO,SAAS;EACpC;EACA,QAAQ,KAAK,EAAE,EAAE,SAAS,MAAM,KAAK,EAAE,EAAE,SAAS;CACpD;CAEA,MAAM,SAAS,KACZ,KAAK,GAAG,MAAM,CAAC,CAAC,CAChB,KAAK,OAAO,CAAC,CACb,KAAK,MAAM,KAAK,EAAE,CAAC,CACnB,QAAQ,QAAQ,QAAQ,KAAA,CAAS;CACpC,OAAO;EAAE,MAAM;EAAQ,UAAU;EAAQ,UAAU,OAAO;CAAS;AACrE"}
+{"version":3,"file":"sorted-row-model.js","names":[],"sources":["../../../../../core/src/table/sorted-row-model.ts"],"sourcesContent":["import type {\n  ColumnDef_RowSorting,\n  RowData,\n  RowModel,\n  SortFnDef,\n  Table,\n  TableFeatures,\n} from '@tanstack/table-core';\nimport { column_getCanSort, column_getSortFn } from '@tanstack/table-core/static-functions';\n\ntype Sorting = readonly { id: string; desc: boolean }[];\n\n// Bumped per table when a column reads its values differently (same id, new\n// accessor): the rows, the filters and the sorting are the same, but which rows\n// pass and their order may not be.\nconst valueVersions = new WeakMap<object, number>();\n\n/** Makes the filtered and sorted row models of `table` filter and sort again on their next read. */\nexport function valuesChanged(table: object): void {\n  valueVersions.set(table, (valueVersions.get(table) ?? 0) + 1);\n}\n\n/** The values version of `table`, bumped by `valuesChanged()`. */\nexport function valueVersion(table: object): number | undefined {\n  return valueVersions.get(table);\n}\n\ninterface SortKey {\n  /** Each row's value by its position in the unsorted rows, resolved for `compare`. */\n  keys: unknown[];\n  compare: (a: unknown, b: unknown) => number;\n  /** -1 flips `compare` (descending, inverted). */\n  sign: number;\n  sortUndefined: false | -1 | 1 | 'first' | 'last' | undefined;\n}\n\n/**\n * The sorted row model, in place of TanStack's `createSortedRowModel()`, giving the\n * same order: the same sort functions (`auto` included), `sortUndefined`,\n * `invertSorting`, ties by row index.\n *\n * It reads each row's value once, through the column's accessor, and sorts the row\n * positions by those values. TanStack's model calls `row.getValue()` four times per\n * comparison, and its row methods take rest arguments (`function (...args)`): in\n * Firefox that slows a large sort down by orders of magnitude (750k rows: 176 s\n * against 0.9 s for the same comparator without rest arguments). Reading values\n * once is also faster everywhere, most of all for text, which is lowercased once\n * per row instead of twice per comparison.\n *\n * The registered sort functions come from `constructSortFn`: each carries a value\n * comparator (`sort`, which compares values only) and a normalizer\n * (`resolveDataValue`). The rows are flat (no sub-rows), so there is nothing to\n * sort below them.\n */\nexport function sortedRowModel<TFeatures extends TableFeatures, TData extends RowData>() {\n  return (table: Table<TFeatures, TData>) => {\n    let last:\n      | {\n          sorting: unknown;\n          source: RowModel<TFeatures, TData>;\n          version: number | undefined;\n          model: RowModel<TFeatures, TData>;\n        }\n      | undefined;\n    return (): RowModel<TFeatures, TData> => {\n      const source = table.getPreSortedRowModel();\n      const sorting = (table.options.state as { sorting?: Sorting } | undefined)?.sorting;\n      const version = valueVersion(table);\n      const prev = last;\n      if (prev && prev.sorting === sorting && prev.source === source && prev.version === version) {\n        return prev.model;\n      }\n      const model = sortRows(table, source, sorting ?? []);\n      last = { sorting, source, version, model };\n      return model;\n    };\n  };\n}\n\nfunction sortRows<TFeatures extends TableFeatures, TData extends RowData>(\n  table: Table<TFeatures, TData>,\n  source: RowModel<TFeatures, TData>,\n  sorting: Sorting,\n): RowModel<TFeatures, TData> {\n  const rows = source.rows;\n  const sortKeys: SortKey[] = [];\n  for (const { id, desc } of sorting) {\n    const column = table.getColumn(id);\n    if (!column || !column_getCanSort(column)) continue;\n    const fn = column_getSortFn(column) as unknown as SortFnDef<TFeatures, TData>;\n    const def = column.columnDef as ColumnDef_RowSorting<TFeatures, TData>;\n    const read = column.accessorFn;\n    const resolve = fn.resolveDataValue;\n    const sortUndefined = def.sortUndefined;\n    sortKeys.push({\n      keys: rows.map((row) => {\n        const value = read?.(row.original, row.index);\n        // Undefined stays undefined where `sortUndefined` places it.\n        return resolve && !(value === undefined && sortUndefined)\n          ? (resolve(value) as unknown)\n          : value;\n      }),\n      compare: fn.sort as (a: unknown, b: unknown) => number,\n      sign: (desc ? -1 : 1) * (def.invertSorting ? -1 : 1),\n      sortUndefined,\n    });\n  }\n  if (!sortKeys.length || !rows.length) return source;\n\n  const compare = (i: number, j: number): number => {\n    for (const { keys, compare, sign, sortUndefined } of sortKeys) {\n      const a = keys[i];\n      const b = keys[j];\n      let result = 0;\n      if (sortUndefined && (a === undefined || b === undefined)) {\n        if (a === undefined && b === undefined) continue;\n        if (sortUndefined === 'first') return a === undefined ? -1 : 1;\n        if (sortUndefined === 'last') return a === undefined ? 1 : -1;\n        result = a === undefined ? sortUndefined : -sortUndefined;\n      }\n      if (result === 0) result = compare(a, b);\n      if (result !== 0) return result * sign;\n    }\n    return (rows[i]?.index ?? i) - (rows[j]?.index ?? j);\n  };\n\n  const sorted = rows\n    .map((_, i) => i)\n    .sort(compare)\n    .map((i) => rows[i])\n    .filter((row) => row !== undefined);\n  return { rows: sorted, flatRows: sorted, rowsById: source.rowsById };\n}\n"],"mappings":";;AAeA,IAAM,gCAAgB,IAAI,QAAwB;;AAGlD,SAAgB,cAAc,OAAqB;CACjD,cAAc,IAAI,QAAQ,cAAc,IAAI,KAAK,KAAK,KAAK,CAAC;AAC9D;;AAGA,SAAgB,aAAa,OAAmC;CAC9D,OAAO,cAAc,IAAI,KAAK;AAChC;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBAAyE;CACvF,QAAQ,UAAmC;EACzC,IAAI;EAQJ,aAAyC;GACvC,MAAM,SAAS,MAAM,qBAAqB;GAC1C,MAAM,UAAW,MAAM,QAAQ,OAA6C;GAC5E,MAAM,UAAU,aAAa,KAAK;GAClC,MAAM,OAAO;GACb,IAAI,QAAQ,KAAK,YAAY,WAAW,KAAK,WAAW,UAAU,KAAK,YAAY,SACjF,OAAO,KAAK;GAEd,MAAM,QAAQ,SAAS,OAAO,QAAQ,WAAW,CAAC,CAAC;GACnD,OAAO;IAAE;IAAS;IAAQ;IAAS;GAAM;GACzC,OAAO;EACT;CACF;AACF;AAEA,SAAS,SACP,OACA,QACA,SAC4B;CAC5B,MAAM,OAAO,OAAO;CACpB,MAAM,WAAsB,CAAC;CAC7B,KAAK,MAAM,EAAE,IAAI,UAAU,SAAS;EAClC,MAAM,SAAS,MAAM,UAAU,EAAE;EACjC,IAAI,CAAC,UAAU,CAAC,kBAAkB,MAAM,GAAG;EAC3C,MAAM,KAAK,iBAAiB,MAAM;EAClC,MAAM,MAAM,OAAO;EACnB,MAAM,OAAO,OAAO;EACpB,MAAM,UAAU,GAAG;EACnB,MAAM,gBAAgB,IAAI;EAC1B,SAAS,KAAK;GACZ,MAAM,KAAK,KAAK,QAAQ;IACtB,MAAM,QAAQ,OAAO,IAAI,UAAU,IAAI,KAAK;IAE5C,OAAO,WAAW,EAAE,UAAU,KAAA,KAAa,iBACtC,QAAQ,KAAK,IACd;GACN,CAAC;GACD,SAAS,GAAG;GACZ,OAAO,OAAO,KAAK,MAAM,IAAI,gBAAgB,KAAK;GAClD;EACF,CAAC;CACH;CACA,IAAI,CAAC,SAAS,UAAU,CAAC,KAAK,QAAQ,OAAO;CAE7C,MAAM,WAAW,GAAW,MAAsB;EAChD,KAAK,MAAM,EAAE,MAAM,SAAS,MAAM,mBAAmB,UAAU;GAC7D,MAAM,IAAI,KAAK;GACf,MAAM,IAAI,KAAK;GACf,IAAI,SAAS;GACb,IAAI,kBAAkB,MAAM,KAAA,KAAa,MAAM,KAAA,IAAY;IACzD,IAAI,MAAM,KAAA,KAAa,MAAM,KAAA,GAAW;IACxC,IAAI,kBAAkB,SAAS,OAAO,MAAM,KAAA,IAAY,KAAK;IAC7D,IAAI,kBAAkB,QAAQ,OAAO,MAAM,KAAA,IAAY,IAAI;IAC3D,SAAS,MAAM,KAAA,IAAY,gBAAgB,CAAC;GAC9C;GACA,IAAI,WAAW,GAAG,SAAS,QAAQ,GAAG,CAAC;GACvC,IAAI,WAAW,GAAG,OAAO,SAAS;EACpC;EACA,QAAQ,KAAK,EAAE,EAAE,SAAS,MAAM,KAAK,EAAE,EAAE,SAAS;CACpD;CAEA,MAAM,SAAS,KACZ,KAAK,GAAG,MAAM,CAAC,CAAC,CAChB,KAAK,OAAO,CAAC,CACb,KAAK,MAAM,KAAK,EAAE,CAAC,CACnB,QAAQ,QAAQ,QAAQ,KAAA,CAAS;CACpC,OAAO;EAAE,MAAM;EAAQ,UAAU;EAAQ,UAAU,OAAO;CAAS;AACrE"}

package/dist/core/src/virtual/column-window.js

@@ -0,0 +1,72 @@
+import { steadyWindow } from "./steady-window.js";
+// ../core/src/virtual/column-window.ts
+/**
+* The scrolling columns a view `viewWidth` px wide shows when scrolled
+* `scrollOffset` px (always positive, RTL included), indexes inclusive.
+* `undefined` when there are no columns or the view has no width. `columns`
+* are in visual order, so their offsets ascend.
+*/
+function visibleColumns(columns, scrollOffset, viewWidth) {
+	const count = columns.length;
+	if (count === 0 || viewWidth <= 0) return void 0;
+	let lo = 0;
+	let hi = count - 1;
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		const c = columns[mid];
+		if (c && c.offset + c.width > scrollOffset) hi = mid;
+		else lo = mid + 1;
+	}
+	const startIndex = lo;
+	const end = scrollOffset + viewWidth;
+	lo = startIndex;
+	hi = count - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		const c = columns[mid];
+		if (c && c.offset < end) lo = mid;
+		else hi = mid - 1;
+	}
+	return {
+		startIndex,
+		endIndex: lo
+	};
+}
+/**
+* The most columns a view `viewWidth` px wide can show at once, partly ones
+* included, wherever it is scrolled. The view shows the most columns when it
+* starts just before some column's end, so that is the only place to try.
+*/
+function maxVisibleColumns(columns, viewWidth) {
+	if (viewWidth <= 0) return 0;
+	let most = 0;
+	let j = 0;
+	for (let i = 0; i < columns.length; i++) {
+		const c = columns[i];
+		if (!c) continue;
+		const limit = c.offset + c.width + viewWidth;
+		j = Math.max(j, i);
+		for (let next = columns[j + 1]; next && next.offset < limit; next = columns[j + 1]) j++;
+		most = Math.max(most, j - i + 1);
+	}
+	return most;
+}
+/**
+* The scrolling columns to render, as indexes: the visible ones plus `overscan`
+* on each side, always the same number of them for one set of widths (like
+* rows, see `steadyWindow`: in WebKit, a column pool that grows while scrolling
+* cuts a wheel scroll short). Empty while the view has no width.
+* `maxVisible` is `maxVisibleColumns()` for these columns and this view.
+*/
+function columnWindow(columns, scrollOffset, viewWidth, overscan, maxVisible) {
+	const visible = visibleColumns(columns, scrollOffset, viewWidth);
+	if (!visible) return [];
+	return steadyWindow({
+		...visible,
+		overscan,
+		count: columns.length
+	}, maxVisible);
+}
+export { columnWindow, maxVisibleColumns, visibleColumns };
+
+//# sourceMappingURL=column-window.js.map

package/dist/core/src/virtual/column-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-window.js","names":[],"sources":["../../../../../core/src/virtual/column-window.ts"],"sourcesContent":["import { steadyWindow } from './steady-window.js';\n\n/** Where a scrolling column sits: its start within the scrolling area and its width, in px. */\nexport interface ColumnExtent {\n  offset: number;\n  width: number;\n}\n\n/**\n * The scrolling columns a view `viewWidth` px wide shows when scrolled\n * `scrollOffset` px (always positive, RTL included), indexes inclusive.\n * `undefined` when there are no columns or the view has no width. `columns`\n * are in visual order, so their offsets ascend.\n */\nexport function visibleColumns(\n  columns: readonly ColumnExtent[],\n  scrollOffset: number,\n  viewWidth: number,\n): { startIndex: number; endIndex: number } | undefined {\n  const count = columns.length;\n  if (count === 0 || viewWidth <= 0) return undefined;\n  // The first column that ends past the scroll offset.\n  let lo = 0;\n  let hi = count - 1;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    const c = columns[mid];\n    if (c && c.offset + c.width > scrollOffset) hi = mid;\n    else lo = mid + 1;\n  }\n  const startIndex = lo;\n  // The last column that starts before the view's end.\n  const end = scrollOffset + viewWidth;\n  lo = startIndex;\n  hi = count - 1;\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    const c = columns[mid];\n    if (c && c.offset < end) lo = mid;\n    else hi = mid - 1;\n  }\n  return { startIndex, endIndex: lo };\n}\n\n/**\n * The most columns a view `viewWidth` px wide can show at once, partly ones\n * included, wherever it is scrolled. The view shows the most columns when it\n * starts just before some column's end, so that is the only place to try.\n */\nexport function maxVisibleColumns(columns: readonly ColumnExtent[], viewWidth: number): number {\n  if (viewWidth <= 0) return 0;\n  let most = 0;\n  let j = 0;\n  for (let i = 0; i < columns.length; i++) {\n    const c = columns[i];\n    if (!c) continue;\n    const limit = c.offset + c.width + viewWidth;\n    j = Math.max(j, i);\n    for (let next = columns[j + 1]; next && next.offset < limit; next = columns[j + 1]) j++;\n    most = Math.max(most, j - i + 1);\n  }\n  return most;\n}\n\n/**\n * The scrolling columns to render, as indexes: the visible ones plus `overscan`\n * on each side, always the same number of them for one set of widths (like\n * rows, see `steadyWindow`: in WebKit, a column pool that grows while scrolling\n * cuts a wheel scroll short). Empty while the view has no width.\n * `maxVisible` is `maxVisibleColumns()` for these columns and this view.\n */\nexport function columnWindow(\n  columns: readonly ColumnExtent[],\n  scrollOffset: number,\n  viewWidth: number,\n  overscan: number,\n  maxVisible: number,\n): number[] {\n  const visible = visibleColumns(columns, scrollOffset, viewWidth);\n  if (!visible) return [];\n  return steadyWindow({ ...visible, overscan, count: columns.length }, maxVisible);\n}\n"],"mappings":";;;;;;;;AAcA,SAAgB,eACd,SACA,cACA,WACsD;CACtD,MAAM,QAAQ,QAAQ;CACtB,IAAI,UAAU,KAAK,aAAa,GAAG,OAAO,KAAA;CAE1C,IAAI,KAAK;CACT,IAAI,KAAK,QAAQ;CACjB,OAAO,KAAK,IAAI;EACd,MAAM,MAAO,KAAK,MAAO;EACzB,MAAM,IAAI,QAAQ;EAClB,IAAI,KAAK,EAAE,SAAS,EAAE,QAAQ,cAAc,KAAK;OAC5C,KAAK,MAAM;CAClB;CACA,MAAM,aAAa;CAEnB,MAAM,MAAM,eAAe;CAC3B,KAAK;CACL,KAAK,QAAQ;CACb,OAAO,KAAK,IAAI;EACd,MAAM,MAAO,KAAK,KAAK,KAAM;EAC7B,MAAM,IAAI,QAAQ;EAClB,IAAI,KAAK,EAAE,SAAS,KAAK,KAAK;OACzB,KAAK,MAAM;CAClB;CACA,OAAO;EAAE;EAAY,UAAU;CAAG;AACpC;;;;;;AAOA,SAAgB,kBAAkB,SAAkC,WAA2B;CAC7F,IAAI,aAAa,GAAG,OAAO;CAC3B,IAAI,OAAO;CACX,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,IAAI,QAAQ;EAClB,IAAI,CAAC,GAAG;EACR,MAAM,QAAQ,EAAE,SAAS,EAAE,QAAQ;EACnC,IAAI,KAAK,IAAI,GAAG,CAAC;EACjB,KAAK,IAAI,OAAO,QAAQ,IAAI,IAAI,QAAQ,KAAK,SAAS,OAAO,OAAO,QAAQ,IAAI,IAAI;EACpF,OAAO,KAAK,IAAI,MAAM,IAAI,IAAI,CAAC;CACjC;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,aACd,SACA,cACA,WACA,UACA,YACU;CACV,MAAM,UAAU,eAAe,SAAS,cAAc,SAAS;CAC/D,IAAI,CAAC,SAAS,OAAO,CAAC;CACtB,OAAO,aAAa;EAAE,GAAG;EAAS;EAAU,OAAO,QAAQ;CAAO,GAAG,UAAU;AACjF"}

package/dist/core/src/virtual/row-pool.js

@@ -1,6 +1,7 @@
 // ../core/src/virtual/row-pool.ts
 /**
-* Assigns pool slots to rendered rows (ADR 0001).
+* Assigns pool slots to rendered rows (ADR 0001), and with `virtualizeColumns`
+* to rendered columns too (the ids are then column ids).
 *
 * A row keeps its slot while it stays rendered. A row entering the window takes a
 * slot freed by a row that left, so its DOM is updated in place rather than created.

package/dist/core/src/virtual/row-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"row-pool.js","names":[],"sources":["../../../../../core/src/virtual/row-pool.ts"],"sourcesContent":["/** A rendered row and the pool slot whose DOM it uses. */\nexport interface PoolEntry {\n  id: string;\n  slot: number;\n}\n\n/**\n * Assigns pool slots to rendered rows (ADR 0001).\n *\n * A row keeps its slot while it stays rendered. A row entering the window takes a\n * slot freed by a row that left, so its DOM is updated in place rather than created.\n * Rows are returned in slot order (\"pool order\"); the ADR 0001 addendum ruled out\n * re-sorting them by row index, so assistive tech gets row positions from\n * `aria-rowindex` instead.\n */\nexport class RowPool {\n  #slots = new Map<string, number>();\n  #free: number[] = [];\n  #size = 0;\n  #pinned: string | undefined;\n\n  /** Number of slots created so far: the most rows rendered at once. */\n  get size(): number {\n    return this.#size;\n  }\n\n  /** The row id whose slot is kept while it is out of range, if any. */\n  get pinned(): string | undefined {\n    return this.#pinned;\n  }\n\n  /**\n   * Keeps one row's slot, and keeps it rendered, while it is outside the rendered\n   * range. Used for the row holding focus. `undefined` releases it.\n   */\n  pin(id: string | undefined): void {\n    this.#pinned = id;\n  }\n\n  /** The slot a row holds, or `undefined` when it isn't rendered. */\n  slotOf(id: string): number | undefined {\n    return this.#slots.get(id);\n  }\n\n  /**\n   * Updates the pool for the rows that should be rendered and returns them, plus the\n   * pinned row if it isn't among them, in slot order.\n   */\n  update(ids: Iterable<string>): PoolEntry[] {\n    const keep = new Set(ids);\n    if (this.#pinned !== undefined) keep.add(this.#pinned);\n\n    for (const [id, slot] of this.#slots) {\n      if (!keep.has(id)) {\n        this.#slots.delete(id);\n        this.#free.push(slot);\n      }\n    }\n    for (const id of keep) {\n      if (!this.#slots.has(id)) this.#slots.set(id, this.#free.pop() ?? this.#size++);\n    }\n\n    const entries: PoolEntry[] = [];\n    for (const [id, slot] of this.#slots) entries.push({ id, slot });\n    return entries.sort((a, b) => a.slot - b.slot);\n  }\n\n  /** Frees every slot, for example when the data is replaced. */\n  clear(): void {\n    this.#slots.clear();\n    this.#free = [];\n    this.#size = 0;\n    this.#pinned = undefined;\n  }\n}\n"],"mappings":";;;;;;;;;;AAeA,IAAa,UAAb,MAAqB;CACnB,yBAAS,IAAI,IAAoB;CACjC,QAAkB,CAAC;CACnB,QAAQ;CACR;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAK;CACd;;CAGA,IAAI,SAA6B;EAC/B,OAAO,KAAK;CACd;;;;;CAMA,IAAI,IAA8B;EAChC,KAAK,UAAU;CACjB;;CAGA,OAAO,IAAgC;EACrC,OAAO,KAAK,OAAO,IAAI,EAAE;CAC3B;;;;;CAMA,OAAO,KAAoC;EACzC,MAAM,OAAO,IAAI,IAAI,GAAG;EACxB,IAAI,KAAK,YAAY,KAAA,GAAW,KAAK,IAAI,KAAK,OAAO;EAErD,KAAK,MAAM,CAAC,IAAI,SAAS,KAAK,QAC5B,IAAI,CAAC,KAAK,IAAI,EAAE,GAAG;GACjB,KAAK,OAAO,OAAO,EAAE;GACrB,KAAK,MAAM,KAAK,IAAI;EACtB;EAEF,KAAK,MAAM,MAAM,MACf,IAAI,CAAC,KAAK,OAAO,IAAI,EAAE,GAAG,KAAK,OAAO,IAAI,IAAI,KAAK,MAAM,IAAI,KAAK,KAAK,OAAO;EAGhF,MAAM,UAAuB,CAAC;EAC9B,KAAK,MAAM,CAAC,IAAI,SAAS,KAAK,QAAQ,QAAQ,KAAK;GAAE;GAAI;EAAK,CAAC;EAC/D,OAAO,QAAQ,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,IAAI;CAC/C;;CAGA,QAAc;EACZ,KAAK,OAAO,MAAM;EAClB,KAAK,QAAQ,CAAC;EACd,KAAK,QAAQ;EACb,KAAK,UAAU,KAAA;CACjB;AACF"}
+{"version":3,"file":"row-pool.js","names":[],"sources":["../../../../../core/src/virtual/row-pool.ts"],"sourcesContent":["/** A rendered row and the pool slot whose DOM it uses. */\nexport interface PoolEntry {\n  id: string;\n  slot: number;\n}\n\n/**\n * Assigns pool slots to rendered rows (ADR 0001), and with `virtualizeColumns`\n * to rendered columns too (the ids are then column ids).\n *\n * A row keeps its slot while it stays rendered. A row entering the window takes a\n * slot freed by a row that left, so its DOM is updated in place rather than created.\n * Rows are returned in slot order (\"pool order\"); the ADR 0001 addendum ruled out\n * re-sorting them by row index, so assistive tech gets row positions from\n * `aria-rowindex` instead.\n */\nexport class RowPool {\n  #slots = new Map<string, number>();\n  #free: number[] = [];\n  #size = 0;\n  #pinned: string | undefined;\n\n  /** Number of slots created so far: the most rows rendered at once. */\n  get size(): number {\n    return this.#size;\n  }\n\n  /** The row id whose slot is kept while it is out of range, if any. */\n  get pinned(): string | undefined {\n    return this.#pinned;\n  }\n\n  /**\n   * Keeps one row's slot, and keeps it rendered, while it is outside the rendered\n   * range. Used for the row holding focus. `undefined` releases it.\n   */\n  pin(id: string | undefined): void {\n    this.#pinned = id;\n  }\n\n  /** The slot a row holds, or `undefined` when it isn't rendered. */\n  slotOf(id: string): number | undefined {\n    return this.#slots.get(id);\n  }\n\n  /**\n   * Updates the pool for the rows that should be rendered and returns them, plus the\n   * pinned row if it isn't among them, in slot order.\n   */\n  update(ids: Iterable<string>): PoolEntry[] {\n    const keep = new Set(ids);\n    if (this.#pinned !== undefined) keep.add(this.#pinned);\n\n    for (const [id, slot] of this.#slots) {\n      if (!keep.has(id)) {\n        this.#slots.delete(id);\n        this.#free.push(slot);\n      }\n    }\n    for (const id of keep) {\n      if (!this.#slots.has(id)) this.#slots.set(id, this.#free.pop() ?? this.#size++);\n    }\n\n    const entries: PoolEntry[] = [];\n    for (const [id, slot] of this.#slots) entries.push({ id, slot });\n    return entries.sort((a, b) => a.slot - b.slot);\n  }\n\n  /** Frees every slot, for example when the data is replaced. */\n  clear(): void {\n    this.#slots.clear();\n    this.#free = [];\n    this.#size = 0;\n    this.#pinned = undefined;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAgBA,IAAa,UAAb,MAAqB;CACnB,yBAAS,IAAI,IAAoB;CACjC,QAAkB,CAAC;CACnB,QAAQ;CACR;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAK;CACd;;CAGA,IAAI,SAA6B;EAC/B,OAAO,KAAK;CACd;;;;;CAMA,IAAI,IAA8B;EAChC,KAAK,UAAU;CACjB;;CAGA,OAAO,IAAgC;EACrC,OAAO,KAAK,OAAO,IAAI,EAAE;CAC3B;;;;;CAMA,OAAO,KAAoC;EACzC,MAAM,OAAO,IAAI,IAAI,GAAG;EACxB,IAAI,KAAK,YAAY,KAAA,GAAW,KAAK,IAAI,KAAK,OAAO;EAErD,KAAK,MAAM,CAAC,IAAI,SAAS,KAAK,QAC5B,IAAI,CAAC,KAAK,IAAI,EAAE,GAAG;GACjB,KAAK,OAAO,OAAO,EAAE;GACrB,KAAK,MAAM,KAAK,IAAI;EACtB;EAEF,KAAK,MAAM,MAAM,MACf,IAAI,CAAC,KAAK,OAAO,IAAI,EAAE,GAAG,KAAK,OAAO,IAAI,IAAI,KAAK,MAAM,IAAI,KAAK,KAAK,OAAO;EAGhF,MAAM,UAAuB,CAAC;EAC9B,KAAK,MAAM,CAAC,IAAI,SAAS,KAAK,QAAQ,QAAQ,KAAK;GAAE;GAAI;EAAK,CAAC;EAC/D,OAAO,QAAQ,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,IAAI;CAC/C;;CAGA,QAAc;EACZ,KAAK,OAAO,MAAM;EAClB,KAAK,QAAQ,CAAC;EACd,KAAK,QAAQ;EACb,KAAK,UAAU,KAAA;CACjB;AACF"}

package/dist/core/src/virtual/row-sizes.js

@@ -0,0 +1,152 @@
+// ../core/src/virtual/row-sizes.ts
+/**
+* Row heights for rows that aren't all the same height (`rowHeight: 'auto'`):
+* every row is `estimate` px until it is measured. Offsets, the row at an
+* offset and the total take O(log n), so measuring a row near the top of a
+* million rows doesn't recompute every row below it.
+*
+* A Fenwick tree over each row's difference from the estimate. Nothing is
+* allocated until a row differs from the estimate: one-line rows cost nothing.
+*/
+var RowSizes = class {
+	#count = 0;
+	#estimate = 1;
+	/** Each row's difference from the estimate; `undefined` while every row is the estimate. */
+	#delta;
+	/** Fenwick tree over `#delta`, 1-based. */
+	#tree;
+	/** The highest power of two at most `#count`, for `indexAt`. */
+	#step = 0;
+	/** The sum of all differences. */
+	#sum = 0;
+	/** Number of rows. */
+	get count() {
+		return this.#count;
+	}
+	/** The height of all rows. */
+	get total() {
+		return this.#count * this.#estimate + this.#sum;
+	}
+	/**
+	* Starts over: `count` rows of `estimate` px, then the heights in `sizes`
+	* (`[index, px]`; indexes out of range are ignored). O(count).
+	*/
+	reset(count, estimate, sizes = []) {
+		this.#count = Math.max(0, Math.floor(count));
+		this.#estimate = estimate > 0 ? estimate : 1;
+		this.#step = highestPowerOfTwo(this.#count);
+		this.#sum = 0;
+		let delta;
+		for (const [index, px] of sizes) {
+			if (index < 0 || index >= this.#count || !Number.isFinite(px)) continue;
+			const d = px - this.#estimate;
+			if (d === 0) continue;
+			delta ??= this.#buffer(this.#count);
+			this.#sum += d - (delta[index] ?? 0);
+			delta[index] = d;
+		}
+		if (delta) this.#build(delta);
+		else this.#clear();
+	}
+	/**
+	* Changes the number of rows (a data source counting more), keeping the
+	* heights of the rows that stay. O(count) when any row was measured.
+	*/
+	resize(count) {
+		count = Math.max(0, Math.floor(count));
+		if (count === this.#count) return;
+		const old = this.#delta;
+		this.#count = count;
+		this.#step = highestPowerOfTwo(count);
+		if (!old) return;
+		const delta = new Float64Array(count);
+		delta.set(old.subarray(0, Math.min(count, old.length)));
+		this.#sum = 0;
+		for (const d of delta) this.#sum += d;
+		this.#build(delta);
+	}
+	/** The height of the row at `index`. */
+	sizeOf(index) {
+		return this.#estimate + (this.#delta?.[index] ?? 0);
+	}
+	/** Sets the height of the row at `index`. Returns how much it changed by. */
+	set(index, px) {
+		if (index < 0 || index >= this.#count || !Number.isFinite(px)) return 0;
+		const d = px - this.sizeOf(index);
+		if (Math.abs(d) < 1e-6) return 0;
+		if (!this.#delta || !this.#tree) this.#build(this.#buffer(this.#count));
+		const delta = this.#delta;
+		const tree = this.#tree;
+		if (!delta || !tree) return 0;
+		delta[index] = (delta[index] ?? 0) + d;
+		for (let i = index + 1; i <= this.#count; i += i & -i) tree[i] = (tree[i] ?? 0) + d;
+		this.#sum += d;
+		return d;
+	}
+	/** The offset of the row at `index` from the first row's top: the heights of the rows before it. */
+	startOf(index) {
+		const i = Math.min(Math.max(Math.floor(index), 0), this.#count);
+		let start = i * this.#estimate;
+		const tree = this.#tree;
+		if (tree) for (let j = i; j > 0; j -= j & -j) start += tree[j] ?? 0;
+		return start;
+	}
+	/** The row at `offset` px from the first row's top, clamped to the rows. 0 when there are none. */
+	indexAt(offset) {
+		const count = this.#count;
+		if (count === 0 || !(offset > 0)) return 0;
+		const estimate = this.#estimate;
+		const tree = this.#tree;
+		let index;
+		if (!tree) index = Math.floor(offset / estimate);
+		else {
+			index = 0;
+			let rest = offset;
+			for (let step = this.#step; step > 0; step >>= 1) {
+				const next = index + step;
+				if (next > count) continue;
+				const size = step * estimate + (tree[next] ?? 0);
+				if (size <= rest) {
+					index = next;
+					rest -= size;
+				}
+			}
+		}
+		return Math.min(index, count - 1);
+	}
+	/** A zeroed buffer for `count` differences, reusing the current one when it fits. */
+	#buffer(count) {
+		const delta = this.#delta;
+		if (delta?.length === count) {
+			delta.fill(0);
+			return delta;
+		}
+		return new Float64Array(count);
+	}
+	/** Builds the tree over `delta` in O(count). */
+	#build(delta) {
+		const count = this.#count;
+		let tree = this.#tree;
+		if (tree?.length !== count + 1) tree = new Float64Array(count + 1);
+		tree.set(delta, 1);
+		tree[0] = 0;
+		for (let i = 1; i <= count; i++) {
+			const parent = i + (i & -i);
+			if (parent <= count) tree[parent] = (tree[parent] ?? 0) + (tree[i] ?? 0);
+		}
+		this.#delta = delta;
+		this.#tree = tree;
+	}
+	#clear() {
+		this.#delta = void 0;
+		this.#tree = void 0;
+	}
+};
+function highestPowerOfTwo(n) {
+	let step = 1;
+	while (step * 2 <= n) step *= 2;
+	return n > 0 ? step : 0;
+}
+export { RowSizes };
+
+//# sourceMappingURL=row-sizes.js.map

package/dist/core/src/virtual/row-sizes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-sizes.js","names":[],"sources":["../../../../../core/src/virtual/row-sizes.ts"],"sourcesContent":["/**\n * Row heights for rows that aren't all the same height (`rowHeight: 'auto'`):\n * every row is `estimate` px until it is measured. Offsets, the row at an\n * offset and the total take O(log n), so measuring a row near the top of a\n * million rows doesn't recompute every row below it.\n *\n * A Fenwick tree over each row's difference from the estimate. Nothing is\n * allocated until a row differs from the estimate: one-line rows cost nothing.\n */\nexport class RowSizes {\n  #count = 0;\n  #estimate = 1;\n  /** Each row's difference from the estimate; `undefined` while every row is the estimate. */\n  #delta: Float64Array | undefined;\n  /** Fenwick tree over `#delta`, 1-based. */\n  #tree: Float64Array | undefined;\n  /** The highest power of two at most `#count`, for `indexAt`. */\n  #step = 0;\n  /** The sum of all differences. */\n  #sum = 0;\n\n  /** Number of rows. */\n  get count(): number {\n    return this.#count;\n  }\n\n  /** The height of all rows. */\n  get total(): number {\n    return this.#count * this.#estimate + this.#sum;\n  }\n\n  /**\n   * Starts over: `count` rows of `estimate` px, then the heights in `sizes`\n   * (`[index, px]`; indexes out of range are ignored). O(count).\n   */\n  reset(count: number, estimate: number, sizes: Iterable<readonly [number, number]> = []): void {\n    this.#count = Math.max(0, Math.floor(count));\n    this.#estimate = estimate > 0 ? estimate : 1;\n    this.#step = highestPowerOfTwo(this.#count);\n    this.#sum = 0;\n    let delta: Float64Array | undefined;\n    for (const [index, px] of sizes) {\n      if (index < 0 || index >= this.#count || !Number.isFinite(px)) continue;\n      const d = px - this.#estimate;\n      if (d === 0) continue;\n      delta ??= this.#buffer(this.#count);\n      this.#sum += d - (delta[index] ?? 0);\n      delta[index] = d;\n    }\n    if (delta) this.#build(delta);\n    else this.#clear();\n  }\n\n  /**\n   * Changes the number of rows (a data source counting more), keeping the\n   * heights of the rows that stay. O(count) when any row was measured.\n   */\n  resize(count: number): void {\n    count = Math.max(0, Math.floor(count));\n    if (count === this.#count) return;\n    const old = this.#delta;\n    this.#count = count;\n    this.#step = highestPowerOfTwo(count);\n    if (!old) return;\n    const delta = new Float64Array(count);\n    delta.set(old.subarray(0, Math.min(count, old.length)));\n    this.#sum = 0;\n    for (const d of delta) this.#sum += d;\n    this.#build(delta);\n  }\n\n  /** The height of the row at `index`. */\n  sizeOf(index: number): number {\n    return this.#estimate + (this.#delta?.[index] ?? 0);\n  }\n\n  /** Sets the height of the row at `index`. Returns how much it changed by. */\n  set(index: number, px: number): number {\n    if (index < 0 || index >= this.#count || !Number.isFinite(px)) return 0;\n    const d = px - this.sizeOf(index);\n    if (Math.abs(d) < 1e-6) return 0;\n    if (!this.#delta || !this.#tree) this.#build(this.#buffer(this.#count));\n    const delta = this.#delta;\n    const tree = this.#tree;\n    if (!delta || !tree) return 0;\n    delta[index] = (delta[index] ?? 0) + d;\n    for (let i = index + 1; i <= this.#count; i += i & -i) tree[i] = (tree[i] ?? 0) + d;\n    this.#sum += d;\n    return d;\n  }\n\n  /** The offset of the row at `index` from the first row's top: the heights of the rows before it. */\n  startOf(index: number): number {\n    const i = Math.min(Math.max(Math.floor(index), 0), this.#count);\n    let start = i * this.#estimate;\n    const tree = this.#tree;\n    if (tree) for (let j = i; j > 0; j -= j & -j) start += tree[j] ?? 0;\n    return start;\n  }\n\n  /** The row at `offset` px from the first row's top, clamped to the rows. 0 when there are none. */\n  indexAt(offset: number): number {\n    const count = this.#count;\n    if (count === 0 || !(offset > 0)) return 0;\n    const estimate = this.#estimate;\n    const tree = this.#tree;\n    let index: number;\n    if (!tree) {\n      index = Math.floor(offset / estimate);\n    } else {\n      // The most rows whose heights add up to at most `offset`: that many rows\n      // end at or above it, so the row at it is the next one.\n      index = 0;\n      let rest = offset;\n      for (let step = this.#step; step > 0; step >>= 1) {\n        const next = index + step;\n        if (next > count) continue;\n        const size = step * estimate + (tree[next] ?? 0);\n        if (size <= rest) {\n          index = next;\n          rest -= size;\n        }\n      }\n    }\n    return Math.min(index, count - 1);\n  }\n\n  /** A zeroed buffer for `count` differences, reusing the current one when it fits. */\n  #buffer(count: number): Float64Array {\n    const delta = this.#delta;\n    if (delta?.length === count) {\n      delta.fill(0);\n      return delta;\n    }\n    return new Float64Array(count);\n  }\n\n  /** Builds the tree over `delta` in O(count). */\n  #build(delta: Float64Array): void {\n    const count = this.#count;\n    let tree = this.#tree;\n    if (tree?.length !== count + 1) tree = new Float64Array(count + 1);\n    tree.set(delta, 1);\n    tree[0] = 0;\n    for (let i = 1; i <= count; i++) {\n      const parent = i + (i & -i);\n      if (parent <= count) tree[parent] = (tree[parent] ?? 0) + (tree[i] ?? 0);\n    }\n    this.#delta = delta;\n    this.#tree = tree;\n  }\n\n  #clear(): void {\n    this.#delta = undefined;\n    this.#tree = undefined;\n  }\n}\n\nfunction highestPowerOfTwo(n: number): number {\n  let step = 1;\n  while (step * 2 <= n) step *= 2;\n  return n > 0 ? step : 0;\n}\n"],"mappings":"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"}

package/dist/core/src/virtual/scroll-scale.js

@@ -3,7 +3,8 @@
 * Maps the scroll position of a body that is too tall to render onto the rows.
 *
 * Engines limit an element's height (about 33.5M px in Chromium and WebKit, less
-* when zoomed; about 17.9M px in Firefox, which drops a taller element to 0). A
+* when zoomed; about 17.9M px in Firefox, which drops a taller element to 0, and
+* lets go of sticky elements past 8.95M px of scrolling, so 8M px there). A
 * body taller than `cap` renders `cap` px tall, and the scroll position is scaled
 * linearly: the top of the physical scroll range is the first row, its bottom the
 * last. Offsets the virtualizer works with are logical (unscaled) px; the
@@ -18,6 +19,8 @@ var ScrollScale = class {
 	#cap = Infinity;
 	/** The logical offset last written and the physical offset it landed on. */
 	#landed;
+	/** A point the mapping passes through instead of the straight line (see `pivot`). */
+	#pivot;
 	/**
 	* `logical`: the height of all body rows in px. `cap`: the tallest body the
 	* engine renders. Returns whether anything changed.
@@ -27,8 +30,28 @@ var ScrollScale = class {
 		this.#logical = logical;
 		this.#cap = cap;
 		this.#landed = void 0;
+		this.#pivot = void 0;
 		return true;
 	}
+	/**
+	* Bends the mapping so that the physical offset `physical` maps to `logical`:
+	* linear from the top to that point and from there to the bottom. Measured row
+	* heights change the logical height of a scaled body while it scrolls; pivoting
+	* at the current offset keeps the rows in view where they are, without writing
+	* the scroll position (which would cut a scroll short). Call after
+	* `configure()`, which drops the pivot. Ignored at the ends of the range,
+	* where the straight line keeps the first and the last row reachable.
+	*/
+	pivot(physical, logical, range) {
+		this.#landed = void 0;
+		const total = range + this.excess;
+		const inside = this.scaled && physical > 1 && physical < range - 1 && logical > 0 && logical < total;
+		this.#pivot = inside ? {
+			physical,
+			logical,
+			range
+		} : void 0;
+	}
 	/** Whether the body is taller than the cap, so offsets are scaled. */
 	get scaled() {
 		return this.#logical > this.#cap;
@@ -46,13 +69,28 @@ var ScrollScale = class {
 		if (!this.scaled || range <= 0) return physical;
 		const landed = this.#landed;
 		if (landed?.physical === physical) return landed.logical;
-		return clamp(physical, range) * (range + this.excess) / range;
+		const total = range + this.excess;
+		const p = clamp(physical, range);
+		const pivot = this.#pivotFor(range);
+		if (!pivot) return p * total / range;
+		if (p <= pivot.physical) return p * pivot.logical / pivot.physical;
+		return pivot.logical + (p - pivot.physical) * (total - pivot.logical) / (range - pivot.physical);
 	}
 	/** The physical offset for a logical one, given the physical scroll range. */
 	toPhysical(logical, range) {
 		if (!this.scaled || range <= 0) return logical;
 		const total = range + this.excess;
-		return clamp(logical, total) * range / total;
+		const l = clamp(logical, total);
+		const pivot = this.#pivotFor(range);
+		if (!pivot) return l * range / total;
+		if (l <= pivot.logical) return l * pivot.physical / pivot.logical;
+		return pivot.physical + (l - pivot.logical) * (range - pivot.physical) / (total - pivot.logical);
+	}
+	/** The pivot, if it was set for this range and is still inside it. */
+	#pivotFor(range) {
+		const pivot = this.#pivot;
+		if (pivot?.range !== range || pivot.logical >= range + this.excess) return void 0;
+		return pivot;
 	}
 	/**
 	* Records that a write of the logical offset `logical` left the scroller at

package/dist/core/src/virtual/scroll-scale.js.map

@@ -1 +1 @@
-{"version":3,"file":"scroll-scale.js","names":[],"sources":["../../../../../core/src/virtual/scroll-scale.ts"],"sourcesContent":["/**\n * Maps the scroll position of a body that is too tall to render onto the rows.\n *\n * Engines limit an element's height (about 33.5M px in Chromium and WebKit, less\n * when zoomed; about 17.9M px in Firefox, which drops a taller element to 0). A\n * body taller than `cap` renders `cap` px tall, and the scroll position is scaled\n * linearly: the top of the physical scroll range is the first row, its bottom the\n * last. Offsets the virtualizer works with are logical (unscaled) px; the\n * scroller's `scrollTop` is physical. Under the cap the mapping is the identity.\n *\n * The scroll range is the scroller's: the body plus what scrolls with it (header,\n * pinned rows) minus the viewport, so pass the physical range,\n * `scrollHeight - clientHeight`. The logical range is longer by `excess`.\n */\nexport class ScrollScale {\n  #logical = 0;\n  #cap = Infinity;\n  /** The logical offset last written and the physical offset it landed on. */\n  #landed: { physical: number; logical: number } | undefined;\n\n  /**\n   * `logical`: the height of all body rows in px. `cap`: the tallest body the\n   * engine renders. Returns whether anything changed.\n   */\n  configure(logical: number, cap: number): boolean {\n    if (logical === this.#logical && cap === this.#cap) return false;\n    this.#logical = logical;\n    this.#cap = cap;\n    this.#landed = undefined;\n    return true;\n  }\n\n  /** Whether the body is taller than the cap, so offsets are scaled. */\n  get scaled(): boolean {\n    return this.#logical > this.#cap;\n  }\n\n  /** The body's rendered height in px. */\n  get size(): number {\n    return Math.min(this.#logical, this.#cap);\n  }\n\n  /** How much longer the logical scroll range is than the physical one. */\n  get excess(): number {\n    return this.#logical - this.size;\n  }\n\n  /** The logical offset for a physical one, given the physical scroll range. */\n  toLogical(physical: number, range: number): number {\n    if (!this.scaled || range <= 0) return physical;\n    const landed = this.#landed;\n    if (landed?.physical === physical) return landed.logical;\n    return (clamp(physical, range) * (range + this.excess)) / range;\n  }\n\n  /** The physical offset for a logical one, given the physical scroll range. */\n  toPhysical(logical: number, range: number): number {\n    if (!this.scaled || range <= 0) return logical;\n    const total = range + this.excess;\n    return (clamp(logical, total) * range) / total;\n  }\n\n  /**\n   * Records that a write of the logical offset `logical` left the scroller at\n   * `physical` (read back, after the engine's rounding), so reading that physical\n   * offset gives the exact logical one again. Without it a scaled offset could be\n   * off by up to the scale ratio, and a row scrolled to the top would sit under\n   * the header by a few px.\n   */\n  land(logical: number, physical: number): void {\n    this.#landed = this.scaled ? { physical, logical } : undefined;\n  }\n}\n\nconst clamp = (value: number, max: number) => Math.min(Math.max(value, 0), max);\n"],"mappings":";;;;;;;;;;;;;;;AAcA,IAAa,cAAb,MAAyB;CACvB,WAAW;CACX,OAAO;;CAEP;;;;;CAMA,UAAU,SAAiB,KAAsB;EAC/C,IAAI,YAAY,KAAK,YAAY,QAAQ,KAAK,MAAM,OAAO;EAC3D,KAAK,WAAW;EAChB,KAAK,OAAO;EACZ,KAAK,UAAU,KAAA;EACf,OAAO;CACT;;CAGA,IAAI,SAAkB;EACpB,OAAO,KAAK,WAAW,KAAK;CAC9B;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAK,IAAI,KAAK,UAAU,KAAK,IAAI;CAC1C;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAK,WAAW,KAAK;CAC9B;;CAGA,UAAU,UAAkB,OAAuB;EACjD,IAAI,CAAC,KAAK,UAAU,SAAS,GAAG,OAAO;EACvC,MAAM,SAAS,KAAK;EACpB,IAAI,QAAQ,aAAa,UAAU,OAAO,OAAO;EACjD,OAAQ,MAAM,UAAU,KAAK,KAAK,QAAQ,KAAK,UAAW;CAC5D;;CAGA,WAAW,SAAiB,OAAuB;EACjD,IAAI,CAAC,KAAK,UAAU,SAAS,GAAG,OAAO;EACvC,MAAM,QAAQ,QAAQ,KAAK;EAC3B,OAAQ,MAAM,SAAS,KAAK,IAAI,QAAS;CAC3C;;;;;;;;CASA,KAAK,SAAiB,UAAwB;EAC5C,KAAK,UAAU,KAAK,SAAS;GAAE;GAAU;EAAQ,IAAI,KAAA;CACvD;AACF;AAEA,IAAM,SAAS,OAAe,QAAgB,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC,GAAG,GAAG"}
+{"version":3,"file":"scroll-scale.js","names":[],"sources":["../../../../../core/src/virtual/scroll-scale.ts"],"sourcesContent":["/**\n * Maps the scroll position of a body that is too tall to render onto the rows.\n *\n * Engines limit an element's height (about 33.5M px in Chromium and WebKit, less\n * when zoomed; about 17.9M px in Firefox, which drops a taller element to 0, and\n * lets go of sticky elements past 8.95M px of scrolling, so 8M px there). A\n * body taller than `cap` renders `cap` px tall, and the scroll position is scaled\n * linearly: the top of the physical scroll range is the first row, its bottom the\n * last. Offsets the virtualizer works with are logical (unscaled) px; the\n * scroller's `scrollTop` is physical. Under the cap the mapping is the identity.\n *\n * The scroll range is the scroller's: the body plus what scrolls with it (header,\n * pinned rows) minus the viewport, so pass the physical range,\n * `scrollHeight - clientHeight`. The logical range is longer by `excess`.\n */\nexport class ScrollScale {\n  #logical = 0;\n  #cap = Infinity;\n  /** The logical offset last written and the physical offset it landed on. */\n  #landed: { physical: number; logical: number } | undefined;\n  /** A point the mapping passes through instead of the straight line (see `pivot`). */\n  #pivot: { physical: number; logical: number; range: number } | undefined;\n\n  /**\n   * `logical`: the height of all body rows in px. `cap`: the tallest body the\n   * engine renders. Returns whether anything changed.\n   */\n  configure(logical: number, cap: number): boolean {\n    if (logical === this.#logical && cap === this.#cap) return false;\n    this.#logical = logical;\n    this.#cap = cap;\n    this.#landed = undefined;\n    this.#pivot = undefined;\n    return true;\n  }\n\n  /**\n   * Bends the mapping so that the physical offset `physical` maps to `logical`:\n   * linear from the top to that point and from there to the bottom. Measured row\n   * heights change the logical height of a scaled body while it scrolls; pivoting\n   * at the current offset keeps the rows in view where they are, without writing\n   * the scroll position (which would cut a scroll short). Call after\n   * `configure()`, which drops the pivot. Ignored at the ends of the range,\n   * where the straight line keeps the first and the last row reachable.\n   */\n  pivot(physical: number, logical: number, range: number): void {\n    this.#landed = undefined;\n    const total = range + this.excess;\n    const inside =\n      this.scaled && physical > 1 && physical < range - 1 && logical > 0 && logical < total;\n    this.#pivot = inside ? { physical, logical, range } : undefined;\n  }\n\n  /** Whether the body is taller than the cap, so offsets are scaled. */\n  get scaled(): boolean {\n    return this.#logical > this.#cap;\n  }\n\n  /** The body's rendered height in px. */\n  get size(): number {\n    return Math.min(this.#logical, this.#cap);\n  }\n\n  /** How much longer the logical scroll range is than the physical one. */\n  get excess(): number {\n    return this.#logical - this.size;\n  }\n\n  /** The logical offset for a physical one, given the physical scroll range. */\n  toLogical(physical: number, range: number): number {\n    if (!this.scaled || range <= 0) return physical;\n    const landed = this.#landed;\n    if (landed?.physical === physical) return landed.logical;\n    const total = range + this.excess;\n    const p = clamp(physical, range);\n    const pivot = this.#pivotFor(range);\n    if (!pivot) return (p * total) / range;\n    if (p <= pivot.physical) return (p * pivot.logical) / pivot.physical;\n    return (\n      pivot.logical + ((p - pivot.physical) * (total - pivot.logical)) / (range - pivot.physical)\n    );\n  }\n\n  /** The physical offset for a logical one, given the physical scroll range. */\n  toPhysical(logical: number, range: number): number {\n    if (!this.scaled || range <= 0) return logical;\n    const total = range + this.excess;\n    const l = clamp(logical, total);\n    const pivot = this.#pivotFor(range);\n    if (!pivot) return (l * range) / total;\n    if (l <= pivot.logical) return (l * pivot.physical) / pivot.logical;\n    return (\n      pivot.physical + ((l - pivot.logical) * (range - pivot.physical)) / (total - pivot.logical)\n    );\n  }\n\n  /** The pivot, if it was set for this range and is still inside it. */\n  #pivotFor(range: number) {\n    const pivot = this.#pivot;\n    if (pivot?.range !== range || pivot.logical >= range + this.excess) return undefined;\n    return pivot;\n  }\n\n  /**\n   * Records that a write of the logical offset `logical` left the scroller at\n   * `physical` (read back, after the engine's rounding), so reading that physical\n   * offset gives the exact logical one again. Without it a scaled offset could be\n   * off by up to the scale ratio, and a row scrolled to the top would sit under\n   * the header by a few px.\n   */\n  land(logical: number, physical: number): void {\n    this.#landed = this.scaled ? { physical, logical } : undefined;\n  }\n}\n\nconst clamp = (value: number, max: number) => Math.min(Math.max(value, 0), max);\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,IAAa,cAAb,MAAyB;CACvB,WAAW;CACX,OAAO;;CAEP;;CAEA;;;;;CAMA,UAAU,SAAiB,KAAsB;EAC/C,IAAI,YAAY,KAAK,YAAY,QAAQ,KAAK,MAAM,OAAO;EAC3D,KAAK,WAAW;EAChB,KAAK,OAAO;EACZ,KAAK,UAAU,KAAA;EACf,KAAK,SAAS,KAAA;EACd,OAAO;CACT;;;;;;;;;;CAWA,MAAM,UAAkB,SAAiB,OAAqB;EAC5D,KAAK,UAAU,KAAA;EACf,MAAM,QAAQ,QAAQ,KAAK;EAC3B,MAAM,SACJ,KAAK,UAAU,WAAW,KAAK,WAAW,QAAQ,KAAK,UAAU,KAAK,UAAU;EAClF,KAAK,SAAS,SAAS;GAAE;GAAU;GAAS;EAAM,IAAI,KAAA;CACxD;;CAGA,IAAI,SAAkB;EACpB,OAAO,KAAK,WAAW,KAAK;CAC9B;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAK,IAAI,KAAK,UAAU,KAAK,IAAI;CAC1C;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAK,WAAW,KAAK;CAC9B;;CAGA,UAAU,UAAkB,OAAuB;EACjD,IAAI,CAAC,KAAK,UAAU,SAAS,GAAG,OAAO;EACvC,MAAM,SAAS,KAAK;EACpB,IAAI,QAAQ,aAAa,UAAU,OAAO,OAAO;EACjD,MAAM,QAAQ,QAAQ,KAAK;EAC3B,MAAM,IAAI,MAAM,UAAU,KAAK;EAC/B,MAAM,QAAQ,KAAK,UAAU,KAAK;EAClC,IAAI,CAAC,OAAO,OAAQ,IAAI,QAAS;EACjC,IAAI,KAAK,MAAM,UAAU,OAAQ,IAAI,MAAM,UAAW,MAAM;EAC5D,OACE,MAAM,WAAY,IAAI,MAAM,aAAa,QAAQ,MAAM,YAAa,QAAQ,MAAM;CAEtF;;CAGA,WAAW,SAAiB,OAAuB;EACjD,IAAI,CAAC,KAAK,UAAU,SAAS,GAAG,OAAO;EACvC,MAAM,QAAQ,QAAQ,KAAK;EAC3B,MAAM,IAAI,MAAM,SAAS,KAAK;EAC9B,MAAM,QAAQ,KAAK,UAAU,KAAK;EAClC,IAAI,CAAC,OAAO,OAAQ,IAAI,QAAS;EACjC,IAAI,KAAK,MAAM,SAAS,OAAQ,IAAI,MAAM,WAAY,MAAM;EAC5D,OACE,MAAM,YAAa,IAAI,MAAM,YAAY,QAAQ,MAAM,aAAc,QAAQ,MAAM;CAEvF;;CAGA,UAAU,OAAe;EACvB,MAAM,QAAQ,KAAK;EACnB,IAAI,OAAO,UAAU,SAAS,MAAM,WAAW,QAAQ,KAAK,QAAQ,OAAO,KAAA;EAC3E,OAAO;CACT;;;;;;;;CASA,KAAK,SAAiB,UAAwB;EAC5C,KAAK,UAAU,KAAK,SAAS;GAAE;GAAU;EAAQ,IAAI,KAAA;CACvD;AACF;AAEA,IAAM,SAAS,OAAe,QAAgB,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC,GAAG,GAAG"}