@hrforte/react-pivottable 1.1.0 → 2.1.0

package/README.md

@@ -0,0 +1,134 @@
+
+
+# Login npm
+npm login
+
+# Patch: 1.0.0 -> 1.0.1
+npm version patch
+
+# Minor: 1.0.0 -> 1.1.0
+npm version minor
+
+# Major: 1.0.0 -> 2.0.0
+npm version major
+
+# Build
+npm run build
+
+# Publish to npm 
+npm publish
+
+# View version
+npm view @hrforte/react-pivottable version
+
+# Large datasets (Web Worker)
+
+With large datasets (e.g. 200,000 records) pivot computation is offloaded to a
+Web Worker so the main thread (and the UI) stays responsive.
+
+## 1. Get the worker file
+
+The published package ships a **self-contained** worker bundle (no imports, no
+dependencies) at:
+
+```
+node_modules/@hrforte/react-pivottable/dist/pivot-worker.js
+```
+
+## 2. Copy it somewhere the browser can fetch
+
+`new Worker(url)` resolves `url` **against the page URL**, not against the
+bundle, and it must be served **same-origin**. So the file has to be copied to
+a public/static folder of your app - it is not enough to just install the
+package.
+
+```bash
+# copy into the folder that the dev server / web server exposes as static root
+mkdir -p public
+cp node_modules/@hrforte/react-pivottable/dist/pivot-worker.js public/
+
+# optional but recommended: keep it in sync automatically after install
+# package.json -> "scripts": { "postinstall": "node -e \"require('fs').copyFileSync('node_modules/@hrforte/react-pivottable/dist/pivot-worker.js','public/pivot-worker.js')\"" }
+```
+
+Where to put it per setup:
+
+| Setup | Target folder | `workerUrl` prop |
+| --- | --- | --- |
+| Plain static site / webpack (this repo) | `examples/` (next to `index.html`) | not needed (default) |
+| Create React App | `public/` | not needed (default) |
+| Vite | `public/` | not needed (default) |
+| Next.js (app or pages) | `public/` | not needed (default) |
+| Page in a sub-folder (`/admin/report.html`) | `/admin/pivot-worker.js` | `workerUrl="/admin/pivot-worker.js"` |
+| App deployed under a sub-path (`/myapp/`) | root of that base path | `workerUrl="/myapp/pivot-worker.js"` |
+| Worker hosted elsewhere (CDN) | - | must be same-origin, see below |
+
+## 3. Pass `workerUrl` (only when the default does not match)
+
+```jsx
+<PivotTableUI
+  data={rows}
+  workerUrl="/myapp/pivot-worker.js"   // absolute web-root path (sub-path deploy)
+  // or a relative path resolved against the page URL:
+  // workerUrl="assets/js/pivot-worker.js"
+  // or a full URL on the SAME origin:
+  // workerUrl={`${window.location.origin}/static/pivot-worker.js`}
+/>
+```
+
+Accepted forms (all verified):
+
+| Value | Resolved by the browser as | Use when |
+| --- | --- | --- |
+| `'pivot-worker.js'` (default) | `<page-directory>/pivot-worker.js` | file sits next to the page |
+| `'assets/js/pivot-worker.js'` | `<page-directory>/assets/js/...` | nested static folder |
+| `'/myapp/pivot-worker.js'` | origin root + `/myapp/...` | app served under a sub-path |
+| `'https://cdn.example.com/pivot-worker.js'` | absolute | same-origin only (CORS does not apply to `new Worker`) |
+
+Notes:
+
+- A worker script must be **same-origin** by default. Cross-origin URLs only
+  work if the server sends CORS headers (`Access-Control-Allow-Origin`) and the
+  browser allows it - support varies, so prefer serving the file from your own
+  origin. If you must host it elsewhere, fetch the script yourself and pass a
+  `Blob` URL as `workerUrl`.
+- Changing `workerUrl` at runtime is supported: the previous worker is
+  terminated, a new one is created from the new URL and the current dataset is
+  staged on it again.
+- If you bundle the worker yourself, pass the emitted URL, e.g. with Vite:
+  `import workerUrl from '@hrforte/react-pivottable/dist/pivot-worker.js?url'`
+  then `workerUrl={workerUrl}`.
+
+## 4. Fallback
+
+If the worker file cannot be loaded (404, blocked, old browser), the component
+automatically falls back to the previous synchronous computation: same results,
+but the main thread is used. Verify with `workerDebug`:
+
+```
+[pivottable worker] worker created: /myapp/pivot-worker.js
+[pivottable worker] #1 dispatching to worker (dataKey=..., staging 1500 records, ...)
+[pivottable worker] (in worker) #1 computed in 25ms (rowKeys: 4, colKeys: 3, ...)
+[pivottable worker] #1 result received in 86ms { totalRecords: 1500, ... }
+```
+
+## Available props
+
+- `enableWorker` (`bool`, default `true`): disable to always compute on the
+  main thread.
+- `workerThreshold` (`number`, default `DEFAULT_WORKER_THRESHOLD`, currently
+  `200` in this build): minimum number of records required before using the
+  worker.
+- `workerUrl` (`string`, default `'pivot-worker.js'`): URL of the worker bundle
+  (see above).
+- `workerDebug` (`bool`, default `false`): prints the whole worker pipeline
+  (worker creation, data staging, progress, compute, result, errors and the
+  fallback to the main thread) to the browser console with a
+  `[pivottable worker]` prefix. Logs emitted inside the worker thread are
+  forwarded to the page console as well. Can also be enabled globally with
+  `window.__PVT_WORKER_DEBUG__ = true`.
+- `isShowProcessing` (`bool`, default `false`): testing/debugging hook. When
+  `true` the loading overlay is forced on top of the table even if nothing is
+  being computed, so the `PivotLoadingOverlay` can be inspected without
+  generating a large dataset. A sample progress value is supplied so the
+  progress bar and percentage are rendered as well.

