@datakable/core 2.0.3 → 2.1.1

package/dist/features/sorting/ranks.cjs

@@ -25,85 +25,152 @@ __export(ranks_exports, {
 module.exports = __toCommonJS(ranks_exports);
 var import_compare = require("./compare.cjs");
 var CHUNK = 4096;
-var RUN = 512;
-function* sortPositions(n, cmp) {
+var RUN = 1024;
+function* sortPositions(n, cmp, run) {
   let a = new Uint32Array(n);
+  let ea = new Uint8Array(n);
   for (let i = 0; i < n; i++) a[i] = i;
-  for (let lo = 0; lo < n; lo += RUN) {
-    a.subarray(lo, Math.min(lo + RUN, n)).sort(cmp);
+  for (let lo = 0; lo < n; lo += run) {
+    const hi = Math.min(lo + run, n);
+    let zero = false;
+    a.subarray(lo, hi).sort((x, y) => {
+      const c = cmp(x, y);
+      if (c === 0) zero = true;
+      return c;
+    });
+    if (zero)
+      for (let k = lo + 1; k < hi; k++) ea[k] = cmp(a[k - 1], a[k]) ? 0 : 1;
     yield;
   }
   let b = new Uint32Array(n);
+  let eb = new Uint8Array(n);
   let ops = 0;
-  for (let width = RUN; width < n; width *= 2) {
+  for (let width = run; width < n; width *= 2) {
     for (let lo = 0; lo < n; lo += 2 * width) {
       const mid = Math.min(lo + width, n);
       const hi = Math.min(lo + 2 * width, n);
       let i = lo;
       let j = mid;
-      let k = lo;
-      while (i < mid && j < hi) {
-        const x = a[i];
-        const y = a[j];
-        if (cmp(y, x) < 0) {
-          b[k++] = y;
-          j++;
-        } else {
-          b[k++] = x;
-          i++;
-        }
-        if (++ops === CHUNK) {
-          ops = 0;
-          yield;
-        }
+      let prev = -1;
+      let same = 0;
+      for (let k = lo; k < hi; k++) {
+        let c = 1;
+        let src;
+        if (i < mid && j < hi) {
+          c = cmp(a[j], a[i]);
+          src = c < 0 ? 1 : 0;
+          if (++ops === CHUNK) {
+            ops = 0;
+            yield;
+          }
+        } else src = i < mid ? 0 : 1;
+        const p = src ? j++ : i++;
+        b[k] = a[p];
+        eb[k] = prev === src ? ea[p] : prev < 0 ? 0 : same;
+        same = src === 0 && c === 0 ? 1 : 0;
+        prev = src;
       }
-      while (i < mid) b[k++] = a[i++];
-      while (j < hi) b[k++] = a[j++];
     }
     const t = a;
     a = b;
     b = t;
+    const e = ea;
+    ea = eb;
+    eb = e;
   }
-  return a;
+  return { order: a, eq: ea };
 }
-function* collationRanks(values, collator) {
+function* collationRanks(values, collator, prev = { values: [], ranks: [], reps: [] }) {
   const n = values.length;
-  const ids = /* @__PURE__ */ new Map();
-  const distinct = [];
-  const slot = new Int32Array(n);
+  const { values: was, ranks: wasRank, reps } = prev;
+  const m = reps.length;
+  const out = new Float64Array(n);
+  const used = new Uint8Array(m);
+  const freshIds = /* @__PURE__ */ new Map();
+  const fresh = [];
+  const gap = [];
+  let rowOf;
+  let shift = 0;
+  let ops = 0;
   for (let r = 0; r < n; r++) {
     const v = values[r];
     if (typeof v === "string") {
-      let id = ids.get(v);
-      if (id === void 0) {
-        id = distinct.length;
-        ids.set(v, id);
-        distinct.push(v);
+      let k;
+      const q = r + shift;
+      if (was[q] === v) k = wasRank[q];
+      else {
+        const id = freshIds.get(v);
+        if (id !== void 0) k = m + id;
+        else {
+          let lo = 0;
+          let hi = m;
+          while (lo < hi) {
+            const mid = lo + hi >>> 1;
+            const c = collator.compare(v, reps[mid]);
+            ops++;
+            if (c === 0) {
+              k = mid;
+              break;
+            }
+            if (c < 0) hi = mid;
+            else lo = mid + 1;
+          }
+          if (k === void 0) {
+            k = m + fresh.length;
+            freshIds.set(v, fresh.length);
+            fresh.push(v);
+            gap.push(lo - 0.5);
+          } else {
+            if (!rowOf) {
+              rowOf = new Int32Array(m);
+              for (let p = 0; p < was.length; p++) {
+                const x = wasRank[p];
+                if (!Number.isNaN(x)) rowOf[x] = p;
+              }
+            }
+            shift = rowOf[k] - r;
+          }
+        }
       }
-      slot[r] = id;
-    } else if ((0, import_compare.typeRank)(v) === import_compare.RANK.missing) slot[r] = -1;
+      if (k < m) used[k] = 1;
+      out[r] = k;
+    } else if ((0, import_compare.typeRank)(v) === import_compare.RANK.missing) out[r] = Number.NaN;
     else return null;
-    if (r % CHUNK === CHUNK - 1) yield;
+    if (++ops >= CHUNK) {
+      ops = 0;
+      yield;
+    }
   }
-  const order = yield* sortPositions(
-    distinct.length,
-    (a, b) => collator.compare(distinct[a], distinct[b])
+  if (!fresh.length && !used.includes(0)) return { ranks: out, state: { values, ranks: out, reps } };
+  const f = fresh.length;
+  const { order, eq } = yield* sortPositions(
+    f,
+    // By gap; two new strings in the same gap (cold: all of them) go to the collator.
+    (a, b) => gap[a] - gap[b] || collator.compare(fresh[a], fresh[b]),
+    // Comparing numbers is far cheaper: longer native runs, fewer merge passes.
+    m ? 8 * RUN : RUN
   );
-  const rankOf = new Float64Array(distinct.length);
-  let rank = 0;
-  for (let k = 0; k < order.length; k++) {
-    const id = order[k];
-    const s = distinct[id];
-    if (k > 0 && collator.compare(distinct[order[k - 1]], s) !== 0) rank++;
-    rankOf[id] = rank;
-    if (k % CHUNK === CHUNK - 1) yield;
+  const remap = new Float64Array(m + f);
+  const kept = [];
+  let rank = -1;
+  let j = 0;
+  for (let g = 0; g <= m; g++) {
+    while (j < f && gap[order[j]] < g) {
+      const id = order[j];
+      if (!eq[j]) kept[++rank] = fresh[id];
+      remap[m + id] = rank;
+      j++;
+    }
+    if (g < m && used[g]) {
+      kept[++rank] = reps[g];
+      remap[g] = rank;
+    }
   }
-  const out = new Float64Array(n);
   for (let r = 0; r < n; r++) {
-    const id = slot[r];
-    out[r] = id < 0 ? Number.NaN : rankOf[id];
+    const k = out[r];
+    if (!Number.isNaN(k)) out[r] = remap[k];
   }
-  return out;
+  return { ranks: out, state: { values, ranks: out, reps: kept } };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/features/sorting/ranks.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/features/sorting/ranks.ts"],"sourcesContent":["import { RANK, typeRank } from './compare'\n\n/** Comparisons / rows between two `yield`s of the jobs below (§9.1). */\nconst CHUNK = 4096\n/** Run length sorted natively before the merge passes. */\nconst RUN = 512\n\n/**\n * Sorts `0..n-1` by `cmp` as a time-sliced job (§9.1): native sorts of short runs, then bottom-up\n * merge passes that `yield` every {@link CHUNK} comparisons. Stable.\n */\nfunction* sortPositions(\n  n: number,\n  cmp: (a: number, b: number) => number,\n): Generator<undefined, Uint32Array, undefined> {\n  let a = new Uint32Array(n)\n  for (let i = 0; i < n; i++) a[i] = i\n  for (let lo = 0; lo < n; lo += RUN) {\n    a.subarray(lo, Math.min(lo + RUN, n)).sort(cmp)\n    yield\n  }\n  let b = new Uint32Array(n)\n  let ops = 0\n  for (let width = RUN; width < n; width *= 2) {\n    for (let lo = 0; lo < n; lo += 2 * width) {\n      const mid = Math.min(lo + width, n)\n      const hi = Math.min(lo + 2 * width, n)\n      let i = lo\n      let j = mid\n      let k = lo\n      while (i < mid && j < hi) {\n        const x = a[i] as number\n        const y = a[j] as number\n        if (cmp(y, x) < 0) {\n          b[k++] = y\n          j++\n        } else {\n          b[k++] = x\n          i++\n        }\n        if (++ops === CHUNK) {\n          ops = 0\n          yield\n        }\n      }\n      while (i < mid) b[k++] = a[i++] as number\n      while (j < hi) b[k++] = a[j++] as number\n    }\n    const t = a\n    a = b\n    b = t\n  }\n  return a\n}\n\n/**\n * Collation ranks of a string column (§6.4, §9.1): per row, the dense rank of its string among\n * the column's distinct strings in `collator` order (strings the collator finds equal share a\n * rank), `NaN` for a missing value. Sorting by these numbers gives exactly the order of\n * `collator.compare`, with integer keys (counting / radix sort) instead of a collator call per\n * comparison. A time-sliced job; `null` when a present value is not a string.\n */\nexport function* collationRanks(\n  values: readonly unknown[],\n  collator: Intl.Collator,\n): Generator<undefined, Float64Array | null, undefined> {\n  const n = values.length\n  const ids = new Map<string, number>()\n  const distinct: string[] = []\n  /** Per row: its string's position in `distinct`, -1 when missing. */\n  const slot = new Int32Array(n)\n  for (let r = 0; r < n; r++) {\n    const v = values[r]\n    if (typeof v === 'string') {\n      let id = ids.get(v)\n      if (id === undefined) {\n        id = distinct.length\n        ids.set(v, id)\n        distinct.push(v)\n      }\n      slot[r] = id\n    } else if (typeRank(v) === RANK.missing) slot[r] = -1\n    else return null\n    if (r % CHUNK === CHUNK - 1) yield\n  }\n  const order = yield* sortPositions(distinct.length, (a, b) =>\n    collator.compare(distinct[a] as string, distinct[b] as string),\n  )\n  const rankOf = new Float64Array(distinct.length)\n  let rank = 0\n  for (let k = 0; k < order.length; k++) {\n    const id = order[k] as number\n    const s = distinct[id] as string\n    if (k > 0 && collator.compare(distinct[order[k - 1] as number] as string, s) !== 0) rank++\n    rankOf[id] = rank\n    if (k % CHUNK === CHUNK - 1) yield\n  }\n  const out = new Float64Array(n)\n  for (let r = 0; r < n; r++) {\n    const id = slot[r] as number\n    out[r] = id < 0 ? Number.NaN : (rankOf[id] as number)\n  }\n  return out\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../../src/features/sorting/ranks.ts"],"sourcesContent":["import { RANK, typeRank } from './compare'\n\n/** Comparisons / rows between two `yield`s of the jobs below (§9.1). */\nconst CHUNK = 4096\n/**\n * Run length sorted natively before the merge passes (#97, was 512): each doubling saves a merge\n * pass, and one native run of collator calls stays within a slice even under a 4x CPU throttle.\n */\nconst RUN = 1024\n\n/**\n * Sorts `0..n-1` by `cmp` as a time-sliced job (§9.1): native sorts of `run`s, then bottom-up\n * merge passes that `yield` every {@link CHUNK} comparisons. Stable. Also returns `eq`:\n * `eq[k] = 1` when `order[k]` compares equal to `order[k - 1]`, from the comparisons the merges\n * make anyway (#97). Inside a native run it costs a second pass only when that sort saw a 0.\n */\nfunction* sortPositions(\n  n: number,\n  cmp: (a: number, b: number) => number,\n  run: number,\n): Generator<undefined, { order: Uint32Array; eq: Uint8Array }, undefined> {\n  let a = new Uint32Array(n)\n  let ea = new Uint8Array(n)\n  for (let i = 0; i < n; i++) a[i] = i\n  for (let lo = 0; lo < n; lo += run) {\n    const hi = Math.min(lo + run, n)\n    let zero = false\n    a.subarray(lo, hi).sort((x, y) => {\n      const c = cmp(x, y)\n      if (c === 0) zero = true\n      return c\n    })\n    // Neighbours can only be equal if the sort saw a 0 (it must, to order them).\n    if (zero)\n      for (let k = lo + 1; k < hi; k++) ea[k] = cmp(a[k - 1] as number, a[k] as number) ? 0 : 1\n    yield\n  }\n  let b = new Uint32Array(n)\n  let eb = new Uint8Array(n)\n  let ops = 0\n  for (let width = run; width < n; width *= 2) {\n    for (let lo = 0; lo < n; lo += 2 * width) {\n      const mid = Math.min(lo + width, n)\n      const hi = Math.min(lo + 2 * width, n)\n      let i = lo\n      let j = mid\n      // The run of the last output (-1: none yet) and whether it equals the other run's head.\n      let prev = -1\n      let same = 0\n      for (let k = lo; k < hi; k++) {\n        let c = 1\n        let src: number\n        if (i < mid && j < hi) {\n          c = cmp(a[j] as number, a[i] as number)\n          src = c < 0 ? 1 : 0\n          if (++ops === CHUNK) {\n            ops = 0\n            yield\n          }\n        } else src = i < mid ? 0 : 1\n        const p = src ? j++ : i++\n        b[k] = a[p] as number\n        eb[k] = prev === src ? (ea[p] as number) : prev < 0 ? 0 : same\n        same = src === 0 && c === 0 ? 1 : 0\n        prev = src\n      }\n    }\n    const t = a\n    a = b\n    b = t\n    const e = ea\n    ea = eb\n    eb = e\n  }\n  return { order: a, eq: ea }\n}\n\n/**\n * What the next {@link collationRanks} of the same column starts from (#95): the values it ranked,\n * their ranks (the `ranks` it returned, shared) and the distinct strings in rank order (one per\n * rank, shared with the data). No string → id map: a row whose string is unchanged at its position\n * (or at a shifted one) keeps its rank, any other string is found by binary search over `reps`.\n * Never mutated (a job builds a new one), so a cancelled job leaves it usable.\n */\nexport interface RankState {\n  readonly values: readonly unknown[]\n  readonly ranks: ArrayLike<number>\n  readonly reps: readonly string[]\n}\n\nexport interface Ranked {\n  readonly ranks: Float64Array\n  readonly state: RankState\n}\n\n/**\n * Collation ranks of a string column (§6.4, §9.1): per row, the dense rank of its string among\n * the column's distinct strings in `collator` order (strings the collator finds equal share a\n * rank), `NaN` for a missing value. Sorting by these numbers gives exactly the order of\n * `collator.compare`, with integer keys (counting / radix sort) instead of a collator call per\n * comparison. A time-sliced job; `null` when a present value is not a string.\n *\n * Incremental across data versions (#95): a string ranked in `prev` (the state of an earlier array\n * of the same column) keeps that rank as its sort key. It is read from the same row of `prev` when\n * the string is the same there (or at the row offset of the last match, for inserted / removed\n * rows), else found by binary search over the ranked strings; a new string is placed in the gap\n * below the first greater one. Only new strings are sorted (two in the same gap call the\n * collator): a one-row edit costs O(log d) collator calls (and a sort of numbers), not a cold\n * sort. The new state holds only the strings present now.\n */\nexport function* collationRanks(\n  values: readonly unknown[],\n  collator: Intl.Collator,\n  prev: RankState = { values: [], ranks: [], reps: [] },\n): Generator<undefined, Ranked | null, undefined> {\n  const n = values.length\n  const { values: was, ranks: wasRank, reps } = prev\n  const m = reps.length\n  /** Per row: its rank in `prev`, `m + id` for the new string `fresh[id]`, NaN when missing. */\n  const out = new Float64Array(n)\n  /** Ranks of `prev` still present (the rest are dropped from the new state). */\n  const used = new Uint8Array(m)\n  // New strings only (a cold job: every distinct string), dropped with the job.\n  const freshIds = new Map<string, number>()\n  const fresh: string[] = []\n  /** Per new string: `g - 0.5`, between ranks g-1 and g of `prev`. */\n  const gap: number[] = []\n  /** Per rank of `prev`: one row holding it, built on the first lookup that finds one. */\n  let rowOf: Int32Array | undefined\n  /** Offset to `prev`'s row of the last match: rows inserted / removed above shift it. */\n  let shift = 0\n  let ops = 0\n  for (let r = 0; r < n; r++) {\n    const v = values[r]\n    if (typeof v === 'string') {\n      let k: number | undefined\n      const q = r + shift\n      // Out of range: `undefined`, never a string.\n      if (was[q] === v) k = wasRank[q] as number\n      else {\n        const id = freshIds.get(v)\n        if (id !== undefined) k = m + id\n        else {\n          let lo = 0\n          let hi = m\n          while (lo < hi) {\n            const mid = (lo + hi) >>> 1\n            const c = collator.compare(v, reps[mid] as string)\n            ops++\n            if (c === 0) {\n              k = mid\n              break\n            }\n            if (c < 0) hi = mid\n            else lo = mid + 1\n          }\n          if (k === undefined) {\n            k = m + fresh.length\n            freshIds.set(v, fresh.length)\n            fresh.push(v)\n            gap.push(lo - 0.5)\n          } else {\n            if (!rowOf) {\n              rowOf = new Int32Array(m)\n              for (let p = 0; p < was.length; p++) {\n                const x = wasRank[p] as number\n                if (!Number.isNaN(x)) rowOf[x] = p\n              }\n            }\n            shift = (rowOf[k] as number) - r\n          }\n        }\n      }\n      if (k < m) used[k] = 1\n      out[r] = k\n    } else if (typeRank(v) === RANK.missing) out[r] = Number.NaN\n    else return null\n    if (++ops >= CHUNK) {\n      ops = 0\n      yield\n    }\n  }\n  // The same strings as `prev` (a new array of equal content, rows moved): the same ranks.\n  if (!fresh.length && !used.includes(0)) return { ranks: out, state: { values, ranks: out, reps } }\n\n  const f = fresh.length\n  const { order, eq } = yield* sortPositions(\n    f,\n    // By gap; two new strings in the same gap (cold: all of them) go to the collator.\n    (a, b) =>\n      (gap[a] as number) - (gap[b] as number) ||\n      collator.compare(fresh[a] as string, fresh[b] as string),\n    // Comparing numbers is far cheaper: longer native runs, fewer merge passes.\n    m ? 8 * RUN : RUN,\n  )\n  // Merge the kept ranks of `prev` and the new strings (each before the rank above its gap). No\n  // collator call: one pass, like the rank lookup below.\n  const remap = new Float64Array(m + f)\n  const kept: string[] = []\n  let rank = -1\n  let j = 0\n  for (let g = 0; g <= m; g++) {\n    while (j < f && (gap[order[j] as number] as number) < g) {\n      const id = order[j] as number\n      if (!eq[j]) kept[++rank] = fresh[id] as string\n      remap[m + id] = rank\n      j++\n    }\n    if (g < m && used[g]) {\n      kept[++rank] = reps[g] as string\n      remap[g] = rank\n    }\n  }\n  for (let r = 0; r < n; r++) {\n    const k = out[r] as number\n    if (!Number.isNaN(k)) out[r] = remap[k] as number\n  }\n  return { ranks: out, state: { values, ranks: out, reps: kept } }\n}\n"],"mappings":"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","names":[]}

package/dist/features/sorting/ranks.js

@@ -1,85 +1,152 @@
 // src/features/sorting/ranks.ts
 import { RANK, typeRank } from "./compare.js";
 var CHUNK = 4096;
-var RUN = 512;
-function* sortPositions(n, cmp) {
+var RUN = 1024;
+function* sortPositions(n, cmp, run) {
   let a = new Uint32Array(n);
+  let ea = new Uint8Array(n);
   for (let i = 0; i < n; i++) a[i] = i;
-  for (let lo = 0; lo < n; lo += RUN) {
-    a.subarray(lo, Math.min(lo + RUN, n)).sort(cmp);
+  for (let lo = 0; lo < n; lo += run) {
+    const hi = Math.min(lo + run, n);
+    let zero = false;
+    a.subarray(lo, hi).sort((x, y) => {
+      const c = cmp(x, y);
+      if (c === 0) zero = true;
+      return c;
+    });
+    if (zero)
+      for (let k = lo + 1; k < hi; k++) ea[k] = cmp(a[k - 1], a[k]) ? 0 : 1;
     yield;
   }
   let b = new Uint32Array(n);
+  let eb = new Uint8Array(n);
   let ops = 0;
-  for (let width = RUN; width < n; width *= 2) {
+  for (let width = run; width < n; width *= 2) {
     for (let lo = 0; lo < n; lo += 2 * width) {
       const mid = Math.min(lo + width, n);
       const hi = Math.min(lo + 2 * width, n);
       let i = lo;
       let j = mid;
-      let k = lo;
-      while (i < mid && j < hi) {
-        const x = a[i];
-        const y = a[j];
-        if (cmp(y, x) < 0) {
-          b[k++] = y;
-          j++;
-        } else {
-          b[k++] = x;
-          i++;
-        }
-        if (++ops === CHUNK) {
-          ops = 0;
-          yield;
-        }
+      let prev = -1;
+      let same = 0;
+      for (let k = lo; k < hi; k++) {
+        let c = 1;
+        let src;
+        if (i < mid && j < hi) {
+          c = cmp(a[j], a[i]);
+          src = c < 0 ? 1 : 0;
+          if (++ops === CHUNK) {
+            ops = 0;
+            yield;
+          }
+        } else src = i < mid ? 0 : 1;
+        const p = src ? j++ : i++;
+        b[k] = a[p];
+        eb[k] = prev === src ? ea[p] : prev < 0 ? 0 : same;
+        same = src === 0 && c === 0 ? 1 : 0;
+        prev = src;
       }
-      while (i < mid) b[k++] = a[i++];
-      while (j < hi) b[k++] = a[j++];
     }
     const t = a;
     a = b;
     b = t;
+    const e = ea;
+    ea = eb;
+    eb = e;
   }
-  return a;
+  return { order: a, eq: ea };
 }
-function* collationRanks(values, collator) {
+function* collationRanks(values, collator, prev = { values: [], ranks: [], reps: [] }) {
   const n = values.length;
-  const ids = /* @__PURE__ */ new Map();
-  const distinct = [];
-  const slot = new Int32Array(n);
+  const { values: was, ranks: wasRank, reps } = prev;
+  const m = reps.length;
+  const out = new Float64Array(n);
+  const used = new Uint8Array(m);
+  const freshIds = /* @__PURE__ */ new Map();
+  const fresh = [];
+  const gap = [];
+  let rowOf;
+  let shift = 0;
+  let ops = 0;
   for (let r = 0; r < n; r++) {
     const v = values[r];
     if (typeof v === "string") {
-      let id = ids.get(v);
-      if (id === void 0) {
-        id = distinct.length;
-        ids.set(v, id);
-        distinct.push(v);
+      let k;
+      const q = r + shift;
+      if (was[q] === v) k = wasRank[q];
+      else {
+        const id = freshIds.get(v);
+        if (id !== void 0) k = m + id;
+        else {
+          let lo = 0;
+          let hi = m;
+          while (lo < hi) {
+            const mid = lo + hi >>> 1;
+            const c = collator.compare(v, reps[mid]);
+            ops++;
+            if (c === 0) {
+              k = mid;
+              break;
+            }
+            if (c < 0) hi = mid;
+            else lo = mid + 1;
+          }
+          if (k === void 0) {
+            k = m + fresh.length;
+            freshIds.set(v, fresh.length);
+            fresh.push(v);
+            gap.push(lo - 0.5);
+          } else {
+            if (!rowOf) {
+              rowOf = new Int32Array(m);
+              for (let p = 0; p < was.length; p++) {
+                const x = wasRank[p];
+                if (!Number.isNaN(x)) rowOf[x] = p;
+              }
+            }
+            shift = rowOf[k] - r;
+          }
+        }
       }
-      slot[r] = id;
-    } else if (typeRank(v) === RANK.missing) slot[r] = -1;
+      if (k < m) used[k] = 1;
+      out[r] = k;
+    } else if (typeRank(v) === RANK.missing) out[r] = Number.NaN;
     else return null;
-    if (r % CHUNK === CHUNK - 1) yield;
+    if (++ops >= CHUNK) {
+      ops = 0;
+      yield;
+    }
   }
-  const order = yield* sortPositions(
-    distinct.length,
-    (a, b) => collator.compare(distinct[a], distinct[b])
+  if (!fresh.length && !used.includes(0)) return { ranks: out, state: { values, ranks: out, reps } };
+  const f = fresh.length;
+  const { order, eq } = yield* sortPositions(
+    f,
+    // By gap; two new strings in the same gap (cold: all of them) go to the collator.
+    (a, b) => gap[a] - gap[b] || collator.compare(fresh[a], fresh[b]),
+    // Comparing numbers is far cheaper: longer native runs, fewer merge passes.
+    m ? 8 * RUN : RUN
   );
-  const rankOf = new Float64Array(distinct.length);
-  let rank = 0;
-  for (let k = 0; k < order.length; k++) {
-    const id = order[k];
-    const s = distinct[id];
-    if (k > 0 && collator.compare(distinct[order[k - 1]], s) !== 0) rank++;
-    rankOf[id] = rank;
-    if (k % CHUNK === CHUNK - 1) yield;
+  const remap = new Float64Array(m + f);
+  const kept = [];
+  let rank = -1;
+  let j = 0;
+  for (let g = 0; g <= m; g++) {
+    while (j < f && gap[order[j]] < g) {
+      const id = order[j];
+      if (!eq[j]) kept[++rank] = fresh[id];
+      remap[m + id] = rank;
+      j++;
+    }
+    if (g < m && used[g]) {
+      kept[++rank] = reps[g];
+      remap[g] = rank;
+    }
   }
-  const out = new Float64Array(n);
   for (let r = 0; r < n; r++) {
-    const id = slot[r];
-    out[r] = id < 0 ? Number.NaN : rankOf[id];
+    const k = out[r];
+    if (!Number.isNaN(k)) out[r] = remap[k];
   }
-  return out;
+  return { ranks: out, state: { values, ranks: out, reps: kept } };
 }
 export {
   collationRanks

package/dist/features/sorting/ranks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/features/sorting/ranks.ts"],"sourcesContent":["import { RANK, typeRank } from './compare'\n\n/** Comparisons / rows between two `yield`s of the jobs below (§9.1). */\nconst CHUNK = 4096\n/** Run length sorted natively before the merge passes. */\nconst RUN = 512\n\n/**\n * Sorts `0..n-1` by `cmp` as a time-sliced job (§9.1): native sorts of short runs, then bottom-up\n * merge passes that `yield` every {@link CHUNK} comparisons. Stable.\n */\nfunction* sortPositions(\n  n: number,\n  cmp: (a: number, b: number) => number,\n): Generator<undefined, Uint32Array, undefined> {\n  let a = new Uint32Array(n)\n  for (let i = 0; i < n; i++) a[i] = i\n  for (let lo = 0; lo < n; lo += RUN) {\n    a.subarray(lo, Math.min(lo + RUN, n)).sort(cmp)\n    yield\n  }\n  let b = new Uint32Array(n)\n  let ops = 0\n  for (let width = RUN; width < n; width *= 2) {\n    for (let lo = 0; lo < n; lo += 2 * width) {\n      const mid = Math.min(lo + width, n)\n      const hi = Math.min(lo + 2 * width, n)\n      let i = lo\n      let j = mid\n      let k = lo\n      while (i < mid && j < hi) {\n        const x = a[i] as number\n        const y = a[j] as number\n        if (cmp(y, x) < 0) {\n          b[k++] = y\n          j++\n        } else {\n          b[k++] = x\n          i++\n        }\n        if (++ops === CHUNK) {\n          ops = 0\n          yield\n        }\n      }\n      while (i < mid) b[k++] = a[i++] as number\n      while (j < hi) b[k++] = a[j++] as number\n    }\n    const t = a\n    a = b\n    b = t\n  }\n  return a\n}\n\n/**\n * Collation ranks of a string column (§6.4, §9.1): per row, the dense rank of its string among\n * the column's distinct strings in `collator` order (strings the collator finds equal share a\n * rank), `NaN` for a missing value. Sorting by these numbers gives exactly the order of\n * `collator.compare`, with integer keys (counting / radix sort) instead of a collator call per\n * comparison. A time-sliced job; `null` when a present value is not a string.\n */\nexport function* collationRanks(\n  values: readonly unknown[],\n  collator: Intl.Collator,\n): Generator<undefined, Float64Array | null, undefined> {\n  const n = values.length\n  const ids = new Map<string, number>()\n  const distinct: string[] = []\n  /** Per row: its string's position in `distinct`, -1 when missing. */\n  const slot = new Int32Array(n)\n  for (let r = 0; r < n; r++) {\n    const v = values[r]\n    if (typeof v === 'string') {\n      let id = ids.get(v)\n      if (id === undefined) {\n        id = distinct.length\n        ids.set(v, id)\n        distinct.push(v)\n      }\n      slot[r] = id\n    } else if (typeRank(v) === RANK.missing) slot[r] = -1\n    else return null\n    if (r % CHUNK === CHUNK - 1) yield\n  }\n  const order = yield* sortPositions(distinct.length, (a, b) =>\n    collator.compare(distinct[a] as string, distinct[b] as string),\n  )\n  const rankOf = new Float64Array(distinct.length)\n  let rank = 0\n  for (let k = 0; k < order.length; k++) {\n    const id = order[k] as number\n    const s = distinct[id] as string\n    if (k > 0 && collator.compare(distinct[order[k - 1] as number] as string, s) !== 0) rank++\n    rankOf[id] = rank\n    if (k % CHUNK === CHUNK - 1) yield\n  }\n  const out = new Float64Array(n)\n  for (let r = 0; r < n; r++) {\n    const id = slot[r] as number\n    out[r] = id < 0 ? Number.NaN : (rankOf[id] as number)\n  }\n  return out\n}\n"],"mappings":";AAAA,SAAS,MAAM,gBAAgB;AAG/B,IAAM,QAAQ;AAEd,IAAM,MAAM;AAMZ,UAAU,cACR,GACA,KAC8C;AAC9C,MAAI,IAAI,IAAI,YAAY,CAAC;AACzB,WAAS,IAAI,GAAG,IAAI,GAAG,IAAK,GAAE,CAAC,IAAI;AACnC,WAAS,KAAK,GAAG,KAAK,GAAG,MAAM,KAAK;AAClC,MAAE,SAAS,IAAI,KAAK,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG;AAC9C;AAAA,EACF;AACA,MAAI,IAAI,IAAI,YAAY,CAAC;AACzB,MAAI,MAAM;AACV,WAAS,QAAQ,KAAK,QAAQ,GAAG,SAAS,GAAG;AAC3C,aAAS,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI,OAAO;AACxC,YAAM,MAAM,KAAK,IAAI,KAAK,OAAO,CAAC;AAClC,YAAM,KAAK,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC;AACrC,UAAI,IAAI;AACR,UAAI,IAAI;AACR,UAAI,IAAI;AACR,aAAO,IAAI,OAAO,IAAI,IAAI;AACxB,cAAM,IAAI,EAAE,CAAC;AACb,cAAM,IAAI,EAAE,CAAC;AACb,YAAI,IAAI,GAAG,CAAC,IAAI,GAAG;AACjB,YAAE,GAAG,IAAI;AACT;AAAA,QACF,OAAO;AACL,YAAE,GAAG,IAAI;AACT;AAAA,QACF;AACA,YAAI,EAAE,QAAQ,OAAO;AACnB,gBAAM;AACN;AAAA,QACF;AAAA,MACF;AACA,aAAO,IAAI,IAAK,GAAE,GAAG,IAAI,EAAE,GAAG;AAC9B,aAAO,IAAI,GAAI,GAAE,GAAG,IAAI,EAAE,GAAG;AAAA,IAC/B;AACA,UAAM,IAAI;AACV,QAAI;AACJ,QAAI;AAAA,EACN;AACA,SAAO;AACT;AASO,UAAU,eACf,QACA,UACsD;AACtD,QAAM,IAAI,OAAO;AACjB,QAAM,MAAM,oBAAI,IAAoB;AACpC,QAAM,WAAqB,CAAC;AAE5B,QAAM,OAAO,IAAI,WAAW,CAAC;AAC7B,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,OAAO,MAAM,UAAU;AACzB,UAAI,KAAK,IAAI,IAAI,CAAC;AAClB,UAAI,OAAO,QAAW;AACpB,aAAK,SAAS;AACd,YAAI,IAAI,GAAG,EAAE;AACb,iBAAS,KAAK,CAAC;AAAA,MACjB;AACA,WAAK,CAAC,IAAI;AAAA,IACZ,WAAW,SAAS,CAAC,MAAM,KAAK,QAAS,MAAK,CAAC,IAAI;AAAA,QAC9C,QAAO;AACZ,QAAI,IAAI,UAAU,QAAQ,EAAG;AAAA,EAC/B;AACA,QAAM,QAAQ,OAAO;AAAA,IAAc,SAAS;AAAA,IAAQ,CAAC,GAAG,MACtD,SAAS,QAAQ,SAAS,CAAC,GAAa,SAAS,CAAC,CAAW;AAAA,EAC/D;AACA,QAAM,SAAS,IAAI,aAAa,SAAS,MAAM;AAC/C,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,KAAK,MAAM,CAAC;AAClB,UAAM,IAAI,SAAS,EAAE;AACrB,QAAI,IAAI,KAAK,SAAS,QAAQ,SAAS,MAAM,IAAI,CAAC,CAAW,GAAa,CAAC,MAAM,EAAG;AACpF,WAAO,EAAE,IAAI;AACb,QAAI,IAAI,UAAU,QAAQ,EAAG;AAAA,EAC/B;AACA,QAAM,MAAM,IAAI,aAAa,CAAC;AAC9B,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,UAAM,KAAK,KAAK,CAAC;AACjB,QAAI,CAAC,IAAI,KAAK,IAAI,OAAO,MAAO,OAAO,EAAE;AAAA,EAC3C;AACA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../../src/features/sorting/ranks.ts"],"sourcesContent":["import { RANK, typeRank } from './compare'\n\n/** Comparisons / rows between two `yield`s of the jobs below (§9.1). */\nconst CHUNK = 4096\n/**\n * Run length sorted natively before the merge passes (#97, was 512): each doubling saves a merge\n * pass, and one native run of collator calls stays within a slice even under a 4x CPU throttle.\n */\nconst RUN = 1024\n\n/**\n * Sorts `0..n-1` by `cmp` as a time-sliced job (§9.1): native sorts of `run`s, then bottom-up\n * merge passes that `yield` every {@link CHUNK} comparisons. Stable. Also returns `eq`:\n * `eq[k] = 1` when `order[k]` compares equal to `order[k - 1]`, from the comparisons the merges\n * make anyway (#97). Inside a native run it costs a second pass only when that sort saw a 0.\n */\nfunction* sortPositions(\n  n: number,\n  cmp: (a: number, b: number) => number,\n  run: number,\n): Generator<undefined, { order: Uint32Array; eq: Uint8Array }, undefined> {\n  let a = new Uint32Array(n)\n  let ea = new Uint8Array(n)\n  for (let i = 0; i < n; i++) a[i] = i\n  for (let lo = 0; lo < n; lo += run) {\n    const hi = Math.min(lo + run, n)\n    let zero = false\n    a.subarray(lo, hi).sort((x, y) => {\n      const c = cmp(x, y)\n      if (c === 0) zero = true\n      return c\n    })\n    // Neighbours can only be equal if the sort saw a 0 (it must, to order them).\n    if (zero)\n      for (let k = lo + 1; k < hi; k++) ea[k] = cmp(a[k - 1] as number, a[k] as number) ? 0 : 1\n    yield\n  }\n  let b = new Uint32Array(n)\n  let eb = new Uint8Array(n)\n  let ops = 0\n  for (let width = run; width < n; width *= 2) {\n    for (let lo = 0; lo < n; lo += 2 * width) {\n      const mid = Math.min(lo + width, n)\n      const hi = Math.min(lo + 2 * width, n)\n      let i = lo\n      let j = mid\n      // The run of the last output (-1: none yet) and whether it equals the other run's head.\n      let prev = -1\n      let same = 0\n      for (let k = lo; k < hi; k++) {\n        let c = 1\n        let src: number\n        if (i < mid && j < hi) {\n          c = cmp(a[j] as number, a[i] as number)\n          src = c < 0 ? 1 : 0\n          if (++ops === CHUNK) {\n            ops = 0\n            yield\n          }\n        } else src = i < mid ? 0 : 1\n        const p = src ? j++ : i++\n        b[k] = a[p] as number\n        eb[k] = prev === src ? (ea[p] as number) : prev < 0 ? 0 : same\n        same = src === 0 && c === 0 ? 1 : 0\n        prev = src\n      }\n    }\n    const t = a\n    a = b\n    b = t\n    const e = ea\n    ea = eb\n    eb = e\n  }\n  return { order: a, eq: ea }\n}\n\n/**\n * What the next {@link collationRanks} of the same column starts from (#95): the values it ranked,\n * their ranks (the `ranks` it returned, shared) and the distinct strings in rank order (one per\n * rank, shared with the data). No string → id map: a row whose string is unchanged at its position\n * (or at a shifted one) keeps its rank, any other string is found by binary search over `reps`.\n * Never mutated (a job builds a new one), so a cancelled job leaves it usable.\n */\nexport interface RankState {\n  readonly values: readonly unknown[]\n  readonly ranks: ArrayLike<number>\n  readonly reps: readonly string[]\n}\n\nexport interface Ranked {\n  readonly ranks: Float64Array\n  readonly state: RankState\n}\n\n/**\n * Collation ranks of a string column (§6.4, §9.1): per row, the dense rank of its string among\n * the column's distinct strings in `collator` order (strings the collator finds equal share a\n * rank), `NaN` for a missing value. Sorting by these numbers gives exactly the order of\n * `collator.compare`, with integer keys (counting / radix sort) instead of a collator call per\n * comparison. A time-sliced job; `null` when a present value is not a string.\n *\n * Incremental across data versions (#95): a string ranked in `prev` (the state of an earlier array\n * of the same column) keeps that rank as its sort key. It is read from the same row of `prev` when\n * the string is the same there (or at the row offset of the last match, for inserted / removed\n * rows), else found by binary search over the ranked strings; a new string is placed in the gap\n * below the first greater one. Only new strings are sorted (two in the same gap call the\n * collator): a one-row edit costs O(log d) collator calls (and a sort of numbers), not a cold\n * sort. The new state holds only the strings present now.\n */\nexport function* collationRanks(\n  values: readonly unknown[],\n  collator: Intl.Collator,\n  prev: RankState = { values: [], ranks: [], reps: [] },\n): Generator<undefined, Ranked | null, undefined> {\n  const n = values.length\n  const { values: was, ranks: wasRank, reps } = prev\n  const m = reps.length\n  /** Per row: its rank in `prev`, `m + id` for the new string `fresh[id]`, NaN when missing. */\n  const out = new Float64Array(n)\n  /** Ranks of `prev` still present (the rest are dropped from the new state). */\n  const used = new Uint8Array(m)\n  // New strings only (a cold job: every distinct string), dropped with the job.\n  const freshIds = new Map<string, number>()\n  const fresh: string[] = []\n  /** Per new string: `g - 0.5`, between ranks g-1 and g of `prev`. */\n  const gap: number[] = []\n  /** Per rank of `prev`: one row holding it, built on the first lookup that finds one. */\n  let rowOf: Int32Array | undefined\n  /** Offset to `prev`'s row of the last match: rows inserted / removed above shift it. */\n  let shift = 0\n  let ops = 0\n  for (let r = 0; r < n; r++) {\n    const v = values[r]\n    if (typeof v === 'string') {\n      let k: number | undefined\n      const q = r + shift\n      // Out of range: `undefined`, never a string.\n      if (was[q] === v) k = wasRank[q] as number\n      else {\n        const id = freshIds.get(v)\n        if (id !== undefined) k = m + id\n        else {\n          let lo = 0\n          let hi = m\n          while (lo < hi) {\n            const mid = (lo + hi) >>> 1\n            const c = collator.compare(v, reps[mid] as string)\n            ops++\n            if (c === 0) {\n              k = mid\n              break\n            }\n            if (c < 0) hi = mid\n            else lo = mid + 1\n          }\n          if (k === undefined) {\n            k = m + fresh.length\n            freshIds.set(v, fresh.length)\n            fresh.push(v)\n            gap.push(lo - 0.5)\n          } else {\n            if (!rowOf) {\n              rowOf = new Int32Array(m)\n              for (let p = 0; p < was.length; p++) {\n                const x = wasRank[p] as number\n                if (!Number.isNaN(x)) rowOf[x] = p\n              }\n            }\n            shift = (rowOf[k] as number) - r\n          }\n        }\n      }\n      if (k < m) used[k] = 1\n      out[r] = k\n    } else if (typeRank(v) === RANK.missing) out[r] = Number.NaN\n    else return null\n    if (++ops >= CHUNK) {\n      ops = 0\n      yield\n    }\n  }\n  // The same strings as `prev` (a new array of equal content, rows moved): the same ranks.\n  if (!fresh.length && !used.includes(0)) return { ranks: out, state: { values, ranks: out, reps } }\n\n  const f = fresh.length\n  const { order, eq } = yield* sortPositions(\n    f,\n    // By gap; two new strings in the same gap (cold: all of them) go to the collator.\n    (a, b) =>\n      (gap[a] as number) - (gap[b] as number) ||\n      collator.compare(fresh[a] as string, fresh[b] as string),\n    // Comparing numbers is far cheaper: longer native runs, fewer merge passes.\n    m ? 8 * RUN : RUN,\n  )\n  // Merge the kept ranks of `prev` and the new strings (each before the rank above its gap). No\n  // collator call: one pass, like the rank lookup below.\n  const remap = new Float64Array(m + f)\n  const kept: string[] = []\n  let rank = -1\n  let j = 0\n  for (let g = 0; g <= m; g++) {\n    while (j < f && (gap[order[j] as number] as number) < g) {\n      const id = order[j] as number\n      if (!eq[j]) kept[++rank] = fresh[id] as string\n      remap[m + id] = rank\n      j++\n    }\n    if (g < m && used[g]) {\n      kept[++rank] = reps[g] as string\n      remap[g] = rank\n    }\n  }\n  for (let r = 0; r < n; r++) {\n    const k = out[r] as number\n    if (!Number.isNaN(k)) out[r] = remap[k] as number\n  }\n  return { ranks: out, state: { values, ranks: out, reps: kept } }\n}\n"],"mappings":"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","names":[]}

package/dist/features/sorting/sorting.cjs

@@ -39,6 +39,7 @@ var import_codes2 = require("../../intercept/codes.cjs");
 var import_columns = require("../../pipeline/columns.cjs");
 var import_env_codes = require("../../pipeline/env-codes.cjs");
 var import_indices = require("../../pipeline/indices.cjs");
+var import_release = require("../../pipeline/release.cjs");
 var import_slice = require("../../pipeline/slice.cjs");
 var import_mode = require("../../source/mode.cjs");
 var import_capability = require("../../versioning/capability.cjs");
@@ -162,19 +163,31 @@ var sorting = (opts = {}) => {
     }
     return collator;
   };
-  const rankKeys = /* @__PURE__ */ new WeakMap();
-  function ranksFor(ctx, values) {
+  let rankKeys = /* @__PURE__ */ new WeakMap();
+  let history = /* @__PURE__ */ new Map();
+  function keepHistory(by) {
+    for (const id of history.keys()) {
+      if (!by.some((e) => String(e.id) === id)) history.delete(id);
+    }
+  }
+  function ranksFor(ctx, id, values) {
     let key = rankKeys.get(values);
     if (!key) {
       key = {};
       rankKeys.set(values, key);
     }
     const c = getCollator(ctx.emit);
-    return (0, import_slice.sliced)(ctx, key, () => (0, import_ranks.collationRanks)(values, c));
+    const into = history;
+    return (0, import_slice.sliced)(ctx, key, function* () {
+      const r = yield* (0, import_ranks.collationRanks)(values, c, into.get(id));
+      if (!r) return null;
+      into.set(id, r.state);
+      return r.ranks;
+    });
   }
   let shown;
-  const sortByCache = /* @__PURE__ */ new WeakMap();
-  const pathCache = /* @__PURE__ */ new WeakMap();
+  let sortByCache = /* @__PURE__ */ new WeakMap();
+  let pathCache = /* @__PURE__ */ new WeakMap();
   let exsorted;
   const sortByFailures = new import_cell_batch.CellFailures();
   function sortByValues(ctx, col, sortBy) {
@@ -220,7 +233,7 @@ var sorting = (opts = {}) => {
     byId.set(id, out);
     return out;
   }
-  return (0, import_define.defineFeature)({
+  const feature = (0, import_define.defineFeature)({
     name: "sorting",
     stage: "sort",
     mode: opts.mode ?? "client",
@@ -258,6 +271,7 @@ var sorting = (opts = {}) => {
     },
     rowModel: (indices, state, ctx) => {
       const by = entriesOf(state);
+      keepHistory(by);
       if (by.length === 0 || indices.length < 2) {
         shown = void 0;
         return indices;
@@ -270,7 +284,7 @@ var sorting = (opts = {}) => {
         const sortBy = col && fnField(col.def, "sortBy");
         const values = sortBy ? sortByValues(ctx, col, sortBy) : ctx.getColumnValues(id) ?? pathValues(ctx, id);
         const sortFn = col && !sortBy ? fnField(col.def, "sortFn") : void 0;
-        return { col, desc: e.desc === true, values, sortFn, ranked: false };
+        return { id, col, desc: e.desc === true, values, sortFn, ranked: false };
       });
       if (process.env.NODE_ENV !== "production") {
         for (const e of entries) {
@@ -311,7 +325,7 @@ var sorting = (opts = {}) => {
         let computing = false;
         for (const e of entries) {
           if (e.sortFn || e.values instanceof Float64Array) continue;
-          const ranks = ranksFor(ctx, e.values);
+          const ranks = ranksFor(ctx, e.id, e.values);
           if (ranks === void 0) computing = true;
           else if (ranks) {
             e.values = ranks;
@@ -465,6 +479,16 @@ var sorting = (opts = {}) => {
       }
     }
   });
+  const internal = feature;
+  internal[import_release.RELEASE] = () => {
+    rankKeys = /* @__PURE__ */ new WeakMap();
+    history = /* @__PURE__ */ new Map();
+    shown = void 0;
+    sortByCache = /* @__PURE__ */ new WeakMap();
+    pathCache = /* @__PURE__ */ new WeakMap();
+  };
+  if (process.env.NODE_ENV !== "production") internal[import_release.PROBE] = () => ({ rankKeys, history, shown, sortByCache, pathCache });
+  return feature;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {