@dou-ui/pivot 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/pivot.vue.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes } from 'vue';
+import type { ForwardedAttributes } from 'dou-ui';
+import type { PivotCollapsed, PivotConfig } from './engine/types';
+import type { PivotCellEvent, PivotExpose, PivotProps } from './types';
+declare const __VLS_export: <Row = Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(PivotProps<Row> & ForwardedAttributes<HTMLAttributes, PivotProps<Row>, "update:config" | "update:collapsed" | "cellClick"> & {
+        config?: PivotConfig;
+        collapsed?: PivotCollapsed;
+    }) & {
+        "onUpdate:config"?: ((value: PivotConfig) => any) | undefined;
+        "onUpdate:collapsed"?: ((value: PivotCollapsed) => any) | undefined;
+        onCellClick?: ((cell: PivotCellEvent<Row>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<PivotExpose>) => void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "cellClick", cell: PivotCellEvent<Row>) => void) & (((event: "update:config", value: PivotConfig) => void) & ((event: "update:collapsed", value: PivotCollapsed) => void));
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/types.d.ts

@@ -0,0 +1,199 @@
+import type { Size } from 'dou-ui';
+import type { PivotAggregator } from './engine/aggregate';
+import type { PivotResult } from './engine/compute';
+import type { PivotEngine } from './engine/engine';
+import type { PivotData } from './engine/source';
+import type { PivotAxis } from './core/layout';
+import type { PivotCSVOptions, PivotGrid } from './core/table';
+import type { PivotCollapsed, PivotConfig, PivotField, PivotPath } from './engine/types';
+import type { PivotMessagesOverride } from './locale';
+export interface PivotProps<Row = Record<string, unknown>> {
+    /**
+     * The records: an array of objects, or their columns
+     * (`{ region: [...], amount: [...] }`, typed arrays welcome). Replace it
+     * to update it (changes inside are not seen); keep large data in a
+     * `shallowRef`.
+     */
+    data: PivotData<Row>;
+    /** What the fields hold and how to show them; worked out from the records when left out. */
+    fields?: readonly PivotField<Row>[];
+    /** Which fields go where. */
+    config?: PivotConfig;
+    /** The collapsed groups; all groups are open by default. */
+    collapsed?: PivotCollapsed;
+    /**
+     * The most height, a number in px or any CSS length; a shorter table ends
+     * with its last row. The width fills the container.
+     */
+    maxHeight?: number | string;
+    /** Row height: 28, 32 (`md`, the default) or 40 px. */
+    size?: Size;
+    /** The width of the row headers, in px. */
+    rowHeaderWidth?: number;
+    /** The width of each value column, in px. */
+    columnWidth?: number;
+    /**
+     * `compact` (the default) puts the row fields in one column as a tree, a
+     * group's total on its own line; `tabular` gives each row field a column
+     * and an open group's total a line after its children.
+     */
+    layout?: 'compact' | 'tabular';
+    /** Whether column widths can be dragged (and fitted with a double-click); `true` by default. */
+    resizable?: boolean;
+    /** Ways to sum up beside the built-in ones, by the name the config uses. */
+    aggregators?: readonly PivotAggregator[];
+    /**
+     * Sum up in a worker, keeping the page responsive. `'auto'` (the default)
+     * does so above 100,000 records where workers are available.
+     */
+    worker?: boolean | 'auto';
+    /** Where to sum up instead: your own worker (`createPivotWorker`) or a server. */
+    engine?: PivotEngine;
+    /**
+     * Marks a row group and a column group, by their paths (as `cellClick`
+     * gives them), such as the groups a click picked; the cells where both
+     * meet stand out the most.
+     */
+    highlight?: {
+        row?: PivotPath;
+        column?: PivotPath;
+    };
+    /** The table's accessible name. */
+    ariaLabel?: string;
+    /** Texts to override. */
+    messages?: PivotMessagesOverride;
+}
+export interface PivotFieldsProps<Row = Record<string, unknown>> {
+    /** The same records as the table's; the panel reads them to list the fields and their values. */
+    data: PivotData<Row>;
+    /** The same fields as the table's. */
+    fields?: readonly PivotField<Row>[];
+    /** Which fields go where; bind the same config as the table's with `v-model:config`. */
+    config?: PivotConfig;
+    /** Ways to sum up beside the built-in ones, offered in each value's menu. */
+    aggregators?: readonly PivotAggregator[];
+    /**
+     * Show the panel as a button that opens it in a drawer. `'auto'` (the
+     * default) does so on screens narrower than the `sm` breakpoint.
+     */
+    drawer?: boolean | 'auto';
+    /** Texts to override. */
+    messages?: PivotMessagesOverride;
+}
+/** A cell that was clicked (or activated with Enter). */
+export interface PivotCellEvent<Row = Record<string, unknown>> {
+    /** The row group's labels, `[]` for the grand total. */
+    row: PivotPath;
+    /** The column group's labels, `[]` for the grand total. */
+    column: PivotPath;
+    /** The same groups as the table writes them (`2026年1月` for the group `'2026-01'`). */
+    labels: {
+        row: string[];
+        column: string[];
+    };
+    /** The value's place in `config.values`. */
+    valueIndex: number;
+    /** The number in the cell, as shown (a share, when the value has `show`); `NaN` when it is empty. */
+    value: number;
+    /** The records summed up in the cell. */
+    records: () => Row[];
+    /** Their indexes in `data`. */
+    indices: () => number[];
+}
+export interface PivotEmits<Row = Record<string, unknown>> {
+    'update:config': [config: PivotConfig];
+    'update:collapsed': [collapsed: PivotCollapsed];
+    cellClick: [cell: PivotCellEvent<Row>];
+}
+export interface PivotExpose {
+    /** The groups and values on show. */
+    readonly result: PivotResult;
+    /** Opens every group, on one axis (`rows` or `columns`) or both. */
+    expandAll: (options?: {
+        axis?: PivotAxis;
+    }) => void;
+    /**
+     * Closes every group from `depth` in (1, the default, closes the outermost
+     * groups), on one axis or both.
+     */
+    collapseAll: (options?: {
+        axis?: PivotAxis;
+        depth?: number;
+    }) => void;
+    /** Opens or closes a group. */
+    toggle: (axis: PivotAxis, path: PivotPath, open?: boolean) => void;
+    /**
+     * The table as it shows, headers and all, as cells: each row field in a
+     * column of its own, the numbers as shown (shares, ranks…) with their text.
+     */
+    toGrid: () => PivotGrid;
+    /** The table as CSV, the numbers as values a spreadsheet can add up unless `text`. */
+    toCSV: (options?: PivotCSVOptions) => string;
+    /**
+     * The table as a workbook for `DouSheet`: numbers with their formats, the
+     * headers merged and frozen, the columns as wide as on screen.
+     */
+    toSheet: (options?: {
+        name?: string;
+    }) => PivotSheetWorkbook;
+    /** Rows and series for `@dou-ui/chart`, from the groups on show; totals are left out. */
+    toChartRows: (options?: PivotChartRowsOptions) => PivotChartRows;
+    /** Copies the selected cells (or, with `all`, the whole table) to the clipboard. */
+    copy: (options?: PivotCopyOptions) => Promise<void>;
+    /** Selects every cell, as Ctrl / ⌘ + A does. */
+    selectAll: () => void;
+    /** Prints the whole table on A4 pages, the column headers repeated on each. */
+    print: (options?: PivotPrintOptions) => void;
+}
+export interface PivotCopyOptions {
+    /** The whole table, headers and all, instead of the selected cells. */
+    all?: boolean;
+}
+export interface PivotPrintOptions {
+    /** A heading above the table; the table's `aria-label` by default. */
+    title?: string;
+    /** Landscape when the table is wider than a portrait page, by default. */
+    orientation?: 'portrait' | 'landscape';
+}
+export interface PivotChartRowsOptions {
+    /** Only this value (its place in `config.values`); every value on show by default. */
+    valueIndex?: number;
+}
+/** What a chart needs: `rows` as its `data`, `x` as its `x`, a series per entry of `series`. */
+export interface PivotChartRows {
+    /** The key of each row's group label. */
+    x: 'label';
+    rows: Record<string, string | number | null>[];
+    series: {
+        /** The key of the series' numbers in each row. */
+        key: string;
+        /** The column's groups (and the value, when there are several). */
+        name: string;
+        valueIndex: number;
+        /** Writes a number as the table does, e.g. for the axis's `format`. */
+        format: (n: number) => string;
+    }[];
+}
+/** A cell as `DouSheet` takes it. */
+export type PivotSheetCell = string | number | null | {
+    value: string | number;
+    format?: string;
+    style?: string;
+};
+/** A workbook in the shape `DouSheet`'s `v-model` takes. */
+export interface PivotSheetWorkbook {
+    version: 1;
+    sheets: {
+        name: string;
+        cells: PivotSheetCell[][];
+        merges: string[];
+        freeze: {
+            rows: number;
+            cols: number;
+        };
+        colSizes: Record<number, number>;
+    }[];
+    styles: Record<string, {
+        bold?: boolean;
+    }>;
+}