package/dist/PivotDataWorker.js

@@ -0,0 +1,264 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_WORKER_URL = undefined;
+exports.setWorkerDebug = setWorkerDebug;
+exports.configureWorkerUrl = configureWorkerUrl;
+exports.computePivotInWorker = computePivotInWorker;
+exports.computePivotSynchronously = computePivotSynchronously;
+exports.computePivotWithFallback = computePivotWithFallback;
+
+var _pivotCompute = require('./pivotCompute');
+
+var DEFAULT_WORKER_URL = exports.DEFAULT_WORKER_URL = 'pivot-worker.js'; /* eslint-disable valid-jsdoc */
+/* eslint-disable no-console */
+/* eslint-disable no-undefined */
+/*
+ * Main-thread client for the pivot Web Worker (src/pivotWorker.js).
+ *
+ * Responsibilities:
+ *   - lazily create a single shared Worker (at `workerUrl`, overrideable),
+ *   - route progress/result/error messages to the matching request,
+ *   - transparently fall back to a synchronous main-thread computation when
+ *     workers are unavailable or the worker bundle fails to load.
+ *
+ * Debug logging is off by default. Turn it on with the `workerDebug` prop of
+ * PivotTableUI (or by setting `window.__PVT_WORKER_DEBUG__ = true` before
+ * rendering) to trace worker creation, staging, computation, progress,
+ * results, errors and fallbacks in the browser console.
+ */
+
+
+var REQUEST_TIMEOUT_MS = 300000;
+
+var workerUrl = DEFAULT_WORKER_URL;
+var sharedWorker = null;
+// The worker is marked broken only if it fails before ever producing a
+// result (e.g. a 404 worker script); runtime hiccups later on just reject
+// the affected request and fall back once.
+var sharedWorkerBroken = false;
+var hasResultEver = false;
+var nextRequestId = 1;
+var lastStagedDataKey = null;
+var workerDebug = false;
+var pendingRequests = new Map();
+
+function setWorkerDebug(enabled) {
+  var next = Boolean(enabled);
+  var wasEnabled = workerDebug;
+  if (next === wasEnabled) {
+    return;
+  }
+  if (next) {
+    workerDebug = true;
+    log('debug logging enabled');
+  } else {
+    // Log while logging is still active, so the "disabled" notice is shown.
+    log('debug logging disabled');
+    workerDebug = false;
+  }
+  if (sharedWorker) {
+    sharedWorker.postMessage({ type: 'pivot:debug', enabled: workerDebug });
+  }
+}
+
+var isDebugEnabled = function isDebugEnabled() {
+  return workerDebug || typeof window !== 'undefined' && window.__PVT_WORKER_DEBUG__ === true;
+};
+
+function log() {
+  var _console;
+
+  if (!isDebugEnabled()) {
+    return;
+  }
+
+  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  (_console = console).log.apply(_console, ['%c[pivottable worker]', 'color:#ff6600;font-weight:bold'].concat(args));
+}
+
+var describeConfig = function describeConfig(config) {
+  return 'rows=[' + (config.rows || []).join(', ') + '] cols=[' + (config.cols || []).join(', ') + '] aggregations=' + (config.aggregations || []).length;
+};
+
+// Length of an optional array field, used for defensive debug logging.
+var countOf = function countOf(value) {
+  return Array.isArray(value) ? value.length : undefined;
+};
+
+var failAllPending = function failAllPending(error) {
+  pendingRequests.forEach(function (entry) {
+    clearTimeout(entry.timer);
+    entry.reject(error);
+  });
+  pendingRequests.clear();
+};
+
+function configureWorkerUrl(url) {
+  if (url && url !== workerUrl) {
+    workerUrl = url;
+    if (sharedWorker) {
+      // Reject in-flight requests first so callers fall back to the
+      // synchronous path instead of waiting for the request timeout.
+      failAllPending(new Error('Pivot worker was reconfigured'));
+      sharedWorker.terminate();
+      sharedWorker = null;
+      sharedWorkerBroken = false;
+      hasResultEver = false;
+      lastStagedDataKey = null;
+    }
+  }
+}
+
+var handleWorkerMessage = function handleWorkerMessage(event) {
+  var message = event.data || {};
+  if (message.type === 'pivot:log') {
+    log('(in worker)', message.message, message.detail || '');
+    return;
+  }
+  var entry = pendingRequests.get(message.id);
+  if (!entry) {
+    return;
+  }
+  if (message.type === 'pivot:progress') {
+    var percent = message.total > 0 ? Math.round(message.processed / message.total * 100) : null;
+    log('#' + message.id + ' progress ' + message.phase + ': ' + message.processed + (message.total ? '/' + message.total : '') + (percent === null ? '' : ' (' + percent + '%)'));
+    if (entry.onProgress) {
+      entry.onProgress(message.processed, message.total, message.phase);
+    }
+    return;
+  }
+  clearTimeout(entry.timer);
+  pendingRequests.delete(message.id);
+  if (message.type === 'pivot:result') {
+    hasResultEver = true;
+    var result = message.result;
+    log('#' + message.id + ' result received in ' + (Date.now() - entry.startedAt) + 'ms', {
+      totalRecords: result && result.totalRecords,
+      rowKeys: countOf(result && result.rowKeys),
+      colKeys: countOf(result && result.colKeys),
+      aggregations: countOf(result && result.aggregations)
+    });
+    entry.resolve(message.result);
+  } else if (message.type === 'pivot:error') {
+    log('#' + message.id + ' worker reported an error:', message.message);
+    entry.reject(new Error(message.message || 'Pivot worker error'));
+  }
+};
+
+var ensureWorker = function ensureWorker() {
+  if (sharedWorkerBroken) {
+    return null;
+  }
+  if (typeof Worker === 'undefined') {
+    log('no Worker support in this environment');
+    return null;
+  }
+  if (!sharedWorker) {
+    try {
+      sharedWorker = new Worker(workerUrl);
+      log('worker created:', workerUrl);
+    } catch (error) {
+      sharedWorkerBroken = true;
+      log('worker creation failed:', error && error.message);
+      return null;
+    }
+    sharedWorker.onmessage = handleWorkerMessage;
+    sharedWorker.onerror = function (event) {
+      log('worker error event (script failed to load / runtime error):', event && event.message || '');
+      failAllPending(new Error('Pivot worker failed to load'));
+      if (!hasResultEver) {
+        sharedWorkerBroken = true;
+        log('worker marked unusable -> will use the synchronous fallback');
+      }
+    };
+    if (isDebugEnabled()) {
+      sharedWorker.postMessage({ type: 'pivot:debug', enabled: true });
+    }
+  }
+  return sharedWorker;
+};
+
+/*
+ * Runs a full computation inside the shared worker.
+ *
+ * `dataKey` must change whenever the underlying dataset changes. It lets the
+ * worker reuse the materialized dataset across consecutive computations and
+ * lets the client skip re-staging identical data.
+ */
+function computePivotInWorker(data, dataKey, config, onProgress) {
+  var worker = ensureWorker();
+  if (!worker) {
+    log('worker unavailable -> synchronous fallback');
+    return Promise.reject(new Error('Web worker unavailable'));
+  }
+  var id = nextRequestId++;
+  return new Promise(function (resolve, reject) {
+    var timer = setTimeout(function () {
+      pendingRequests.delete(id);
+      log('#' + id + ' timed out after ' + REQUEST_TIMEOUT_MS + 'ms');
+      reject(new Error('Pivot worker timed out'));
+    }, REQUEST_TIMEOUT_MS);
+    pendingRequests.set(id, {
+      resolve: resolve,
+      reject: reject,
+      onProgress: onProgress,
+      timer: timer,
+      startedAt: Date.now()
+    });
+    var mustStage = lastStagedDataKey !== dataKey;
+    log('#' + id + ' dispatching to worker (dataKey=' + dataKey + (mustStage ? ', staging ' + (data || []).length + ' records' : ', cached dataset') + ', ' + describeConfig(config) + ')');
+    if (mustStage) {
+      worker.postMessage({ type: 'pivot:setData', id: id, dataKey: dataKey, data: data });
+      lastStagedDataKey = dataKey;
+    }
+    worker.postMessage({ type: 'pivot:compute', id: id, dataKey: dataKey, config: config });
+  });
+}
+
+/*
+ * Same contract as the worker path, executed on the main thread. Used as the
+ * automatic fallback whenever the worker path is unavailable. Deferred by
+ * one tick so a loading indicator can paint before the blocking work starts.
+ */
+function computePivotSynchronously(data, config, onProgress) {
+  return new Promise(function (resolve, reject) {
+    setTimeout(function () {
+      var startedAt = Date.now();
+      log('running synchronous computation on the main thread...');
+      try {
+        var materialized = (0, _pivotCompute.materializeData)(data, {}, function (processed, total) {
+          onProgress(processed, total, 'materialize');
+        });
+        var result = (0, _pivotCompute.computePivotState)(materialized, config, onProgress);
+        log('synchronous computation finished in ' + (Date.now() - startedAt) + 'ms', {
+          totalRecords: result.totalRecords,
+          rowKeys: result.rowKeys.length,
+          colKeys: result.colKeys.length
+        });
+        resolve(result);
+      } catch (error) {
+        log('synchronous computation failed:', error && error.message);
+        reject(error);
+      }
+    }, 0);
+  });
+}
+
+/*
+ * Worker-first entry point with automatic synchronous fallback. The fallback
+ * produces the exact same serialized shape, so callers render identically
+ * either way.
+ */
+function computePivotWithFallback(data, dataKey, config, onProgress) {
+  return computePivotInWorker(data, dataKey, config, onProgress).catch(function (error) {
+    log('worker request failed, falling back to the main thread:', error && error.message || error);
+    return computePivotSynchronously(data, config, onProgress);
+  });
+}
+//# sourceMappingURL=PivotDataWorker.js.map

