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

package/dist/core/data.js

@@ -0,0 +1,257 @@
+import { inOrder } from "./hit.js";
+import { toRaw } from "vue";
+// src/core/data.ts
+/** Whether `data` is given by column. */
+var byColumn = (data) => !Array.isArray(data);
+/** How many rows `data` has: the length of its first column, when by column. */
+function rowCount(data) {
+	if (!byColumn(data)) return data.length;
+	for (const key in data) return data[key].length;
+	return 0;
+}
+var columnRows = /* @__PURE__ */ new WeakMap();
+/**
+* Row `i` of `data`. A row of columns is put together when first asked
+* for, and is then the same object each time.
+*/
+function rowOf(data, i) {
+	if (!byColumn(data)) return data[i];
+	let made = columnRows.get(data);
+	if (!made) columnRows.set(data, made = /* @__PURE__ */ new Map());
+	let row = made.get(i);
+	if (!row) {
+		row = {};
+		for (const key in data) row[key] = data[key][i];
+		made.set(i, row);
+	}
+	return row;
+}
+var DATE = /^(\d{4})-(\d{1,2})(?:-(\d{1,2}))?(?:[ T](\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/;
+/**
+* A point in time in ms, or `NaN`. Dates without a zone (`'2026-10-31'`,
+* `'2026-10-31 09:30'`) are read in local time, the way people write them.
+*/
+function toTime(value) {
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "number") return value;
+	if (typeof value !== "string") return NaN;
+	const match = DATE.exec(value.trim());
+	if (match) {
+		const [, y, mo, d, h, mi, s, ms] = match;
+		return new Date(Number(y), Number(mo) - 1, d ? Number(d) : 1, h ? Number(h) : 0, mi ? Number(mi) : 0, s ? Number(s) : 0, ms ? Number(ms.slice(0, 3).padEnd(3, "0")) : 0).getTime();
+	}
+	return Date.parse(value);
+}
+/** Reads `accessor` from `row`. */
+function read(row, accessor, index) {
+	if (typeof accessor === "function") return accessor(row, index);
+	return row == null ? void 0 : row[accessor];
+}
+/** Places rows by their index when there is no x. */
+var byIndex = (_row, index) => index;
+/** Guesses how x values are meant from the first one that is there. */
+function inferXKind(rows, accessor) {
+	const column = byColumn(rows) && typeof accessor === "string" ? rows[accessor] : null;
+	for (let i = 0, n = rowCount(rows); i < n; i++) {
+		const value = column ? column[i] : read(rowOf(rows, i), accessor, i);
+		if (value == null || value === "") continue;
+		if (typeof value === "number") return "linear";
+		if (value instanceof Date) return "time";
+		if (typeof value === "string" && DATE.test(value.trim())) return "time";
+		return "category";
+	}
+	return "linear";
+}
+var cache = /* @__PURE__ */ new WeakMap();
+/** The last array a column was built from, for each scope and key. */
+var latest = /* @__PURE__ */ new Map();
+/** At most this many rows gone from the start, for the rest to be kept. */
+var MOST_DROPPED = 4096;
+/**
+* How `rows` carries on from `before`: how many rows of `before` are gone
+* from its start (`dropped`) and how many are kept (`kept`, the start of
+* `rows`). `null` when it doesn't carry on from it.
+*/
+function carriesOn(rows, before) {
+	if (!rows.length || !before.length) return null;
+	const first = rows[0];
+	let dropped = -1;
+	for (let i = 0, most = Math.min(before.length, MOST_DROPPED); i < most; i++) if (before[i] === first) {
+		dropped = i;
+		break;
+	}
+	if (dropped < 0) return null;
+	const kept = before.length - dropped;
+	if (kept >= rows.length) return null;
+	if (rows[kept - 1] !== before[before.length - 1]) return null;
+	if (rows[kept >> 1] !== before[dropped + (kept >> 1)]) return null;
+	return {
+		dropped,
+		kept
+	};
+}
+function cached(rows, scope, key, build, extend) {
+	let scopes = cache.get(rows);
+	if (!scopes) cache.set(rows, scopes = /* @__PURE__ */ new Map());
+	let entries = scopes.get(scope);
+	if (!entries) scopes.set(scope, entries = /* @__PURE__ */ new Map());
+	if (entries.has(key)) return entries.get(key);
+	const name = typeof key === "string" ? `${scope}\u0000${key}` : null;
+	let value = null;
+	const live = name && extend && !byColumn(rows);
+	if (live) {
+		const last = latest.get(name);
+		const before = last?.rows.deref();
+		const link = before && carriesOn(rows, before);
+		if (link) value = extend(last.value, link.dropped, link.kept);
+	}
+	value ??= build();
+	entries.set(key, value);
+	if (live && typeof WeakRef === "function") latest.set(name, {
+		rows: new WeakRef(rows),
+		value
+	});
+	return value;
+}
+/** Whether a column is a typed array of numbers, which can be copied at once. */
+var isNumbers = (column) => ArrayBuffer.isView(column) && !(column instanceof DataView) && !(column instanceof BigInt64Array) && !(column instanceof BigUint64Array);
+/** A value that isn't a number, read as one: `NaN` for none. */
+function slowNumber(value) {
+	return value == null || value === "" ? NaN : Number(value);
+}
+/** Reads the x of each row from `from` on into `values`, as numbers or times (not categories). */
+function readX(rows, accessor, time, from, values) {
+	if (accessor === byIndex) {
+		for (let i = from; i < values.length; i++) values[i] = i;
+		return;
+	}
+	if (byColumn(rows)) {
+		const column = typeof accessor === "string" ? toRaw(rows[accessor]) ?? [] : null;
+		if (from === 0 && isNumbers(column)) return values.set(column.subarray(0, values.length));
+		for (let i = from, n = values.length; i < n; i++) {
+			const value = column ? column[i] : read(rowOf(rows, i), accessor, i);
+			values[i] = typeof value === "number" ? value : time ? toTime(value) : slowNumber(value);
+		}
+		return;
+	}
+	const key = typeof accessor === "string" ? accessor : null;
+	for (let i = from; i < rows.length; i++) {
+		const row = rows[i];
+		const value = key === null ? read(row, accessor, i) : row == null ? void 0 : row[key];
+		values[i] = typeof value === "number" ? value : time ? toTime(value) : slowNumber(value);
+	}
+}
+/** Reads the y of each row from `from` on into `values`; anything not finite is `NaN`. */
+function readY(rows, accessor, from, values) {
+	if (byColumn(rows)) {
+		const column = typeof accessor === "string" ? toRaw(rows[accessor]) ?? [] : null;
+		if (from === 0 && isNumbers(column)) {
+			values.set(column.subarray(0, values.length));
+			for (let i = 0; i < values.length; i++) {
+				const v = values[i];
+				if (v - v !== 0) values[i] = NaN;
+			}
+			return;
+		}
+		for (let i = from, n = values.length; i < n; i++) {
+			const value = column ? column[i] : read(rowOf(rows, i), accessor, i);
+			const v = typeof value === "number" ? value : slowNumber(value);
+			values[i] = v - v === 0 ? v : NaN;
+		}
+		return;
+	}
+	const key = typeof accessor === "string" ? accessor : null;
+	for (let i = from; i < rows.length; i++) {
+		const row = rows[i];
+		const value = key === null ? read(row, accessor, i) : row == null ? void 0 : row[key];
+		const n = typeof value === "number" ? value : slowNumber(value);
+		values[i] = n - n === 0 ? n : NaN;
+	}
+}
+/** X columns with a gap somewhere. */
+var gapped = /* @__PURE__ */ new WeakSet();
+/**
+* The x values of `rows` as one typed array. Built once per data array,
+* accessor and kind: replace the array (don't change it in place) for the
+* chart to see new data.
+*/
+function xColumn(rows, accessor, kind) {
+	const raw = toRaw(rows);
+	return cached(raw, `x:${kind}`, accessor, () => buildX(raw, accessor, kind), (before, dropped, kept) => {
+		if (kind === "category" || !before.sorted || gapped.has(before.values)) return null;
+		const values = new Float64Array(rowCount(raw));
+		values.set(before.values.subarray(dropped));
+		readX(raw, accessor, kind === "time", kept, values);
+		for (let i = kept; i < values.length; i++) if (!(values[i] >= values[i - 1])) return null;
+		inOrder(values);
+		return {
+			kind,
+			values,
+			categories: before.categories,
+			sorted: true
+		};
+	});
+}
+function buildX(rows, accessor, kind) {
+	const values = new Float64Array(rowCount(rows));
+	const categories = [];
+	if (kind === "category") {
+		const seen = /* @__PURE__ */ new Map();
+		const column = byColumn(rows) && typeof accessor === "string" ? rows[accessor] : null;
+		for (let i = 0; i < values.length; i++) {
+			const value = column ? column[i] : read(rowOf(rows, i), accessor, i);
+			const label = value == null ? "" : String(value);
+			let at = seen.get(label);
+			if (at === void 0) seen.set(label, at = categories.push(label) - 1);
+			values[i] = at;
+		}
+	} else readX(rows, accessor, kind === "time", 0, values);
+	let sorted = true;
+	let gaps = false;
+	let last = -Infinity;
+	for (let i = 0; i < values.length; i++) {
+		const n = values[i];
+		if (n < last) sorted = false;
+		if (n === n) last = n;
+		else gaps = true;
+	}
+	if (sorted && !gaps) inOrder(values);
+	if (gaps) gapped.add(values);
+	return {
+		kind,
+		values,
+		categories,
+		sorted
+	};
+}
+/**
+* The y values of `rows` as one typed array; anything that isn't a finite
+* number (`null`, a gap) is `NaN`.
+*/
+function yColumn(rows, accessor) {
+	const raw = toRaw(rows);
+	return cached(raw, "y", accessor, () => {
+		const values = new Float64Array(rowCount(raw));
+		readY(raw, accessor, 0, values);
+		return values;
+	}, (before, dropped, kept) => {
+		const values = new Float64Array(rowCount(raw));
+		values.set(before.subarray(dropped));
+		readY(raw, accessor, kept, values);
+		return values;
+	});
+}
+/** The smallest and largest number in `values` (skipping `NaN`), or `null`. */
+function extent(values, from = 0, to = values.length) {
+	let min = Infinity;
+	let max = -Infinity;
+	for (let i = from; i < to; i++) {
+		const v = values[i];
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	return min <= max ? [min, max] : null;
+}
+export { byColumn, byIndex, carriesOn, extent, inferXKind, read, rowCount, rowOf, toTime, xColumn, yColumn };
+
+//# sourceMappingURL=data.js.map

package/dist/core/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","names":[],"sources":["../../src/core/data.ts"],"sourcesContent":["import { toRaw } from 'vue'\nimport { inOrder } from './hit'\n\n/** A row of chart data: usually an object, read through accessors. */\nexport type ChartRow = any\n\n/**\n * Data given by column instead of by row: a list of values for each key,\n * all as long as each other. Typed arrays (`Float64Array`) are read\n * fastest; a key reads its column, a function gets a row put together\n * from all the columns.\n */\nexport type ChartColumns = Readonly<Record<string, ArrayLike<unknown>>>\n\n/** Data as rows (objects), or as columns. */\nexport type ChartData = readonly ChartRow[] | ChartColumns\n\n/** Whether `data` is given by column. */\nexport const byColumn = (data: ChartData): data is ChartColumns => !Array.isArray(data)\n\n/** How many rows `data` has: the length of its first column, when by column. */\nexport function rowCount(data: ChartData): number {\n  if (!byColumn(data)) return data.length\n  for (const key in data) return data[key]!.length\n  return 0\n}\n\nconst columnRows = new WeakMap<ChartColumns, Map<number, Record<string, unknown>>>()\n\n/**\n * Row `i` of `data`. A row of columns is put together when first asked\n * for, and is then the same object each time.\n */\nexport function rowOf(data: ChartData, i: number): ChartRow {\n  if (!byColumn(data)) return data[i]\n  let made = columnRows.get(data)\n  if (!made) columnRows.set(data, (made = new Map()))\n  let row = made.get(i)\n  if (!row) {\n    row = {}\n    for (const key in data) row[key] = data[key]![i]\n    made.set(i, row)\n  }\n  return row\n}\n\n/**\n * Picks a value from a row: a key of the row, or a function of the row and\n * its index. Prefer keys for large data: a function written inline in the\n * template is new on every render, so its column can't be cached.\n */\nexport type ChartAccessor<V = unknown> = string | ((row: ChartRow, index: number) => V)\n\n/** How x values are read: numbers, points in time (ms), or categories. */\nexport type XKind = 'linear' | 'time' | 'category'\n\nexport interface XColumn {\n  kind: XKind\n  /** Numbers, times in ms, or the index of each row's category in `categories`. */\n  values: Float64Array\n  /** For `category`: the categories in the order they first appear. */\n  categories: string[]\n  /** Whether `values` never go down, so the visible part can be found by bisection. */\n  sorted: boolean\n}\n\nconst DATE = /^(\\d{4})-(\\d{1,2})(?:-(\\d{1,2}))?(?:[ T](\\d{1,2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d+))?)?)?$/\n\n/**\n * A point in time in ms, or `NaN`. Dates without a zone (`'2026-10-31'`,\n * `'2026-10-31 09:30'`) are read in local time, the way people write them.\n */\nexport function toTime(value: unknown): number {\n  if (value instanceof Date) return value.getTime()\n  if (typeof value === 'number') return value\n  if (typeof value !== 'string') return Number.NaN\n  const match = DATE.exec(value.trim())\n  if (match) {\n    const [, y, mo, d, h, mi, s, ms] = match\n    return new Date(\n      Number(y),\n      Number(mo) - 1,\n      d ? Number(d) : 1,\n      h ? Number(h) : 0,\n      mi ? Number(mi) : 0,\n      s ? Number(s) : 0,\n      ms ? Number(ms.slice(0, 3).padEnd(3, '0')) : 0,\n    ).getTime()\n  }\n  return Date.parse(value)\n}\n\n/** Reads `accessor` from `row`. */\nexport function read(row: ChartRow, accessor: ChartAccessor, index: number): unknown {\n  if (typeof accessor === 'function') return accessor(row, index)\n  return row == null ? undefined : (row as Record<string, unknown>)[accessor]\n}\n\n/** Places rows by their index when there is no x. */\nexport const byIndex: ChartAccessor = (_row, index) => index\n\n/** Guesses how x values are meant from the first one that is there. */\nexport function inferXKind(rows: ChartData, accessor: ChartAccessor): XKind {\n  const column = byColumn(rows) && typeof accessor === 'string' ? rows[accessor] : null\n  for (let i = 0, n = rowCount(rows); i < n; i++) {\n    const value = column ? column[i] : read(rowOf(rows, i), accessor, i)\n    if (value == null || value === '') continue\n    if (typeof value === 'number') return 'linear'\n    if (value instanceof Date) return 'time'\n    if (typeof value === 'string' && DATE.test(value.trim())) return 'time'\n    return 'category'\n  }\n  return 'linear'\n}\n\n/* columns, cached per data array and accessor */\n\nconst cache = new WeakMap<object, Map<string, Map<unknown, unknown>>>()\n\n/*\n * Live data comes as a new array each time: the last one with a few rows\n * added at the end, and perhaps a few gone from the start. The column of\n * the last array is then moved along and only the new rows are read.\n */\n\n/** The last array a column was built from, for each scope and key. */\nconst latest = new Map<string, { rows: WeakRef<readonly ChartRow[]>; value: unknown }>()\n/** At most this many rows gone from the start, for the rest to be kept. */\nconst MOST_DROPPED = 4096\n\n/**\n * How `rows` carries on from `before`: how many rows of `before` are gone\n * from its start (`dropped`) and how many are kept (`kept`, the start of\n * `rows`). `null` when it doesn't carry on from it.\n */\nexport function carriesOn(\n  rows: readonly ChartRow[],\n  before: readonly ChartRow[],\n): { dropped: number; kept: number } | null {\n  if (!rows.length || !before.length) return null\n  const first = rows[0]\n  let dropped = -1\n  for (let i = 0, most = Math.min(before.length, MOST_DROPPED); i < most; i++) {\n    if (before[i] === first) {\n      dropped = i\n      break\n    }\n  }\n  if (dropped < 0) return null\n  const kept = before.length - dropped\n  // nothing new: the rows may have been changed in place, so read them all\n  if (kept >= rows.length) return null\n  // the same rows at the end and in the middle: taken as the same throughout\n  if (rows[kept - 1] !== before[before.length - 1]) return null\n  if (rows[kept >> 1] !== before[dropped + (kept >> 1)]) return null\n  return { dropped, kept }\n}\n\nfunction cached<T>(\n  rows: ChartData,\n  scope: string,\n  key: unknown,\n  build: () => T,\n  /** Builds it from the column of the array `rows` carries on from. */\n  extend?: (before: T, dropped: number, kept: number) => T | null,\n): T {\n  let scopes = cache.get(rows)\n  if (!scopes) cache.set(rows, (scopes = new Map()))\n  let entries = scopes.get(scope)\n  if (!entries) scopes.set(scope, (entries = new Map()))\n  if (entries.has(key)) return entries.get(key) as T\n  // only keys read the same row the same wherever it is: a function also gets the index\n  const name = typeof key === 'string' ? `${scope}\\u0000${key}` : null\n  let value: T | null = null\n  // live data comes as rows\n  const live = name && extend && !byColumn(rows)\n  if (live) {\n    const last = latest.get(name)\n    const before = last?.rows.deref()\n    const link = before && carriesOn(rows, before)\n    if (link) value = extend(last!.value as T, link.dropped, link.kept)\n  }\n  value ??= build()\n  entries.set(key, value)\n  if (live && typeof WeakRef === 'function') latest.set(name, { rows: new WeakRef(rows), value })\n  return value\n}\n\n/*\n * Reading columns: the loops below run once per row of data that may have\n * a million rows, so they read a key straight off the row and take a\n * number as it is without a call. Rows of a raw array are raw themselves,\n * so they aren't unwrapped one by one.\n */\n\ntype Numbers =\n  | Float64Array\n  | Float32Array\n  | Int32Array\n  | Uint32Array\n  | Int16Array\n  | Uint16Array\n  | Int8Array\n  | Uint8Array\n\n/** Whether a column is a typed array of numbers, which can be copied at once. */\nconst isNumbers = (column: unknown): column is Numbers =>\n  ArrayBuffer.isView(column) &&\n  !(column instanceof DataView) &&\n  !(column instanceof BigInt64Array) &&\n  !(column instanceof BigUint64Array)\n\n/** A value that isn't a number, read as one: `NaN` for none. */\nfunction slowNumber(value: unknown): number {\n  return value == null || value === '' ? Number.NaN : Number(value)\n}\n\n/** Reads the x of each row from `from` on into `values`, as numbers or times (not categories). */\nfunction readX(\n  rows: ChartData,\n  accessor: ChartAccessor,\n  time: boolean,\n  from: number,\n  values: Float64Array,\n) {\n  if (accessor === byIndex) {\n    for (let i = from; i < values.length; i++) values[i] = i\n    return\n  }\n  if (byColumn(rows)) {\n    const column = typeof accessor === 'string' ? (toRaw(rows[accessor]) ?? []) : null\n    // numbers already: copied at once\n    if (from === 0 && isNumbers(column)) return values.set(column.subarray(0, values.length))\n    for (let i = from, n = values.length; i < n; i++) {\n      const value = column ? column[i] : read(rowOf(rows, i), accessor, i)\n      values[i] = typeof value === 'number' ? value : time ? toTime(value) : slowNumber(value)\n    }\n    return\n  }\n  const key = typeof accessor === 'string' ? accessor : null\n  for (let i = from; i < rows.length; i++) {\n    const row = rows[i]\n    const value = key === null ? read(row, accessor, i) : row == null ? undefined : row[key]\n    values[i] = typeof value === 'number' ? value : time ? toTime(value) : slowNumber(value)\n  }\n}\n\n/** Reads the y of each row from `from` on into `values`; anything not finite is `NaN`. */\nfunction readY(rows: ChartData, accessor: ChartAccessor, from: number, values: Float64Array) {\n  if (byColumn(rows)) {\n    const column = typeof accessor === 'string' ? (toRaw(rows[accessor]) ?? []) : null\n    if (from === 0 && isNumbers(column)) {\n      values.set(column.subarray(0, values.length))\n      for (let i = 0; i < values.length; i++) {\n        const v = values[i]!\n        if (v - v !== 0) values[i] = Number.NaN\n      }\n      return\n    }\n    for (let i = from, n = values.length; i < n; i++) {\n      const value = column ? column[i] : read(rowOf(rows, i), accessor, i)\n      const v = typeof value === 'number' ? value : slowNumber(value)\n      values[i] = v - v === 0 ? v : Number.NaN\n    }\n    return\n  }\n  const key = typeof accessor === 'string' ? accessor : null\n  for (let i = from; i < rows.length; i++) {\n    const row = rows[i]\n    const value = key === null ? read(row, accessor, i) : row == null ? undefined : row[key]\n    const n = typeof value === 'number' ? value : slowNumber(value)\n    // `n - n` is 0 only for finite numbers\n    values[i] = n - n === 0 ? n : Number.NaN\n  }\n}\n\n/** X columns with a gap somewhere. */\nconst gapped = new WeakSet<Float64Array>()\n\n/**\n * The x values of `rows` as one typed array. Built once per data array,\n * accessor and kind: replace the array (don't change it in place) for the\n * chart to see new data.\n */\nexport function xColumn(rows: ChartData, accessor: ChartAccessor, kind: XKind): XColumn {\n  const raw = toRaw(rows)\n  return cached(\n    raw,\n    `x:${kind}`,\n    accessor,\n    () => buildX(raw, accessor, kind),\n    (before, dropped, kept) => {\n      // categories and gaps of the dropped rows would linger: built afresh\n      if (kind === 'category' || !before.sorted || gapped.has(before.values)) return null\n      const values = new Float64Array(rowCount(raw))\n      values.set(before.values.subarray(dropped))\n      readX(raw, accessor, kind === 'time', kept, values)\n      // out of order or missing: built afresh, which works out the rest\n      for (let i = kept; i < values.length; i++) if (!(values[i]! >= values[i - 1]!)) return null\n      inOrder(values)\n      return { kind, values, categories: before.categories, sorted: true }\n    },\n  )\n}\n\nfunction buildX(rows: ChartData, accessor: ChartAccessor, kind: XKind): XColumn {\n  const values = new Float64Array(rowCount(rows))\n  const categories: string[] = []\n  if (kind === 'category') {\n    const seen = new Map<string, number>()\n    const column = byColumn(rows) && typeof accessor === 'string' ? rows[accessor] : null\n    for (let i = 0; i < values.length; i++) {\n      const value = column ? column[i] : read(rowOf(rows, i), accessor, i)\n      const label = value == null ? '' : String(value)\n      let at = seen.get(label)\n      if (at === undefined) seen.set(label, (at = categories.push(label) - 1))\n      values[i] = at\n    }\n  } else readX(rows, accessor, kind === 'time', 0, values)\n  let sorted = true\n  let gaps = false\n  let last = -Infinity\n  for (let i = 0; i < values.length; i++) {\n    const n = values[i]!\n    if (n < last) sorted = false\n    if (n === n) last = n\n    else gaps = true\n  }\n  // the order hovering needs is then just as the rows come\n  if (sorted && !gaps) inOrder(values)\n  if (gaps) gapped.add(values)\n  return { kind, values, categories, sorted }\n}\n\n/**\n * The y values of `rows` as one typed array; anything that isn't a finite\n * number (`null`, a gap) is `NaN`.\n */\nexport function yColumn(rows: ChartData, accessor: ChartAccessor): Float64Array {\n  const raw = toRaw(rows)\n  return cached(\n    raw,\n    'y',\n    accessor,\n    () => {\n      const values = new Float64Array(rowCount(raw))\n      readY(raw, accessor, 0, values)\n      return values\n    },\n    (before, dropped, kept) => {\n      const values = new Float64Array(rowCount(raw))\n      values.set(before.subarray(dropped))\n      readY(raw, accessor, kept, values)\n      return values\n    },\n  )\n}\n\n/** The smallest and largest number in `values` (skipping `NaN`), or `null`. */\nexport function extent(\n  values: ArrayLike<number>,\n  from = 0,\n  to = values.length,\n): [number, number] | null {\n  let min = Infinity\n  let max = -Infinity\n  for (let i = from; i < to; i++) {\n    const v = values[i]!\n    if (v < min) min = v\n    if (v > max) max = v\n  }\n  return min <= max ? [min, max] : null\n}\n\n/** The first index whose value is `>= target`, in a sorted array (`NaN`s aside). */\nexport function bisect(\n  values: ArrayLike<number>,\n  target: number,\n  lo = 0,\n  hi = values.length,\n): number {\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1\n    if (values[mid]! < target) lo = mid + 1\n    else hi = mid\n  }\n  return lo\n}\n"],"mappings":"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"}

package/dist/core/decimate.js

@@ -0,0 +1,211 @@
+var pool = /* @__PURE__ */ new Int32Array(1024);
+/** Points per block at the first level; each level up takes this many blocks. */
+var SHIFT = 5;
+var BLOCK = 32;
+/** Below this many points a line is quick enough without summaries. */
+var SUMMARIZED = 16384;
+var summaries = /* @__PURE__ */ new WeakMap();
+/** The summaries of `ys` along `xs` if they have been made. */
+function summaryOf(xs, ys) {
+	const known = summaries.get(ys);
+	return known && known.xs === xs ? known.levels : null;
+}
+/** Makes the summaries of a sorted line long enough to need them, finest first. */
+function summarize(xs, ys) {
+	if (Math.min(xs.length, ys.length) < SUMMARIZED) return null;
+	const known = summaryOf(xs, ys);
+	if (known) return known;
+	const n = Math.min(xs.length, ys.length);
+	const levels = [];
+	let count = n >> SHIFT;
+	let low = new Int32Array(count);
+	let high = new Int32Array(count);
+	let gap = new Uint8Array(count);
+	for (let b = 0; b < count; b++) {
+		let lo = -1;
+		let hi = -1;
+		let broken = 0;
+		for (let i = b << SHIFT, end = i + BLOCK; i < end; i++) {
+			const y = ys[i];
+			if (y !== y || xs[i] !== xs[i]) {
+				broken = 1;
+				continue;
+			}
+			if (lo < 0 || y < ys[lo]) lo = i;
+			if (hi < 0 || y > ys[hi]) hi = i;
+		}
+		low[b] = lo;
+		high[b] = hi;
+		gap[b] = broken;
+	}
+	levels.push({
+		size: BLOCK,
+		low,
+		high,
+		gap
+	});
+	while (count >= BLOCK) {
+		const under = levels[levels.length - 1];
+		count >>= SHIFT;
+		low = new Int32Array(count);
+		high = new Int32Array(count);
+		gap = new Uint8Array(count);
+		for (let b = 0; b < count; b++) {
+			let lo = -1;
+			let hi = -1;
+			let broken = 0;
+			for (let k = b << SHIFT, end = k + BLOCK; k < end; k++) {
+				broken |= under.gap[k];
+				const l = under.low[k];
+				const h = under.high[k];
+				if (l >= 0 && (lo < 0 || ys[l] < ys[lo])) lo = l;
+				if (h >= 0 && (hi < 0 || ys[h] > ys[hi])) hi = h;
+			}
+			low[b] = lo;
+			high[b] = hi;
+			gap[b] = broken;
+		}
+		levels.push({
+			size: under.size << SHIFT,
+			low,
+			high,
+			gap
+		});
+	}
+	summaries.set(ys, {
+		xs,
+		levels
+	});
+	return levels;
+}
+/**
+* The indices from `from` to `to` (exclusive) to draw, in order, with
+* `BREAK` between runs that a gap (a `NaN` y) splits. With `connect`, gaps
+* are skipped instead. Columns are whole pixels of the x scale `x * k + b`.
+*
+* The returned array is reused by the next call: use it before calling again.
+*/
+function decimate(xs, ys, from, to, k, b, connect = false, sorted = false) {
+	const levels = sorted && to - from >= SUMMARIZED ? summaryOf(xs, ys) : null;
+	let out = pool;
+	let length = 0;
+	const push = (index) => {
+		if (length === out.length) {
+			const bigger = new Int32Array(out.length * 2);
+			bigger.set(out);
+			out = pool = bigger;
+		}
+		out[length++] = index;
+	};
+	let column = NaN;
+	let first = -1;
+	let last = -1;
+	let min = -1;
+	let max = -1;
+	let low = 0;
+	let high = 0;
+	const flush = () => {
+		if (first < 0) return;
+		push(first);
+		const early = min < max ? min : max;
+		const late = min < max ? max : min;
+		if (early !== first && early !== last) push(early);
+		if (late !== first && late !== last && late !== early) push(late);
+		if (last !== first) push(last);
+		first = last = min = max = -1;
+	};
+	for (let i = from; i < to; i++) {
+		if (levels && (i & 31) === 0) {
+			let taken = false;
+			for (let l = levels.length - 1; l >= 0 && !taken; l--) {
+				const level = levels[l];
+				const size = level.size;
+				if (i % size !== 0 || i + size > to) continue;
+				const block = i / size;
+				if (level.gap[block]) continue;
+				const c = Math.floor(xs[i] * k + b);
+				if (Math.floor(xs[i + size - 1] * k + b) !== c) continue;
+				const lo = level.low[block];
+				const hi = level.high[block];
+				if (c !== column) {
+					flush();
+					column = c;
+					first = i;
+					min = lo;
+					max = hi;
+					low = ys[lo];
+					high = ys[hi];
+				} else {
+					if (ys[lo] < low) {
+						low = ys[lo];
+						min = lo;
+					}
+					if (ys[hi] > high) {
+						high = ys[hi];
+						max = hi;
+					}
+				}
+				last = i + size - 1;
+				i += size - 1;
+				taken = true;
+			}
+			if (taken) continue;
+		}
+		const y = ys[i];
+		const x = xs[i];
+		if (y !== y || x !== x) {
+			if (connect) continue;
+			flush();
+			if (length > 0 && out[length - 1] !== -1) push(-1);
+			column = NaN;
+			continue;
+		}
+		const c = Math.floor(x * k + b);
+		if (c !== column) {
+			flush();
+			column = c;
+			first = last = min = max = i;
+			low = high = y;
+			continue;
+		}
+		last = i;
+		if (y < low) {
+			low = y;
+			min = i;
+		} else if (y > high) {
+			high = y;
+			max = i;
+		}
+	}
+	flush();
+	return {
+		indices: out,
+		length
+	};
+}
+/**
+* The part of a sorted x column that is on screen, widened by one point on
+* each side so lines run to the edge.
+*/
+function visibleRange(xs, sorted, lo, hi) {
+	if (!sorted) return [0, xs.length];
+	let a = 0;
+	let b = xs.length;
+	while (a < b) {
+		const mid = a + b >>> 1;
+		if (xs[mid] < lo) a = mid + 1;
+		else b = mid;
+	}
+	const from = Math.max(0, a - 1);
+	a = from;
+	b = xs.length;
+	while (a < b) {
+		const mid = a + b >>> 1;
+		if (xs[mid] <= hi) a = mid + 1;
+		else b = mid;
+	}
+	return [from, Math.min(xs.length, a + 1)];
+}
+export { decimate, summarize, visibleRange };
+
+//# sourceMappingURL=decimate.js.map

package/dist/core/decimate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimate.js","names":[],"sources":["../../src/core/decimate.ts"],"sourcesContent":["/**\n * Picks the points worth drawing. A pixel column can't show more than its\n * first, lowest, highest and last point, so a line of a million points is\n * drawn from at most four per column and looks exactly the same.\n */\n\n/** Marks a break in the line: a gap in the data. */\nexport const BREAK = -1\n\nlet pool = new Int32Array(1024)\n\n/*\n * Summaries of a long sorted line, for skipping over it: for each block of\n * 32 points (then of 32 blocks, and so on) the lowest and highest point in\n * it and whether it has a gap. A block that falls in one pixel column is\n * taken whole, so a column of thousands of points costs a few dozen steps.\n * Made when the page is idle (see `prepare`), not for data that is drawn\n * once and replaced, as live data is.\n */\n\n/** Points per block at the first level; each level up takes this many blocks. */\nconst SHIFT = 5\nconst BLOCK = 1 << SHIFT\n/** Below this many points a line is quick enough without summaries. */\nconst SUMMARIZED = 1 << 14\n\ninterface Level {\n  /** Points per block. */\n  size: number\n  /** The row of the lowest and the highest y in each block. */\n  low: Int32Array\n  high: Int32Array\n  /** Whether a block has a gap (a `NaN` x or y). */\n  gap: Uint8Array\n}\n\nconst summaries = new WeakMap<Float64Array, { xs: Float64Array; levels: Level[] }>()\n\n/** The summaries of `ys` along `xs` if they have been made. */\nfunction summaryOf(xs: Float64Array, ys: Float64Array): Level[] | null {\n  const known = summaries.get(ys)\n  return known && known.xs === xs ? known.levels : null\n}\n\n/** Makes the summaries of a sorted line long enough to need them, finest first. */\nexport function summarize(xs: Float64Array, ys: Float64Array): Level[] | null {\n  if (Math.min(xs.length, ys.length) < SUMMARIZED) return null\n  const known = summaryOf(xs, ys)\n  if (known) return known\n  const n = Math.min(xs.length, ys.length)\n  const levels: Level[] = []\n  // the first level from the points\n  let count = n >> SHIFT\n  let low = new Int32Array(count)\n  let high = new Int32Array(count)\n  let gap = new Uint8Array(count)\n  for (let b = 0; b < count; b++) {\n    let lo = -1\n    let hi = -1\n    let broken = 0\n    for (let i = b << SHIFT, end = i + BLOCK; i < end; i++) {\n      const y = ys[i]!\n      if (y !== y || xs[i]! !== xs[i]!) {\n        broken = 1\n        continue\n      }\n      if (lo < 0 || y < ys[lo]!) lo = i\n      if (hi < 0 || y > ys[hi]!) hi = i\n    }\n    low[b] = lo\n    high[b] = hi\n    gap[b] = broken\n  }\n  levels.push({ size: BLOCK, low, high, gap })\n  // each next level from the one under it\n  while (count >= BLOCK) {\n    const under = levels[levels.length - 1]!\n    count >>= SHIFT\n    low = new Int32Array(count)\n    high = new Int32Array(count)\n    gap = new Uint8Array(count)\n    for (let b = 0; b < count; b++) {\n      let lo = -1\n      let hi = -1\n      let broken = 0\n      for (let k = b << SHIFT, end = k + BLOCK; k < end; k++) {\n        broken |= under.gap[k]!\n        const l = under.low[k]!\n        const h = under.high[k]!\n        if (l >= 0 && (lo < 0 || ys[l]! < ys[lo]!)) lo = l\n        if (h >= 0 && (hi < 0 || ys[h]! > ys[hi]!)) hi = h\n      }\n      low[b] = lo\n      high[b] = hi\n      gap[b] = broken\n    }\n    levels.push({ size: under.size << SHIFT, low, high, gap })\n  }\n  summaries.set(ys, { xs, levels })\n  return levels\n}\n\n/**\n * The indices from `from` to `to` (exclusive) to draw, in order, with\n * `BREAK` between runs that a gap (a `NaN` y) splits. With `connect`, gaps\n * are skipped instead. Columns are whole pixels of the x scale `x * k + b`.\n *\n * The returned array is reused by the next call: use it before calling again.\n */\nexport function decimate(\n  xs: Float64Array,\n  ys: Float64Array,\n  from: number,\n  to: number,\n  /** Pixel of x is `x * k + b`. */\n  k: number,\n  b: number,\n  connect = false,\n  /** Whether `xs` goes up from start to end: long lines can then skip whole blocks. */\n  sorted = false,\n): { indices: Int32Array; length: number } {\n  const levels = sorted && to - from >= SUMMARIZED ? summaryOf(xs, ys) : null\n  // at most 4 per column plus a break per gap; grow when needed\n  let out = pool\n  let length = 0\n  const push = (index: number) => {\n    if (length === out.length) {\n      const bigger = new Int32Array(out.length * 2)\n      bigger.set(out)\n      out = pool = bigger\n    }\n    out[length++] = index\n  }\n\n  let column = Number.NaN\n  let first = -1\n  let last = -1\n  let min = -1\n  let max = -1\n  let low = 0\n  let high = 0\n  const flush = () => {\n    if (first < 0) return\n    push(first)\n    // the lowest and highest, in the order they come\n    const early = min < max ? min : max\n    const late = min < max ? max : min\n    if (early !== first && early !== last) push(early)\n    if (late !== first && late !== last && late !== early) push(late)\n    if (last !== first) push(last)\n    first = last = min = max = -1\n  }\n\n  for (let i = from; i < to; i++) {\n    // a block of points all in one column: its first, lowest, highest and last at once\n    if (levels && (i & (BLOCK - 1)) === 0) {\n      let taken = false\n      for (let l = levels.length - 1; l >= 0 && !taken; l--) {\n        const level = levels[l]!\n        const size = level.size\n        if (i % size !== 0 || i + size > to) continue\n        const block = i / size\n        if (level.gap[block]) continue\n        const c = Math.floor(xs[i]! * k + b)\n        if (Math.floor(xs[i + size - 1]! * k + b) !== c) continue\n        const lo = level.low[block]!\n        const hi = level.high[block]!\n        if (c !== column) {\n          flush()\n          column = c\n          first = i\n          min = lo\n          max = hi\n          low = ys[lo]!\n          high = ys[hi]!\n        } else {\n          if (ys[lo]! < low) {\n            low = ys[lo]!\n            min = lo\n          }\n          if (ys[hi]! > high) {\n            high = ys[hi]!\n            max = hi\n          }\n        }\n        last = i + size - 1\n        i += size - 1\n        taken = true\n      }\n      if (taken) continue\n    }\n    const y = ys[i]!\n    const x = xs[i]!\n    if (y !== y || x !== x) {\n      if (connect) continue\n      flush()\n      if (length > 0 && out[length - 1] !== BREAK) push(BREAK)\n      column = Number.NaN\n      continue\n    }\n    const c = Math.floor(x * k + b)\n    if (c !== column) {\n      flush()\n      column = c\n      first = last = min = max = i\n      low = high = y\n      continue\n    }\n    last = i\n    if (y < low) {\n      low = y\n      min = i\n    } else if (y > high) {\n      high = y\n      max = i\n    }\n  }\n  flush()\n  return { indices: out, length }\n}\n\n/**\n * The part of a sorted x column that is on screen, widened by one point on\n * each side so lines run to the edge.\n */\nexport function visibleRange(\n  xs: ArrayLike<number>,\n  sorted: boolean,\n  lo: number,\n  hi: number,\n): [number, number] {\n  if (!sorted) return [0, xs.length]\n  let a = 0\n  let b = xs.length\n  while (a < b) {\n    const mid = (a + b) >>> 1\n    if (xs[mid]! < lo) a = mid + 1\n    else b = mid\n  }\n  const from = Math.max(0, a - 1)\n  a = from\n  b = xs.length\n  while (a < b) {\n    const mid = (a + b) >>> 1\n    if (xs[mid]! <= hi) a = mid + 1\n    else b = mid\n  }\n  return [from, Math.min(xs.length, a + 1)]\n}\n"],"mappings":"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"}