package/dist/types/worker/client.d.ts

@@ -0,0 +1,19 @@
+import { type PivotEngine } from '../engine/engine';
+/** The page's side of the messages: a `Worker`, or anything that talks like one. */
+export interface PivotWorkerLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    /** When the worker fails to start or throws: pending and later computes reject. */
+    addEventListener(type: 'error', listener: (event: Event) => void): void;
+    terminate?(): void;
+}
+/**
+ * An engine that sums up in a worker, so a million records never hold up
+ * the page. The page reads each field the config needs once, in slices of
+ * a few milliseconds, and moves it to the worker (no copy); after that
+ * only configs go over.
+ *
+ * Pass a worker that calls `servePivot`, or a function that makes one
+ * (made when first needed).
+ */
+export declare function createPivotWorker(worker: PivotWorkerLike | (() => PivotWorkerLike)): PivotEngine;

package/dist/types/worker/default.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/worker/index.d.ts

@@ -0,0 +1,5 @@
+export { createPivotWorker } from './client';
+export type { PivotWorkerLike } from './client';
+export { servePivot } from './serve';
+export type { PivotWorkerScope, ServePivotOptions } from './serve';
+export type { PivotEngine, PivotComputeRequest } from '../engine/engine';

package/dist/types/worker/protocol.d.ts