package/dist/PivotDataWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/PivotDataWorker.js"],"names":["setWorkerDebug","configureWorkerUrl","computePivotInWorker","computePivotSynchronously","computePivotWithFallback","DEFAULT_WORKER_URL","REQUEST_TIMEOUT_MS","workerUrl","sharedWorker","sharedWorkerBroken","hasResultEver","nextRequestId","lastStagedDataKey","workerDebug","pendingRequests","Map","enabled","next","Boolean","wasEnabled","log","postMessage","type","isDebugEnabled","window","__PVT_WORKER_DEBUG__","args","describeConfig","config","rows","join","cols","aggregations","length","countOf","Array","isArray","value","undefined","failAllPending","forEach","clearTimeout","entry","timer","reject","error","clear","url","Error","terminate","handleWorkerMessage","message","event","data","detail","get","id","percent","total","Math","round","processed","phase","onProgress","delete","result","Date","now","startedAt","totalRecords","rowKeys","colKeys","resolve","ensureWorker","Worker","onmessage","onerror","dataKey","worker","Promise","setTimeout","set","mustStage","materialized","catch"],"mappings":"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","file":"PivotDataWorker.js","sourcesContent":["/* eslint-disable valid-jsdoc */\n/* eslint-disable no-console */\n/* eslint-disable no-undefined */\n/*\n * Main-thread client for the pivot Web Worker (src/pivotWorker.js).\n *\n * Responsibilities:\n *   - lazily create a single shared Worker (at `workerUrl`, overrideable),\n *   - route progress/result/error messages to the matching request,\n *   - transparently fall back to a synchronous main-thread computation when\n *     workers are unavailable or the worker bundle fails to load.\n *\n * Debug logging is off by default. Turn it on with the `workerDebug` prop of\n * PivotTableUI (or by setting `window.__PVT_WORKER_DEBUG__ = true` before\n * rendering) to trace worker creation, staging, computation, progress,\n * results, errors and fallbacks in the browser console.\n */\nimport {materializeData, computePivotState} from './pivotCompute';\n\nexport const DEFAULT_WORKER_URL = 'pivot-worker.js';\n\nconst REQUEST_TIMEOUT_MS = 300000;\n\nlet workerUrl = DEFAULT_WORKER_URL;\nlet sharedWorker = null;\n// The worker is marked broken only if it fails before ever producing a\n// result (e.g. a 404 worker script); runtime hiccups later on just reject\n// the affected request and fall back once.\nlet sharedWorkerBroken = false;\nlet hasResultEver = false;\nlet nextRequestId = 1;\nlet lastStagedDataKey = null;\nlet workerDebug = false;\nconst pendingRequests = new Map();\n\nexport function setWorkerDebug(enabled) {\n  const next = Boolean(enabled);\n  const wasEnabled = workerDebug;\n  if (next === wasEnabled) {\n    return;\n  }\n  if (next) {\n    workerDebug = true;\n    log('debug logging enabled');\n  } else {\n    // Log while logging is still active, so the \"disabled\" notice is shown.\n    log('debug logging disabled');\n    workerDebug = false;\n  }\n  if (sharedWorker) {\n    sharedWorker.postMessage({type: 'pivot:debug', enabled: workerDebug});\n  }\n}\n\nconst isDebugEnabled = () =>\n  workerDebug ||\n  (typeof window !== 'undefined' && window.__PVT_WORKER_DEBUG__ === true);\n\nfunction log(...args) {\n  if (!isDebugEnabled()) {\n    return;\n  }\n  console.log(\n    '%c[pivottable worker]',\n    'color:#ff6600;font-weight:bold',\n    ...args\n  );\n}\n\nconst describeConfig = config =>\n  `rows=[${(config.rows || []).join(', ')}] cols=[${(config.cols || []).join(\n    ', '\n  )}] aggregations=${(config.aggregations || []).length}`;\n\n// Length of an optional array field, used for defensive debug logging.\nconst countOf = value => (Array.isArray(value) ? value.length : undefined);\n\nconst failAllPending = error => {\n  pendingRequests.forEach(entry => {\n    clearTimeout(entry.timer);\n    entry.reject(error);\n  });\n  pendingRequests.clear();\n};\n\nexport function configureWorkerUrl(url) {\n  if (url && url !== workerUrl) {\n    workerUrl = url;\n    if (sharedWorker) {\n      // Reject in-flight requests first so callers fall back to the\n      // synchronous path instead of waiting for the request timeout.\n      failAllPending(new Error('Pivot worker was reconfigured'));\n      sharedWorker.terminate();\n      sharedWorker = null;\n      sharedWorkerBroken = false;\n      hasResultEver = false;\n      lastStagedDataKey = null;\n    }\n  }\n}\n\nconst handleWorkerMessage = event => {\n  const message = event.data || {};\n  if (message.type === 'pivot:log') {\n    log('(in worker)', message.message, message.detail || '');\n    return;\n  }\n  const entry = pendingRequests.get(message.id);\n  if (!entry) {\n    return;\n  }\n  if (message.type === 'pivot:progress') {\n    const percent =\n      message.total > 0\n        ? Math.round((message.processed / message.total) * 100)\n        : null;\n    log(\n      `#${message.id} progress ${message.phase}: ${message.processed}` +\n        (message.total ? `/${message.total}` : '') +\n        (percent === null ? '' : ` (${percent}%)`)\n    );\n    if (entry.onProgress) {\n      entry.onProgress(message.processed, message.total, message.phase);\n    }\n    return;\n  }\n  clearTimeout(entry.timer);\n  pendingRequests.delete(message.id);\n  if (message.type === 'pivot:result') {\n    hasResultEver = true;\n    const result = message.result;\n    log(`#${message.id} result received in ${Date.now() - entry.startedAt}ms`, {\n      totalRecords: result && result.totalRecords,\n      rowKeys: countOf(result && result.rowKeys),\n      colKeys: countOf(result && result.colKeys),\n      aggregations: countOf(result && result.aggregations),\n    });\n    entry.resolve(message.result);\n  } else if (message.type === 'pivot:error') {\n    log(`#${message.id} worker reported an error:`, message.message);\n    entry.reject(new Error(message.message || 'Pivot worker error'));\n  }\n};\n\nconst ensureWorker = () => {\n  if (sharedWorkerBroken) {\n    return null;\n  }\n  if (typeof Worker === 'undefined') {\n    log('no Worker support in this environment');\n    return null;\n  }\n  if (!sharedWorker) {\n    try {\n      sharedWorker = new Worker(workerUrl);\n      log('worker created:', workerUrl);\n    } catch (error) {\n      sharedWorkerBroken = true;\n      log('worker creation failed:', error && error.message);\n      return null;\n    }\n    sharedWorker.onmessage = handleWorkerMessage;\n    sharedWorker.onerror = event => {\n      log(\n        'worker error event (script failed to load / runtime error):',\n        (event && event.message) || ''\n      );\n      failAllPending(new Error('Pivot worker failed to load'));\n      if (!hasResultEver) {\n        sharedWorkerBroken = true;\n        log('worker marked unusable -> will use the synchronous fallback');\n      }\n    };\n    if (isDebugEnabled()) {\n      sharedWorker.postMessage({type: 'pivot:debug', enabled: true});\n    }\n  }\n  return sharedWorker;\n};\n\n/*\n * Runs a full computation inside the shared worker.\n *\n * `dataKey` must change whenever the underlying dataset changes. It lets the\n * worker reuse the materialized dataset across consecutive computations and\n * lets the client skip re-staging identical data.\n */\nexport function computePivotInWorker(data, dataKey, config, onProgress) {\n  const worker = ensureWorker();\n  if (!worker) {\n    log('worker unavailable -> synchronous fallback');\n    return Promise.reject(new Error('Web worker unavailable'));\n  }\n  const id = nextRequestId++;\n  return new Promise((resolve, reject) => {\n    const timer = setTimeout(() => {\n      pendingRequests.delete(id);\n      log(`#${id} timed out after ${REQUEST_TIMEOUT_MS}ms`);\n      reject(new Error('Pivot worker timed out'));\n    }, REQUEST_TIMEOUT_MS);\n    pendingRequests.set(id, {\n      resolve,\n      reject,\n      onProgress,\n      timer,\n      startedAt: Date.now(),\n    });\n    const mustStage = lastStagedDataKey !== dataKey;\n    log(\n      `#${id} dispatching to worker (dataKey=${dataKey}${\n        mustStage\n          ? ', staging ' + (data || []).length + ' records'\n          : ', cached dataset'\n      }, ${describeConfig(config)})`\n    );\n    if (mustStage) {\n      worker.postMessage({type: 'pivot:setData', id, dataKey, data});\n      lastStagedDataKey = dataKey;\n    }\n    worker.postMessage({type: 'pivot:compute', id, dataKey, config});\n  });\n}\n\n/*\n * Same contract as the worker path, executed on the main thread. Used as the\n * automatic fallback whenever the worker path is unavailable. Deferred by\n * one tick so a loading indicator can paint before the blocking work starts.\n */\nexport function computePivotSynchronously(data, config, onProgress) {\n  return new Promise((resolve, reject) => {\n    setTimeout(() => {\n      const startedAt = Date.now();\n      log('running synchronous computation on the main thread...');\n      try {\n        const materialized = materializeData(data, {}, (processed, total) => {\n          onProgress(processed, total, 'materialize');\n        });\n        const result = computePivotState(materialized, config, onProgress);\n        log(`synchronous computation finished in ${Date.now() - startedAt}ms`, {\n          totalRecords: result.totalRecords,\n          rowKeys: result.rowKeys.length,\n          colKeys: result.colKeys.length,\n        });\n        resolve(result);\n      } catch (error) {\n        log('synchronous computation failed:', error && error.message);\n        reject(error);\n      }\n    }, 0);\n  });\n}\n\n/*\n * Worker-first entry point with automatic synchronous fallback. The fallback\n * produces the exact same serialized shape, so callers render identically\n * either way.\n */\nexport function computePivotWithFallback(data, dataKey, config, onProgress) {\n  return computePivotInWorker(data, dataKey, config, onProgress).catch(\n    error => {\n      log(\n        'worker request failed, falling back to the main thread:',\n        (error && error.message) || error\n      );\n      return computePivotSynchronously(data, config, onProgress);\n    }\n  );\n}\n"]}