@@ -0,0 +1,60 @@
+import type { PivotPacket } from '../engine/compute';
+import type { PivotEncodedColumn } from '../engine/source';
+import type { PivotConfig, PivotFieldType } from '../engine/types';
+/** A field as the worker knows it: no functions, they stay in the page. */
+export interface PivotWorkerField {
+    name: string;
+    label: string;
+    type: PivotFieldType;
+    order?: readonly unknown[];
+}
+/** What the page sends. `source` numbers the records; anything for an older one is dropped. */
+export type PivotToWorker = {
+    type: 'source';
+    source: number;
+    length: number;
+    locale?: string;
+    fields: PivotWorkerField[];
+}
+/** Fields the page came to know after `source` (keys the config names that no field described). */
+ | {
+    type: 'fields';
+    source: number;
+    fields: PivotWorkerField[];
+} | ({
+    type: 'dimension';
+    source: number;
+    name: string;
+} & PivotEncodedColumn) | {
+    type: 'measure';
+    source: number;
+    name: string;
+    values: Float64Array;
+} | {
+    type: 'compute';
+    source: number;
+    id: number;
+    config: PivotConfig;
+};
+/** What the worker answers to a `compute`. */
+export type PivotFromWorker = {
+    type: 'result';
+    id: number;
+    packet: PivotPacket;
+}
+/** Fields it was not sent, which the page could not tell it needs (a custom aggregator's input). */
+ | {
+    type: 'need';
+    id: number;
+    dimensions: string[];
+    measures: string[];
+}
+/** A newer compute came in first. */
+ | {
+    type: 'skipped';
+    id: number;
+} | {
+    type: 'error';
+    id: number;
+    message: string;
+};

package/dist/types/worker/serve.d.ts

@@ -0,0 +1,22 @@
+import type { PivotAggregator } from '../engine/aggregate';
+export interface ServePivotOptions {
+    /** Custom aggregators (`defineAggregator`) the configs may name; functions cannot be sent, so they live here. */
+    aggregators?: readonly PivotAggregator[];
+}
+/** The worker's side of the messages: anything with `postMessage` and `onmessage`. */
+export interface PivotWorkerScope {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+}
+/**
+ * Sums up for the page in a worker. Call it in your own worker file when
+ * configs use custom aggregators; `DouPivot`'s built-in worker calls it
+ * with none.
+ *
+ * ```ts
+ * // pivot.worker.ts
+ * import { servePivot } from '@dou-ui/pivot/worker'
+ * servePivot({ aggregators: [weightedAverage] })
+ * ```
+ */
+export declare function servePivot(options?: ServePivotOptions, scope?: PivotWorkerScope): void;

package/dist/worker/client.js

@@ -0,0 +1,191 @@
+import { PivotResult } from "../engine/compute.js";
+import { neededColumns } from "../engine/engine.js";
+// src/worker/client.ts
+/** How long the page reads records before it lets other work run, in ms. */
+var SLICE = 6;
+var PREFIX = "[@dou-ui/pivot]";
+var CANNOT_START = "the worker could not start";
+/** Why the worker can't sum up, with the package prefix in front of what the browser said. */
+var brokenMessage = (message) => !message ? `${PREFIX} ${CANNOT_START}; check that the worker file loads (a 404, a CSP or cross-origin block, or a bundler that left it out), or use :worker="false" or createPivotWorker()` : message.startsWith(PREFIX) ? message : `${PREFIX} ${CANNOT_START}: ${message}`;
+var abortError = () => new DOMException("A newer config came in", "AbortError");
+/** Lets the page paint and handle input between slices of reading. */
+var breathe = (() => {
+	if (typeof MessageChannel === "undefined") return () => new Promise((r) => setTimeout(r));
+	const channel = new MessageChannel();
+	const waiting = [];
+	channel.port1.addEventListener("message", () => waiting.shift()?.());
+	channel.port1.start();
+	return () => new Promise((resolve) => {
+		waiting.push(resolve);
+		channel.port2.postMessage(0);
+	});
+})();
+/** Runs reading in slices of a few ms each, so the page stays responsive. */
+async function sliced(steps, signal) {
+	let until = performance.now() + SLICE;
+	for (;;) {
+		const step = steps.next();
+		if (step.done) return step.value;
+		if (performance.now() < until) continue;
+		await breathe();
+		if (signal?.aborted) throw abortError();
+		until = performance.now() + SLICE;
+	}
+}
+var describe = (source) => [...source.fields.values()].map((f) => ({
+	name: f.name,
+	label: f.label,
+	type: f.type,
+	...f.order ? { order: f.order } : {}
+}));
+/**
+* An engine that sums up in a worker, so a million records never hold up
+* the page. The page reads each field the config needs once, in slices of
+* a few milliseconds, and moves it to the worker (no copy); after that
+* only configs go over.
+*
+* Pass a worker that calls `servePivot`, or a function that makes one
+* (made when first needed).
+*/
+function createPivotWorker(worker) {
+	let w = null;
+	let current = null;
+	let sourceId = 0;
+	let nextId = 0;
+	/** Why the worker stopped working, once it has. */
+	let broken = null;
+	const known = /* @__PURE__ */ new Set();
+	const sent = {
+		dimensions: /* @__PURE__ */ new Set(),
+		measures: /* @__PURE__ */ new Set()
+	};
+	const waiting = /* @__PURE__ */ new Map();
+	let lane = Promise.resolve();
+	const post = (message, transfer) => w.postMessage(message, transfer);
+	const connect = () => {
+		if (w) return w;
+		w = typeof worker === "function" ? worker() : worker;
+		w.addEventListener("message", (event) => {
+			const m = event.data;
+			const job = waiting.get(m.id);
+			if (!job) return;
+			waiting.delete(m.id);
+			job.resolve(m);
+		});
+		w.addEventListener("error", (event) => {
+			broken = brokenMessage(event.message);
+			for (const job of waiting.values()) job.resolve({
+				type: "error",
+				id: -1,
+				message: broken
+			});
+			waiting.clear();
+		});
+		return w;
+	};
+	/** Reads and sends the fields the worker does not have yet. */
+	async function ship(source, need, signal) {
+		const fresh = describe(source).filter((f) => !known.has(f.name));
+		if (fresh.length) {
+			for (const f of fresh) known.add(f.name);
+			post({
+				type: "fields",
+				source: sourceId,
+				fields: fresh
+			});
+		}
+		for (const name of need.dimensions) {
+			if (sent.dimensions.has(name)) continue;
+			const id = sourceId;
+			const column = await sliced(source.encodeSteps(name), signal);
+			if (id !== sourceId) throw abortError();
+			post({
+				type: "dimension",
+				source: id,
+				name,
+				...column
+			}, [column.codes.buffer]);
+			sent.dimensions.add(name);
+		}
+		for (const name of need.measures) {
+			if (sent.measures.has(name)) continue;
+			const id = sourceId;
+			const values = await sliced(source.measureSteps(name, true), signal);
+			if (id !== sourceId) throw abortError();
+			post({
+				type: "measure",
+				source: id,
+				name,
+				values
+			}, [values.buffer]);
+			sent.measures.add(name);
+		}
+	}
+	return {
+		async compute(source, config, request = {}) {
+			const { signal } = request;
+			try {
+				connect();
+			} catch (error) {
+				broken = brokenMessage(error.message);
+			}
+			if (broken) throw new Error(broken);
+			if (source !== current) {
+				current = source;
+				sourceId++;
+				known.clear();
+				sent.dimensions.clear();
+				sent.measures.clear();
+				const fields = describe(source);
+				for (const f of fields) known.add(f.name);
+				post({
+					type: "source",
+					source: sourceId,
+					length: source.length,
+					locale: source.locale,
+					fields
+				});
+			}
+			const need = neededColumns(source, config, request.aggregators);
+			const shipped = lane.then(() => ship(source, need, signal));
+			lane = shipped.catch(() => {});
+			await shipped;
+			for (let round = 0; round < 3; round++) {
+				if (signal?.aborted) throw abortError();
+				const id = nextId++;
+				const answer = await new Promise((resolve) => {
+					if (broken) return resolve({
+						type: "error",
+						id,
+						message: broken
+					});
+					waiting.set(id, { resolve });
+					post({
+						type: "compute",
+						source: sourceId,
+						id,
+						config
+					});
+				});
+				if (answer.type === "result") return PivotResult.unpack(answer.packet, source, config);
+				if (answer.type === "error") throw new Error(answer.message);
+				if (answer.type === "skipped") throw abortError();
+				await ship(source, answer, signal);
+			}
+			throw new Error("[@dou-ui/pivot] the worker still lacks fields after they were sent");
+		},
+		dispose() {
+			w?.terminate?.();
+			w = null;
+			current = null;
+			for (const job of waiting.values()) job.resolve({
+				type: "skipped",
+				id: -1
+			});
+			waiting.clear();
+		}
+	};
+}
+export { createPivotWorker };
+
+//# sourceMappingURL=client.js.map

package/dist/worker/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../../src/worker/client.ts"],"sourcesContent":["import { PivotResult } from '../engine/compute'\nimport { neededColumns, type PivotComputeRequest, type PivotEngine } from '../engine/engine'\nimport type { PivotSource } from '../engine/source'\nimport type { PivotConfig } from '../engine/types'\nimport type { PivotFromWorker, PivotToWorker, PivotWorkerField } from './protocol'\n\n/** The page's side of the messages: a `Worker`, or anything that talks like one. */\nexport interface PivotWorkerLike {\n  postMessage(message: unknown, transfer?: Transferable[]): void\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void\n  /** When the worker fails to start or throws: pending and later computes reject. */\n  addEventListener(type: 'error', listener: (event: Event) => void): void\n  terminate?(): void\n}\n\n/** How long the page reads records before it lets other work run, in ms. */\nconst SLICE = 6\n\nconst PREFIX = '[@dou-ui/pivot]'\nconst CANNOT_START = 'the worker could not start'\n/** Why the worker can't sum up, with the package prefix in front of what the browser said. */\nconst brokenMessage = (message: string | undefined) =>\n  !message\n    ? `${PREFIX} ${CANNOT_START}; check that the worker file loads (a 404, a CSP or cross-origin block, or a bundler that left it out), or use :worker=\"false\" or createPivotWorker()`\n    : message.startsWith(PREFIX)\n      ? message\n      : `${PREFIX} ${CANNOT_START}: ${message}`\n\nconst abortError = () => new DOMException('A newer config came in', 'AbortError')\n\n/** Lets the page paint and handle input between slices of reading. */\nconst breathe = (() => {\n  if (typeof MessageChannel === 'undefined') return () => new Promise((r) => setTimeout(r))\n  const channel = new MessageChannel()\n  const waiting: (() => void)[] = []\n  channel.port1.addEventListener('message', () => waiting.shift()?.())\n  channel.port1.start()\n  return () =>\n    new Promise<void>((resolve) => {\n      waiting.push(resolve)\n      channel.port2.postMessage(0)\n    })\n})()\n\n/** Runs reading in slices of a few ms each, so the page stays responsive. */\nasync function sliced<T>(steps: Generator<void, T>, signal?: AbortSignal): Promise<T> {\n  let until = performance.now() + SLICE\n  for (;;) {\n    const step = steps.next()\n    if (step.done) return step.value\n    if (performance.now() < until) continue\n    await breathe()\n    if (signal?.aborted) throw abortError()\n    until = performance.now() + SLICE\n  }\n}\n\nconst describe = <Row>(source: PivotSource<Row>): PivotWorkerField[] =>\n  [...source.fields.values()].map((f) => ({\n    name: f.name,\n    label: f.label,\n    type: f.type,\n    ...(f.order ? { order: f.order } : {}),\n  }))\n\n/**\n * An engine that sums up in a worker, so a million records never hold up\n * the page. The page reads each field the config needs once, in slices of\n * a few milliseconds, and moves it to the worker (no copy); after that\n * only configs go over.\n *\n * Pass a worker that calls `servePivot`, or a function that makes one\n * (made when first needed).\n */\nexport function createPivotWorker(worker: PivotWorkerLike | (() => PivotWorkerLike)): PivotEngine {\n  let w: PivotWorkerLike | null = null\n  let current: object | null = null\n  let sourceId = 0\n  let nextId = 0\n  /** Why the worker stopped working, once it has. */\n  let broken: string | null = null\n  const known = new Set<string>()\n  const sent = { dimensions: new Set<string>(), measures: new Set<string>() }\n  const waiting = new Map<\n    number,\n    {\n      resolve: (message: PivotFromWorker) => void\n    }\n  >()\n\n  // one compute reads fields at a time, so two never read the same field\n  let lane: Promise<unknown> = Promise.resolve()\n\n  const post = (message: PivotToWorker, transfer?: Transferable[]) =>\n    w!.postMessage(message, transfer)\n\n  const connect = () => {\n    if (w) return w\n    w = typeof worker === 'function' ? worker() : worker\n    w.addEventListener('message', (event) => {\n      const m = event.data as PivotFromWorker\n      const job = waiting.get(m.id)\n      if (!job) return\n      waiting.delete(m.id)\n      job.resolve(m)\n    })\n    w.addEventListener('error', (event) => {\n      broken = brokenMessage((event as ErrorEvent).message)\n      for (const job of waiting.values()) job.resolve({ type: 'error', id: -1, message: broken })\n      waiting.clear()\n    })\n    return w\n  }\n\n  /** Reads and sends the fields the worker does not have yet. */\n  async function ship<Row>(\n    source: PivotSource<Row>,\n    need: { dimensions: string[]; measures: string[] },\n    signal?: AbortSignal,\n  ) {\n    const fresh = describe(source).filter((f) => !known.has(f.name))\n    if (fresh.length) {\n      for (const f of fresh) known.add(f.name)\n      post({ type: 'fields', source: sourceId, fields: fresh })\n    }\n    for (const name of need.dimensions) {\n      if (sent.dimensions.has(name)) continue\n      const id = sourceId\n      const column = await sliced(source.encodeSteps(name), signal)\n      if (id !== sourceId) throw abortError()\n      post({ type: 'dimension', source: id, name, ...column }, [column.codes.buffer])\n      sent.dimensions.add(name)\n    }\n    for (const name of need.measures) {\n      if (sent.measures.has(name)) continue\n      const id = sourceId\n      const values = await sliced(source.measureSteps(name, true), signal)\n      if (id !== sourceId) throw abortError()\n      post({ type: 'measure', source: id, name, values }, [values.buffer])\n      sent.measures.add(name)\n    }\n  }\n\n  return {\n    async compute(source, config: PivotConfig, request: PivotComputeRequest = {}) {\n      const { signal } = request\n      try {\n        connect()\n      } catch (error) {\n        broken = brokenMessage((error as Error).message)\n      }\n      if (broken) throw new Error(broken)\n      if (source !== current) {\n        current = source\n        sourceId++\n        known.clear()\n        sent.dimensions.clear()\n        sent.measures.clear()\n        const fields = describe(source)\n        for (const f of fields) known.add(f.name)\n        post({\n          type: 'source',\n          source: sourceId,\n          length: source.length,\n          locale: source.locale,\n          fields,\n        })\n      }\n      const need = neededColumns(source, config, request.aggregators)\n      const shipped = lane.then(() => ship(source, need, signal))\n      lane = shipped.catch(() => {})\n      await shipped\n      // the worker may need more than the page could tell (a custom aggregator's input)\n      for (let round = 0; round < 3; round++) {\n        if (signal?.aborted) throw abortError()\n        const id = nextId++\n        const answer = await new Promise<PivotFromWorker>((resolve) => {\n          if (broken) return resolve({ type: 'error', id, message: broken })\n          waiting.set(id, { resolve })\n          post({ type: 'compute', source: sourceId, id, config })\n        })\n        if (answer.type === 'result') return PivotResult.unpack(answer.packet, source, config)\n        if (answer.type === 'error') throw new Error(answer.message)\n        if (answer.type === 'skipped') throw abortError()\n        await ship(source, answer, signal)\n      }\n      throw new Error('[@dou-ui/pivot] the worker still lacks fields after they were sent')\n    },\n    dispose() {\n      w?.terminate?.()\n      w = null\n      current = null\n      for (const job of waiting.values()) job.resolve({ type: 'skipped', id: -1 })\n      waiting.clear()\n    },\n  }\n}\n"],"mappings":";;;;AAgBA,IAAM,QAAQ;AAEd,IAAM,SAAS;AACf,IAAM,eAAe;;AAErB,IAAM,iBAAiB,YACrB,CAAC,UACG,GAAG,OAAO,GAAG,aAAa,yJAC1B,QAAQ,WAAW,MAAM,IACvB,UACA,GAAG,OAAO,GAAG,aAAa,IAAI;AAEtC,IAAM,mBAAmB,IAAI,aAAa,0BAA0B,YAAY;;AAGhF,IAAM,iBAAiB;CACrB,IAAI,OAAO,mBAAmB,aAAa,aAAa,IAAI,SAAS,MAAM,WAAW,CAAC,CAAC;CACxF,MAAM,UAAU,IAAI,eAAe;CACnC,MAAM,UAA0B,CAAC;CACjC,QAAQ,MAAM,iBAAiB,iBAAiB,QAAQ,MAAM,CAAC,GAAG,CAAC;CACnE,QAAQ,MAAM,MAAM;CACpB,aACE,IAAI,SAAe,YAAY;EAC7B,QAAQ,KAAK,OAAO;EACpB,QAAQ,MAAM,YAAY,CAAC;CAC7B,CAAC;AACL,EAAA,CAAG;;AAGH,eAAe,OAAU,OAA2B,QAAkC;CACpF,IAAI,QAAQ,YAAY,IAAI,IAAI;CAChC,SAAS;EACP,MAAM,OAAO,MAAM,KAAK;EACxB,IAAI,KAAK,MAAM,OAAO,KAAK;EAC3B,IAAI,YAAY,IAAI,IAAI,OAAO;EAC/B,MAAM,QAAQ;EACd,IAAI,QAAQ,SAAS,MAAM,WAAW;EACtC,QAAQ,YAAY,IAAI,IAAI;CAC9B;AACF;AAEA,IAAM,YAAiB,WACrB,CAAC,GAAG,OAAO,OAAO,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO;CACtC,MAAM,EAAE;CACR,OAAO,EAAE;CACT,MAAM,EAAE;CACR,GAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AACtC,EAAE;;;;;;;;;;AAWJ,SAAgB,kBAAkB,QAAgE;CAChG,IAAI,IAA4B;CAChC,IAAI,UAAyB;CAC7B,IAAI,WAAW;CACf,IAAI,SAAS;;CAEb,IAAI,SAAwB;CAC5B,MAAM,wBAAQ,IAAI,IAAY;CAC9B,MAAM,OAAO;EAAE,4BAAY,IAAI,IAAY;EAAG,0BAAU,IAAI,IAAY;CAAE;CAC1E,MAAM,0BAAU,IAAI,IAKlB;CAGF,IAAI,OAAyB,QAAQ,QAAQ;CAE7C,MAAM,QAAQ,SAAwB,aACpC,EAAG,YAAY,SAAS,QAAQ;CAElC,MAAM,gBAAgB;EACpB,IAAI,GAAG,OAAO;EACd,IAAI,OAAO,WAAW,aAAa,OAAO,IAAI;EAC9C,EAAE,iBAAiB,YAAY,UAAU;GACvC,MAAM,IAAI,MAAM;GAChB,MAAM,MAAM,QAAQ,IAAI,EAAE,EAAE;GAC5B,IAAI,CAAC,KAAK;GACV,QAAQ,OAAO,EAAE,EAAE;GACnB,IAAI,QAAQ,CAAC;EACf,CAAC;EACD,EAAE,iBAAiB,UAAU,UAAU;GACrC,SAAS,cAAe,MAAqB,OAAO;GACpD,KAAK,MAAM,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;IAAE,MAAM;IAAS,IAAI;IAAI,SAAS;GAAO,CAAC;GAC1F,QAAQ,MAAM;EAChB,CAAC;EACD,OAAO;CACT;;CAGA,eAAe,KACb,QACA,MACA,QACA;EACA,MAAM,QAAQ,SAAS,MAAM,CAAC,CAAC,QAAQ,MAAM,CAAC,MAAM,IAAI,EAAE,IAAI,CAAC;EAC/D,IAAI,MAAM,QAAQ;GAChB,KAAK,MAAM,KAAK,OAAO,MAAM,IAAI,EAAE,IAAI;GACvC,KAAK;IAAE,MAAM;IAAU,QAAQ;IAAU,QAAQ;GAAM,CAAC;EAC1D;EACA,KAAK,MAAM,QAAQ,KAAK,YAAY;GAClC,IAAI,KAAK,WAAW,IAAI,IAAI,GAAG;GAC/B,MAAM,KAAK;GACX,MAAM,SAAS,MAAM,OAAO,OAAO,YAAY,IAAI,GAAG,MAAM;GAC5D,IAAI,OAAO,UAAU,MAAM,WAAW;GACtC,KAAK;IAAE,MAAM;IAAa,QAAQ;IAAI;IAAM,GAAG;GAAO,GAAG,CAAC,OAAO,MAAM,MAAM,CAAC;GAC9E,KAAK,WAAW,IAAI,IAAI;EAC1B;EACA,KAAK,MAAM,QAAQ,KAAK,UAAU;GAChC,IAAI,KAAK,SAAS,IAAI,IAAI,GAAG;GAC7B,MAAM,KAAK;GACX,MAAM,SAAS,MAAM,OAAO,OAAO,aAAa,MAAM,IAAI,GAAG,MAAM;GACnE,IAAI,OAAO,UAAU,MAAM,WAAW;GACtC,KAAK;IAAE,MAAM;IAAW,QAAQ;IAAI;IAAM;GAAO,GAAG,CAAC,OAAO,MAAM,CAAC;GACnE,KAAK,SAAS,IAAI,IAAI;EACxB;CACF;CAEA,OAAO;EACL,MAAM,QAAQ,QAAQ,QAAqB,UAA+B,CAAC,GAAG;GAC5E,MAAM,EAAE,WAAW;GACnB,IAAI;IACF,QAAQ;GACV,SAAS,OAAO;IACd,SAAS,cAAe,MAAgB,OAAO;GACjD;GACA,IAAI,QAAQ,MAAM,IAAI,MAAM,MAAM;GAClC,IAAI,WAAW,SAAS;IACtB,UAAU;IACV;IACA,MAAM,MAAM;IACZ,KAAK,WAAW,MAAM;IACtB,KAAK,SAAS,MAAM;IACpB,MAAM,SAAS,SAAS,MAAM;IAC9B,KAAK,MAAM,KAAK,QAAQ,MAAM,IAAI,EAAE,IAAI;IACxC,KAAK;KACH,MAAM;KACN,QAAQ;KACR,QAAQ,OAAO;KACf,QAAQ,OAAO;KACf;IACF,CAAC;GACH;GACA,MAAM,OAAO,cAAc,QAAQ,QAAQ,QAAQ,WAAW;GAC9D,MAAM,UAAU,KAAK,WAAW,KAAK,QAAQ,MAAM,MAAM,CAAC;GAC1D,OAAO,QAAQ,YAAY,CAAC,CAAC;GAC7B,MAAM;GAEN,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS;IACtC,IAAI,QAAQ,SAAS,MAAM,WAAW;IACtC,MAAM,KAAK;IACX,MAAM,SAAS,MAAM,IAAI,SAA0B,YAAY;KAC7D,IAAI,QAAQ,OAAO,QAAQ;MAAE,MAAM;MAAS;MAAI,SAAS;KAAO,CAAC;KACjE,QAAQ,IAAI,IAAI,EAAE,QAAQ,CAAC;KAC3B,KAAK;MAAE,MAAM;MAAW,QAAQ;MAAU;MAAI;KAAO,CAAC;IACxD,CAAC;IACD,IAAI,OAAO,SAAS,UAAU,OAAO,YAAY,OAAO,OAAO,QAAQ,QAAQ,MAAM;IACrF,IAAI,OAAO,SAAS,SAAS,MAAM,IAAI,MAAM,OAAO,OAAO;IAC3D,IAAI,OAAO,SAAS,WAAW,MAAM,WAAW;IAChD,MAAM,KAAK,QAAQ,QAAQ,MAAM;GACnC;GACA,MAAM,IAAI,MAAM,oEAAoE;EACtF;EACA,UAAU;GACR,GAAG,YAAY;GACf,IAAI;GACJ,UAAU;GACV,KAAK,MAAM,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;IAAE,MAAM;IAAW,IAAI;GAAG,CAAC;GAC3E,QAAQ,MAAM;EAChB;CACF;AACF"}