@voila.dev/chart 4.0.0

package/dist/core/scales/resolve.js

@@ -0,0 +1,112 @@
+import { linearScale, logScale, toNumber } from "./continuous.js";
+import { bandScale, categoryKey, pointScale } from "./discrete.js";
+import { timeScale } from "./time.js";
+import { niceDomain } from "../ticks.js";
+function inferKind(channels, values) {
+  if (channels.some((channel) => channel.discrete === "band")) {
+    return "band";
+  }
+  const askedPoint = channels.some((channel) => channel.discrete === "point");
+  if (values.length > 0 && values.every((value) => value instanceof Date)) {
+    return askedPoint ? "point" : "time";
+  }
+  if (values.length > 0 && values.every((value) => typeof value === "number")) {
+    return askedPoint ? "point" : "linear";
+  }
+  return "point";
+}
+function distinct(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const value of values) {
+    const key = categoryKey(value);
+    if (!seen.has(key)) {
+      seen.add(key);
+      kept.push(value);
+    }
+  }
+  return kept;
+}
+function continuousDomain(values, options, kind) {
+  let low = Number.POSITIVE_INFINITY;
+  let high = Number.NEGATIVE_INFINITY;
+  for (const value of values) {
+    const number = toNumber(value);
+    if (Number.isFinite(number)) {
+      low = Math.min(low, number);
+      high = Math.max(high, number);
+    }
+  }
+  if (!Number.isFinite(low)) {
+    return [0, 1];
+  }
+  if (options.zero && kind === "linear") {
+    low = Math.min(low, 0);
+    high = Math.max(high, 0);
+  }
+  if (options.nice && kind === "linear") {
+    return niceDomain(low, high);
+  }
+  return [low, high];
+}
+function planScale(channels, options, axis) {
+  if (channels.length === 0) {
+    return void 0;
+  }
+  const values = channels.flatMap((channel) => channel.values);
+  const kind = options?.type ?? inferKind(channels, values);
+  const label = options?.label ?? channels.find((channel) => channel.label)?.label;
+  if (kind === "band" || kind === "point") {
+    const padding = channels.find(
+      (channel) => channel.padding !== void 0
+    )?.padding;
+    const paddingOuter = channels.find(
+      (channel) => channel.paddingOuter !== void 0
+    )?.paddingOuter;
+    return {
+      kind,
+      domain: options?.domain ?? distinct(values),
+      label,
+      padding,
+      paddingOuter: paddingOuter ?? padding
+    };
+  }
+  if (options?.domain !== void 0) {
+    return { kind, domain: options.domain.map(toNumber), label };
+  }
+  const zero = options?.zero ?? channels.some((channel) => channel.includeZero === true);
+  const nice = options?.nice ?? (axis === "y" || zero);
+  return {
+    kind,
+    domain: continuousDomain(values, { zero, nice }, kind),
+    label
+  };
+}
+function buildScale(plan, options, range, locale, tickCount) {
+  const ordered = options?.reverse ? [range[1], range[0]] : range;
+  if (plan.kind === "band" || plan.kind === "point") {
+    const discrete = {
+      domain: plan.domain,
+      range: ordered,
+      locale,
+      paddingInner: options?.paddingInner ?? plan.padding,
+      paddingOuter: options?.paddingOuter ?? plan.paddingOuter
+    };
+    return plan.kind === "band" ? bandScale(discrete) : pointScale(discrete);
+  }
+  const continuous = {
+    domain: [toNumber(plan.domain[0]), toNumber(plan.domain[1])],
+    range: ordered,
+    locale,
+    tickCount
+  };
+  if (plan.kind === "time") {
+    return timeScale(continuous);
+  }
+  return plan.kind === "log" ? logScale(continuous) : linearScale(continuous);
+}
+export {
+  buildScale,
+  planScale
+};
+//# sourceMappingURL=resolve.js.map

package/dist/core/scales/resolve.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/scales/resolve.ts"],
+  "sourcesContent": ["import type { ChartPositionScaleOptions } from \"#/core/define-chart.ts\";\nimport { linearScale, logScale, toNumber } from \"#/core/scales/continuous.ts\";\nimport { bandScale, categoryKey, pointScale } from \"#/core/scales/discrete.ts\";\nimport { timeScale } from \"#/core/scales/time.ts\";\nimport { niceDomain } from \"#/core/ticks.ts\";\nimport type {\n\tChartChannel,\n\tChartPositionScale,\n\tChartPositionScaleKind,\n\tChartValue,\n} from \"#/core/types.ts\";\n\n/**\n * What a scale will be once the plot size is known: its kind and its domain,\n * read off every channel the marks put on it. Split from the range so the\n * axes can measure their tick labels before the plot rectangle exists.\n */\nexport interface ScalePlan {\n\treadonly kind: ChartPositionScaleKind;\n\treadonly domain: ReadonlyArray<ChartValue>;\n\treadonly label: string | undefined;\n\t/** The band padding a mark asked for, when the options name none. */\n\treadonly padding?: number;\n\treadonly paddingOuter?: number;\n}\n\nfunction inferKind(\n\tchannels: ReadonlyArray<ChartChannel>,\n\tvalues: ReadonlyArray<ChartValue>,\n): ChartPositionScaleKind {\n\tif (channels.some((channel) => channel.discrete === \"band\")) {\n\t\treturn \"band\";\n\t}\n\tconst askedPoint = channels.some((channel) => channel.discrete === \"point\");\n\tif (values.length > 0 && values.every((value) => value instanceof Date)) {\n\t\treturn askedPoint ? \"point\" : \"time\";\n\t}\n\tif (values.length > 0 && values.every((value) => typeof value === \"number\")) {\n\t\treturn askedPoint ? \"point\" : \"linear\";\n\t}\n\treturn \"point\";\n}\n\nfunction distinct(\n\tvalues: ReadonlyArray<ChartValue>,\n): ReadonlyArray<ChartValue> {\n\tconst seen = new Set<string>();\n\tconst kept: ChartValue[] = [];\n\tfor (const value of values) {\n\t\tconst key = categoryKey(value);\n\t\tif (!seen.has(key)) {\n\t\t\tseen.add(key);\n\t\t\tkept.push(value);\n\t\t}\n\t}\n\treturn kept;\n}\n\nfunction continuousDomain(\n\tvalues: ReadonlyArray<ChartValue>,\n\toptions: { readonly zero: boolean; readonly nice: boolean },\n\tkind: ChartPositionScaleKind,\n): readonly [number, number] {\n\tlet low = Number.POSITIVE_INFINITY;\n\tlet high = Number.NEGATIVE_INFINITY;\n\tfor (const value of values) {\n\t\tconst number = toNumber(value);\n\t\tif (Number.isFinite(number)) {\n\t\t\tlow = Math.min(low, number);\n\t\t\thigh = Math.max(high, number);\n\t\t}\n\t}\n\tif (!Number.isFinite(low)) {\n\t\treturn [0, 1];\n\t}\n\tif (options.zero && kind === \"linear\") {\n\t\tlow = Math.min(low, 0);\n\t\thigh = Math.max(high, 0);\n\t}\n\tif (options.nice && kind === \"linear\") {\n\t\treturn niceDomain(low, high);\n\t}\n\treturn [low, high];\n}\n\nexport function planScale(\n\tchannels: ReadonlyArray<ChartChannel>,\n\toptions: ChartPositionScaleOptions | undefined,\n\taxis: \"x\" | \"y\",\n): ScalePlan | undefined {\n\tif (channels.length === 0) {\n\t\treturn undefined;\n\t}\n\tconst values = channels.flatMap((channel) => channel.values);\n\tconst kind = options?.type ?? inferKind(channels, values);\n\tconst label =\n\t\toptions?.label ?? channels.find((channel) => channel.label)?.label;\n\tif (kind === \"band\" || kind === \"point\") {\n\t\tconst padding = channels.find(\n\t\t\t(channel) => channel.padding !== undefined,\n\t\t)?.padding;\n\t\tconst paddingOuter = channels.find(\n\t\t\t(channel) => channel.paddingOuter !== undefined,\n\t\t)?.paddingOuter;\n\t\treturn {\n\t\t\tkind,\n\t\t\tdomain: options?.domain ?? distinct(values),\n\t\t\tlabel,\n\t\t\tpadding,\n\t\t\tpaddingOuter: paddingOuter ?? padding,\n\t\t};\n\t}\n\tif (options?.domain !== undefined) {\n\t\treturn { kind, domain: options.domain.map(toNumber), label };\n\t}\n\tconst zero =\n\t\toptions?.zero ?? channels.some((channel) => channel.includeZero === true);\n\t// A value axis (y, or the x of horizontal bars) reads best on round\n\t// numbers; a position axis (the x of a scatter) on the data's own extent.\n\tconst nice = options?.nice ?? (axis === \"y\" || zero);\n\treturn {\n\t\tkind,\n\t\tdomain: continuousDomain(values, { zero, nice }, kind),\n\t\tlabel,\n\t};\n}\n\nexport function buildScale(\n\tplan: ScalePlan,\n\toptions: ChartPositionScaleOptions | undefined,\n\trange: readonly [number, number],\n\tlocale: string,\n\ttickCount: number,\n): ChartPositionScale {\n\tconst ordered: readonly [number, number] = options?.reverse\n\t\t? [range[1], range[0]]\n\t\t: range;\n\tif (plan.kind === \"band\" || plan.kind === \"point\") {\n\t\tconst discrete = {\n\t\t\tdomain: plan.domain,\n\t\t\trange: ordered,\n\t\t\tlocale,\n\t\t\tpaddingInner: options?.paddingInner ?? plan.padding,\n\t\t\tpaddingOuter: options?.paddingOuter ?? plan.paddingOuter,\n\t\t};\n\t\treturn plan.kind === \"band\" ? bandScale(discrete) : pointScale(discrete);\n\t}\n\tconst continuous = {\n\t\tdomain: [toNumber(plan.domain[0]), toNumber(plan.domain[1])] as const,\n\t\trange: ordered,\n\t\tlocale,\n\t\ttickCount,\n\t};\n\tif (plan.kind === \"time\") {\n\t\treturn timeScale(continuous);\n\t}\n\treturn plan.kind === \"log\" ? logScale(continuous) : linearScale(continuous);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/scales/time.d.ts

@@ -0,0 +1,4 @@
+import { type ContinuousScaleOptions } from "./continuous.js";
+import type { ChartPositionScale } from "../types.js";
+export declare function timeScale(options: ContinuousScaleOptions): ChartPositionScale;
+//# sourceMappingURL=time.d.ts.map

package/dist/core/scales/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../src/core/scales/time.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,sBAAsB,EAG3B,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,iBAAiB,CAAC;AA0JtE,wBAAgB,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,kBAAkB,CAkB7E"}

package/dist/core/scales/time.js

@@ -0,0 +1,140 @@
+import { dateFormat } from "../format.js";
+import {
+  linearScale,
+  toNumber
+} from "./continuous.js";
+import { niceTicks } from "../ticks.js";
+const SECOND = 1e3;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const WEEK = 7 * DAY;
+const MONTH = 30 * DAY;
+const YEAR = 365 * DAY;
+const INTERVALS = [
+  { unit: "second", step: 1, duration: SECOND },
+  { unit: "second", step: 5, duration: 5 * SECOND },
+  { unit: "second", step: 15, duration: 15 * SECOND },
+  { unit: "second", step: 30, duration: 30 * SECOND },
+  { unit: "minute", step: 1, duration: MINUTE },
+  { unit: "minute", step: 5, duration: 5 * MINUTE },
+  { unit: "minute", step: 15, duration: 15 * MINUTE },
+  { unit: "minute", step: 30, duration: 30 * MINUTE },
+  { unit: "hour", step: 1, duration: HOUR },
+  { unit: "hour", step: 3, duration: 3 * HOUR },
+  { unit: "hour", step: 6, duration: 6 * HOUR },
+  { unit: "hour", step: 12, duration: 12 * HOUR },
+  { unit: "day", step: 1, duration: DAY },
+  { unit: "day", step: 2, duration: 2 * DAY },
+  { unit: "week", step: 1, duration: WEEK },
+  { unit: "month", step: 1, duration: MONTH },
+  { unit: "month", step: 3, duration: 3 * MONTH },
+  { unit: "month", step: 6, duration: 6 * MONTH },
+  { unit: "year", step: 1, duration: YEAR }
+];
+const UNIT_MS = {
+  second: SECOND,
+  minute: MINUTE,
+  hour: HOUR,
+  day: DAY
+};
+function chooseInterval(span, count) {
+  const target = span / Math.max(1, count);
+  let best = INTERVALS[0];
+  for (const interval of INTERVALS) {
+    if (Math.abs(Math.log(interval.duration / target)) < Math.abs(Math.log(best.duration / target))) {
+      best = interval;
+    }
+  }
+  return best;
+}
+function monthTicks(start, end, step) {
+  const from = new Date(start);
+  const year = from.getUTCFullYear();
+  let month = from.getUTCMonth();
+  month = Math.ceil(month / step) * step;
+  const ticks = [];
+  for (; ; ) {
+    const time = Date.UTC(year + Math.floor(month / 12), month % 12, 1);
+    if (time > end) {
+      return ticks;
+    }
+    if (time >= start) {
+      ticks.push(time);
+    }
+    month += step;
+  }
+}
+function intervalTicks(start, end, interval) {
+  const { unit, step } = interval;
+  if (unit === "year") {
+    const years = niceTicks(
+      new Date(start).getUTCFullYear(),
+      new Date(end).getUTCFullYear(),
+      Math.max(1, Math.round((end - start) / YEAR))
+    ).filter(Number.isInteger);
+    return years.map((year) => Date.UTC(year, 0, 1)).filter((time) => time >= start && time <= end);
+  }
+  if (unit === "month") {
+    return monthTicks(start, end, step);
+  }
+  if (unit === "week") {
+    const monday = Date.UTC(1970, 0, 5);
+    const first = monday + Math.ceil((start - monday) / WEEK) * WEEK;
+    const ticks2 = [];
+    for (let time = first; time <= end; time += WEEK) {
+      ticks2.push(time);
+    }
+    return ticks2;
+  }
+  const size = UNIT_MS[unit] * step;
+  const ticks = [];
+  for (let time = Math.ceil(start / size) * size; time <= end; time += size) {
+    ticks.push(time);
+  }
+  return ticks;
+}
+function tickLabel(time, unit, locale) {
+  const date = new Date(time);
+  if (unit === "year") {
+    return dateFormat(locale, { year: "numeric" }).format(date);
+  }
+  if (unit === "month") {
+    return date.getUTCMonth() === 0 ? dateFormat(locale, { month: "short", year: "numeric" }).format(date) : dateFormat(locale, { month: "short" }).format(date);
+  }
+  if (unit === "day" || unit === "week") {
+    return dateFormat(locale, { day: "numeric", month: "short" }).format(date);
+  }
+  if (unit === "second") {
+    return dateFormat(locale, {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    }).format(date);
+  }
+  return dateFormat(locale, { hour: "2-digit", minute: "2-digit" }).format(
+    date
+  );
+}
+function timeScale(options) {
+  const { domain, locale, tickCount } = options;
+  const linear = linearScale(options);
+  const [start, end] = [Math.min(...domain), Math.max(...domain)];
+  let unit = chooseInterval(end - start, tickCount).unit;
+  return {
+    ...linear,
+    kind: "time",
+    domain: [new Date(domain[0]), new Date(domain[1])],
+    invert: (pixel) => new Date(toNumber(linear.invert(pixel))),
+    ticks: (count = tickCount) => {
+      const interval = chooseInterval(end - start, count);
+      unit = interval.unit;
+      return intervalTicks(start, end, interval).map((time) => new Date(time));
+    },
+    format: (value) => tickLabel(toNumber(value), unit, locale)
+  };
+}
+export {
+  timeScale
+};
+//# sourceMappingURL=time.js.map

package/dist/core/scales/time.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/scales/time.ts"],
+  "sourcesContent": ["import { dateFormat } from \"#/core/format.ts\";\nimport {\n\ttype ContinuousScaleOptions,\n\tlinearScale,\n\ttoNumber,\n} from \"#/core/scales/continuous.ts\";\nimport { niceTicks } from \"#/core/ticks.ts\";\nimport type { ChartPositionScale, ChartValue } from \"#/core/types.ts\";\n\n/**\n * Dates in, pixels out. Ticks land on calendar boundaries (midnight, the first\n * of the month, New Year) rather than on round millisecond counts, and their\n * labels only say what changes between two ticks.\n *\n * Everything is UTC. Chart data is mostly day or month buckets written as\n * `2026-03-01`, which JavaScript parses as UTC midnight: reading them in the\n * viewer's zone would push every bucket onto the previous day west of\n * Greenwich.\n */\n\nconst SECOND = 1000;\nconst MINUTE = 60 * SECOND;\nconst HOUR = 60 * MINUTE;\nconst DAY = 24 * HOUR;\nconst WEEK = 7 * DAY;\nconst MONTH = 30 * DAY;\nconst YEAR = 365 * DAY;\n\ntype Unit = \"second\" | \"minute\" | \"hour\" | \"day\" | \"week\" | \"month\" | \"year\";\n\ninterface TimeInterval {\n\treadonly unit: Unit;\n\treadonly step: number;\n\t/** Approximate length, only to pick the interval closest to the tick count. */\n\treadonly duration: number;\n}\n\nconst INTERVALS: ReadonlyArray<TimeInterval> = [\n\t{ unit: \"second\", step: 1, duration: SECOND },\n\t{ unit: \"second\", step: 5, duration: 5 * SECOND },\n\t{ unit: \"second\", step: 15, duration: 15 * SECOND },\n\t{ unit: \"second\", step: 30, duration: 30 * SECOND },\n\t{ unit: \"minute\", step: 1, duration: MINUTE },\n\t{ unit: \"minute\", step: 5, duration: 5 * MINUTE },\n\t{ unit: \"minute\", step: 15, duration: 15 * MINUTE },\n\t{ unit: \"minute\", step: 30, duration: 30 * MINUTE },\n\t{ unit: \"hour\", step: 1, duration: HOUR },\n\t{ unit: \"hour\", step: 3, duration: 3 * HOUR },\n\t{ unit: \"hour\", step: 6, duration: 6 * HOUR },\n\t{ unit: \"hour\", step: 12, duration: 12 * HOUR },\n\t{ unit: \"day\", step: 1, duration: DAY },\n\t{ unit: \"day\", step: 2, duration: 2 * DAY },\n\t{ unit: \"week\", step: 1, duration: WEEK },\n\t{ unit: \"month\", step: 1, duration: MONTH },\n\t{ unit: \"month\", step: 3, duration: 3 * MONTH },\n\t{ unit: \"month\", step: 6, duration: 6 * MONTH },\n\t{ unit: \"year\", step: 1, duration: YEAR },\n];\n\nconst UNIT_MS: Record<\"second\" | \"minute\" | \"hour\" | \"day\", number> = {\n\tsecond: SECOND,\n\tminute: MINUTE,\n\thour: HOUR,\n\tday: DAY,\n};\n\nfunction chooseInterval(span: number, count: number): TimeInterval {\n\tconst target = span / Math.max(1, count);\n\tlet best = INTERVALS[0];\n\tfor (const interval of INTERVALS) {\n\t\tif (\n\t\t\tMath.abs(Math.log(interval.duration / target)) <\n\t\t\tMath.abs(Math.log(best.duration / target))\n\t\t) {\n\t\t\tbest = interval;\n\t\t}\n\t}\n\treturn best;\n}\n\nfunction monthTicks(start: number, end: number, step: number): number[] {\n\tconst from = new Date(start);\n\tconst year = from.getUTCFullYear();\n\tlet month = from.getUTCMonth();\n\tmonth = Math.ceil(month / step) * step;\n\tconst ticks: number[] = [];\n\tfor (;;) {\n\t\tconst time = Date.UTC(year + Math.floor(month / 12), month % 12, 1);\n\t\tif (time > end) {\n\t\t\treturn ticks;\n\t\t}\n\t\tif (time >= start) {\n\t\t\tticks.push(time);\n\t\t}\n\t\tmonth += step;\n\t}\n}\n\nfunction intervalTicks(\n\tstart: number,\n\tend: number,\n\tinterval: TimeInterval,\n): number[] {\n\tconst { unit, step } = interval;\n\tif (unit === \"year\") {\n\t\tconst years = niceTicks(\n\t\t\tnew Date(start).getUTCFullYear(),\n\t\t\tnew Date(end).getUTCFullYear(),\n\t\t\tMath.max(1, Math.round((end - start) / YEAR)),\n\t\t).filter(Number.isInteger);\n\t\treturn years\n\t\t\t.map((year) => Date.UTC(year, 0, 1))\n\t\t\t.filter((time) => time >= start && time <= end);\n\t}\n\tif (unit === \"month\") {\n\t\treturn monthTicks(start, end, step);\n\t}\n\tif (unit === \"week\") {\n\t\t// Weeks start on Monday: 1970-01-05 was one.\n\t\tconst monday = Date.UTC(1970, 0, 5);\n\t\tconst first = monday + Math.ceil((start - monday) / WEEK) * WEEK;\n\t\tconst ticks: number[] = [];\n\t\tfor (let time = first; time <= end; time += WEEK) {\n\t\t\tticks.push(time);\n\t\t}\n\t\treturn ticks;\n\t}\n\tconst size = UNIT_MS[unit] * step;\n\tconst ticks: number[] = [];\n\tfor (let time = Math.ceil(start / size) * size; time <= end; time += size) {\n\t\tticks.push(time);\n\t}\n\treturn ticks;\n}\n\nfunction tickLabel(time: number, unit: Unit, locale: string): string {\n\tconst date = new Date(time);\n\tif (unit === \"year\") {\n\t\treturn dateFormat(locale, { year: \"numeric\" }).format(date);\n\t}\n\tif (unit === \"month\") {\n\t\t// The year only where it turns, so a row of months stays short.\n\t\treturn date.getUTCMonth() === 0\n\t\t\t? dateFormat(locale, { month: \"short\", year: \"numeric\" }).format(date)\n\t\t\t: dateFormat(locale, { month: \"short\" }).format(date);\n\t}\n\tif (unit === \"day\" || unit === \"week\") {\n\t\treturn dateFormat(locale, { day: \"numeric\", month: \"short\" }).format(date);\n\t}\n\tif (unit === \"second\") {\n\t\treturn dateFormat(locale, {\n\t\t\thour: \"2-digit\",\n\t\t\tminute: \"2-digit\",\n\t\t\tsecond: \"2-digit\",\n\t\t}).format(date);\n\t}\n\treturn dateFormat(locale, { hour: \"2-digit\", minute: \"2-digit\" }).format(\n\t\tdate,\n\t);\n}\n\nexport function timeScale(options: ContinuousScaleOptions): ChartPositionScale {\n\tconst { domain, locale, tickCount } = options;\n\tconst linear = linearScale(options);\n\tconst [start, end] = [Math.min(...domain), Math.max(...domain)];\n\tlet unit = chooseInterval(end - start, tickCount).unit;\n\n\treturn {\n\t\t...linear,\n\t\tkind: \"time\",\n\t\tdomain: [new Date(domain[0]), new Date(domain[1])],\n\t\tinvert: (pixel) => new Date(toNumber(linear.invert(pixel))),\n\t\tticks: (count = tickCount) => {\n\t\t\tconst interval = chooseInterval(end - start, count);\n\t\t\tunit = interval.unit;\n\t\t\treturn intervalTicks(start, end, interval).map((time) => new Date(time));\n\t\t},\n\t\tformat: (value: ChartValue) => tickLabel(toNumber(value), unit, locale),\n\t};\n}\n"],
+  "mappings": "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",
+  "names": ["ticks"]
+}

package/dist/core/text.d.ts

@@ -0,0 +1,3 @@
+import type { ChartTextMeasurer } from "./types.js";
+export declare const estimateTextWidth: ChartTextMeasurer;
+//# sourceMappingURL=text.d.ts.map

package/dist/core/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/core/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AA+BzD,eAAO,MAAM,iBAAiB,EAAE,iBAU/B,CAAC"}

package/dist/core/text.js

@@ -0,0 +1,29 @@
+const NARROW = /[ijlt.,:;'!|()[\]\s]/;
+const WIDE = /[mwMW@%]/;
+const DIGIT = /[0-9]/;
+const UPPER = /[A-Z]/;
+const EM_NARROW = 0.3;
+const EM_WIDE = 0.85;
+const EM_DIGIT = 0.58;
+const EM_UPPER = 0.66;
+const EM_OTHER = 0.54;
+const BOLD_FACTOR = 1.06;
+const BOLD_WEIGHT = 600;
+function emWidth(character) {
+  if (NARROW.test(character)) return EM_NARROW;
+  if (WIDE.test(character)) return EM_WIDE;
+  if (DIGIT.test(character)) return EM_DIGIT;
+  if (UPPER.test(character)) return EM_UPPER;
+  return EM_OTHER;
+}
+const estimateTextWidth = (text, fontSize, fontWeight = 400) => {
+  let ems = 0;
+  for (const character of text) {
+    ems += emWidth(character);
+  }
+  return ems * fontSize * (fontWeight >= BOLD_WEIGHT ? BOLD_FACTOR : 1);
+};
+export {
+  estimateTextWidth
+};
+//# sourceMappingURL=text.js.map

package/dist/core/text.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/text.ts"],
+  "sourcesContent": ["import type { ChartTextMeasurer } from \"#/core/types.ts\";\n\n/**\n * Text width without a browser. The server and the first client render both\n * lay out with this estimate, so the hydrated markup matches; the browser\n * swaps in real metrics right after.\n *\n * Widths are in ems for a typical UI sans-serif: narrow letters, wide\n * letters, digits (tabular in most UI fonts) and everything else.\n */\nconst NARROW = /[ijlt.,:;'!|()[\\]\\s]/;\nconst WIDE = /[mwMW@%]/;\nconst DIGIT = /[0-9]/;\nconst UPPER = /[A-Z]/;\n\nconst EM_NARROW = 0.3;\nconst EM_WIDE = 0.85;\nconst EM_DIGIT = 0.58;\nconst EM_UPPER = 0.66;\nconst EM_OTHER = 0.54;\nconst BOLD_FACTOR = 1.06;\nconst BOLD_WEIGHT = 600;\n\nfunction emWidth(character: string): number {\n\tif (NARROW.test(character)) return EM_NARROW;\n\tif (WIDE.test(character)) return EM_WIDE;\n\tif (DIGIT.test(character)) return EM_DIGIT;\n\tif (UPPER.test(character)) return EM_UPPER;\n\treturn EM_OTHER;\n}\n\nexport const estimateTextWidth: ChartTextMeasurer = (\n\ttext,\n\tfontSize,\n\tfontWeight = 400,\n) => {\n\tlet ems = 0;\n\tfor (const character of text) {\n\t\tems += emWidth(character);\n\t}\n\treturn ems * fontSize * (fontWeight >= BOLD_WEIGHT ? BOLD_FACTOR : 1);\n};\n"],
+  "mappings": "AAUA,MAAM,SAAS;AACf,MAAM,OAAO;AACb,MAAM,QAAQ;AACd,MAAM,QAAQ;AAEd,MAAM,YAAY;AAClB,MAAM,UAAU;AAChB,MAAM,WAAW;AACjB,MAAM,WAAW;AACjB,MAAM,WAAW;AACjB,MAAM,cAAc;AACpB,MAAM,cAAc;AAEpB,SAAS,QAAQ,WAA2B;AAC3C,MAAI,OAAO,KAAK,SAAS,EAAG,QAAO;AACnC,MAAI,KAAK,KAAK,SAAS,EAAG,QAAO;AACjC,MAAI,MAAM,KAAK,SAAS,EAAG,QAAO;AAClC,MAAI,MAAM,KAAK,SAAS,EAAG,QAAO;AAClC,SAAO;AACR;AAEO,MAAM,oBAAuC,CACnD,MACA,UACA,aAAa,QACT;AACJ,MAAI,MAAM;AACV,aAAW,aAAa,MAAM;AAC7B,WAAO,QAAQ,SAAS;AAAA,EACzB;AACA,SAAO,MAAM,YAAY,cAAc,cAAc,cAAc;AACpE;",
+  "names": []
+}

package/dist/core/theme.d.ts

@@ -0,0 +1,8 @@
+import type { ChartTheme } from "./types.js";
+/**
+ * Every colour is a CSS variable with a fallback, so a chart picks up the
+ * kit's tokens (`--chart-1`…, `--muted-foreground`, `--border`) when the page
+ * has them and still draws legibly when it does not.
+ */
+export declare const DEFAULT_THEME: ChartTheme;
+//# sourceMappingURL=theme.d.ts.map

package/dist/core/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/core/theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAWlD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,UAS3B,CAAC"}

package/dist/core/theme.js

@@ -0,0 +1,21 @@
+const FALLBACK_PALETTE = [
+  "oklch(0.646 0.222 41.116)",
+  "oklch(0.6 0.118 184.704)",
+  "oklch(0.398 0.07 227.392)",
+  "oklch(0.828 0.189 84.429)",
+  "oklch(0.769 0.188 70.08)"
+];
+const DEFAULT_THEME = {
+  palette: FALLBACK_PALETTE.map(
+    (fallback, index) => `var(--chart-${index + 1}, ${fallback})`
+  ),
+  foreground: "var(--foreground, currentColor)",
+  muted: "var(--muted-foreground, currentColor)",
+  grid: "var(--border, color-mix(in oklab, currentColor 15%, transparent))",
+  background: "var(--background, Canvas)",
+  fontSize: 12
+};
+export {
+  DEFAULT_THEME
+};
+//# sourceMappingURL=theme.js.map

package/dist/core/theme.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/theme.ts"],
+  "sourcesContent": ["import type { ChartTheme } from \"#/core/types.ts\";\n\n/** What the palette falls back to on a page without the kit's `--chart-N` tokens. */\nconst FALLBACK_PALETTE = [\n\t\"oklch(0.646 0.222 41.116)\",\n\t\"oklch(0.6 0.118 184.704)\",\n\t\"oklch(0.398 0.07 227.392)\",\n\t\"oklch(0.828 0.189 84.429)\",\n\t\"oklch(0.769 0.188 70.08)\",\n];\n\n/**\n * Every colour is a CSS variable with a fallback, so a chart picks up the\n * kit's tokens (`--chart-1`\u2026, `--muted-foreground`, `--border`) when the page\n * has them and still draws legibly when it does not.\n */\nexport const DEFAULT_THEME: ChartTheme = {\n\tpalette: FALLBACK_PALETTE.map(\n\t\t(fallback, index) => `var(--chart-${index + 1}, ${fallback})`,\n\t),\n\tforeground: \"var(--foreground, currentColor)\",\n\tmuted: \"var(--muted-foreground, currentColor)\",\n\tgrid: \"var(--border, color-mix(in oklab, currentColor 15%, transparent))\",\n\tbackground: \"var(--background, Canvas)\",\n\tfontSize: 12,\n};\n"],
+  "mappings": "AAGA,MAAM,mBAAmB;AAAA,EACxB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD;AAOO,MAAM,gBAA4B;AAAA,EACxC,SAAS,iBAAiB;AAAA,IACzB,CAAC,UAAU,UAAU,eAAe,QAAQ,CAAC,KAAK,QAAQ;AAAA,EAC3D;AAAA,EACA,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,UAAU;AACX;",
+  "names": []
+}

package/dist/core/ticks.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Round tick values for a continuous axis. The step is always 1, 2, 5 or 10
+ * times a power of ten, which is what makes an axis readable: 0/25/50/75/100
+ * rather than 0/23.4/46.8.
+ */
+/**
+ * The round step closest to covering `[min, max]` in about `count` intervals.
+ * Returns `0` for a degenerate span, which callers read as "no ticks".
+ */
+export declare function tickStep(min: number, max: number, count?: number): number;
+/**
+ * Round values strictly inside `[min, max]`. An axis that has been through
+ * `niceDomain` first gets ticks on both bounds; a raw domain does not, on
+ * purpose — a tick outside the data would be a lie.
+ */
+export declare function niceTicks(min: number, max: number, count?: number): ReadonlyArray<number>;
+/**
+ * Widens `[min, max]` outwards to the nearest round step, so the axis starts
+ * and ends on a tick instead of mid-air.
+ */
+export declare function niceDomain(min: number, max: number, count?: number): readonly [number, number];
+/**
+ * The `[min, max]` of a set of values, always including zero so bars are
+ * measured from a real baseline rather than from an arbitrary floor.
+ */
+export declare function extentFromZero(values: ReadonlyArray<number>): readonly [number, number];
+//# sourceMappingURL=ticks.d.ts.map

package/dist/core/ticks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../src/core/ticks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH;;;GAGG;AACH,wBAAgB,QAAQ,CACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAA2B,GAChC,MAAM,CAUR;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACxB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAA2B,GAChC,aAAa,CAAC,MAAM,CAAC,CAevB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACzB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAA2B,GAChC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAe3B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAC3B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAW3B"}

package/dist/core/ticks.js

@@ -0,0 +1,76 @@
+const NICE_FACTORS = [
+  { threshold: Math.SQRT2, factor: 1 },
+  { threshold: Math.sqrt(10), factor: 2 },
+  { threshold: Math.sqrt(50), factor: 5 }
+];
+const DEFAULT_TICK_COUNT = 5;
+const MAX_TICK_PRECISION = 12;
+function roundToStep(value, step) {
+  if (step === 0 || !Number.isFinite(step)) {
+    return value;
+  }
+  const decimals = Math.max(0, -Math.floor(Math.log10(Math.abs(step))));
+  return Number(value.toFixed(Math.min(decimals, MAX_TICK_PRECISION)));
+}
+function tickStep(min, max, count = DEFAULT_TICK_COUNT) {
+  const span = max - min;
+  if (!Number.isFinite(span) || span <= 0 || count <= 0) {
+    return 0;
+  }
+  const rough = span / count;
+  const power = Math.floor(Math.log10(rough));
+  const error = rough / 10 ** power;
+  const match = NICE_FACTORS.find((candidate) => error < candidate.threshold);
+  return (match?.factor ?? 10) * 10 ** power;
+}
+function niceTicks(min, max, count = DEFAULT_TICK_COUNT) {
+  if (min === max) {
+    return [min];
+  }
+  const step = tickStep(min, max, count);
+  if (step === 0) {
+    return [];
+  }
+  const first = Math.ceil(min / step);
+  const last = Math.floor(max / step);
+  const ticks = [];
+  for (let index = first; index <= last; index += 1) {
+    ticks.push(roundToStep(index * step, step));
+  }
+  return ticks;
+}
+function niceDomain(min, max, count = DEFAULT_TICK_COUNT) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    return [0, 1];
+  }
+  if (min === max) {
+    return min === 0 ? [0, 1] : [Math.min(0, min), Math.max(0, max)];
+  }
+  const step = tickStep(min, max, count);
+  if (step === 0) {
+    return [min, max];
+  }
+  return [
+    roundToStep(Math.floor(min / step) * step, step),
+    roundToStep(Math.ceil(max / step) * step, step)
+  ];
+}
+function extentFromZero(values) {
+  let min = 0;
+  let max = 0;
+  for (const value of values) {
+    if (!Number.isFinite(value)) {
+      continue;
+    }
+    min = Math.min(min, value);
+    max = Math.max(max, value);
+  }
+  return [min, max];
+}
+export {
+  extentFromZero,
+  niceDomain,
+  niceTicks,
+  tickStep
+};
+//# sourceMappingURL=ticks.js.map

package/dist/core/ticks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/ticks.ts"],
+  "sourcesContent": ["/**\n * Round tick values for a continuous axis. The step is always 1, 2, 5 or 10\n * times a power of ten, which is what makes an axis readable: 0/25/50/75/100\n * rather than 0/23.4/46.8.\n */\n\n/** Steps the eye reads as round, in units of the current power of ten. */\nconst NICE_FACTORS = [\n\t{ threshold: Math.SQRT2, factor: 1 },\n\t{ threshold: Math.sqrt(10), factor: 2 },\n\t{ threshold: Math.sqrt(50), factor: 5 },\n] as const;\n\nconst DEFAULT_TICK_COUNT = 5;\n/** Beyond this many decimals the rounding helper stops fighting IEEE noise. */\nconst MAX_TICK_PRECISION = 12;\n\n/**\n * Drops the floating-point dust `i * step` leaves behind (0.30000000000000004)\n * by rounding to the number of decimals the step itself carries.\n */\nfunction roundToStep(value: number, step: number): number {\n\tif (step === 0 || !Number.isFinite(step)) {\n\t\treturn value;\n\t}\n\tconst decimals = Math.max(0, -Math.floor(Math.log10(Math.abs(step))));\n\treturn Number(value.toFixed(Math.min(decimals, MAX_TICK_PRECISION)));\n}\n\n/**\n * The round step closest to covering `[min, max]` in about `count` intervals.\n * Returns `0` for a degenerate span, which callers read as \"no ticks\".\n */\nexport function tickStep(\n\tmin: number,\n\tmax: number,\n\tcount: number = DEFAULT_TICK_COUNT,\n): number {\n\tconst span = max - min;\n\tif (!Number.isFinite(span) || span <= 0 || count <= 0) {\n\t\treturn 0;\n\t}\n\tconst rough = span / count;\n\tconst power = Math.floor(Math.log10(rough));\n\tconst error = rough / 10 ** power;\n\tconst match = NICE_FACTORS.find((candidate) => error < candidate.threshold);\n\treturn (match?.factor ?? 10) * 10 ** power;\n}\n\n/**\n * Round values strictly inside `[min, max]`. An axis that has been through\n * `niceDomain` first gets ticks on both bounds; a raw domain does not, on\n * purpose \u2014 a tick outside the data would be a lie.\n */\nexport function niceTicks(\n\tmin: number,\n\tmax: number,\n\tcount: number = DEFAULT_TICK_COUNT,\n): ReadonlyArray<number> {\n\tif (min === max) {\n\t\treturn [min];\n\t}\n\tconst step = tickStep(min, max, count);\n\tif (step === 0) {\n\t\treturn [];\n\t}\n\tconst first = Math.ceil(min / step);\n\tconst last = Math.floor(max / step);\n\tconst ticks: number[] = [];\n\tfor (let index = first; index <= last; index += 1) {\n\t\tticks.push(roundToStep(index * step, step));\n\t}\n\treturn ticks;\n}\n\n/**\n * Widens `[min, max]` outwards to the nearest round step, so the axis starts\n * and ends on a tick instead of mid-air.\n */\nexport function niceDomain(\n\tmin: number,\n\tmax: number,\n\tcount: number = DEFAULT_TICK_COUNT,\n): readonly [number, number] {\n\tif (!Number.isFinite(min) || !Number.isFinite(max)) {\n\t\treturn [0, 1];\n\t}\n\tif (min === max) {\n\t\treturn min === 0 ? [0, 1] : [Math.min(0, min), Math.max(0, max)];\n\t}\n\tconst step = tickStep(min, max, count);\n\tif (step === 0) {\n\t\treturn [min, max];\n\t}\n\treturn [\n\t\troundToStep(Math.floor(min / step) * step, step),\n\t\troundToStep(Math.ceil(max / step) * step, step),\n\t];\n}\n\n/**\n * The `[min, max]` of a set of values, always including zero so bars are\n * measured from a real baseline rather than from an arbitrary floor.\n */\nexport function extentFromZero(\n\tvalues: ReadonlyArray<number>,\n): readonly [number, number] {\n\tlet min = 0;\n\tlet max = 0;\n\tfor (const value of values) {\n\t\tif (!Number.isFinite(value)) {\n\t\t\tcontinue;\n\t\t}\n\t\tmin = Math.min(min, value);\n\t\tmax = Math.max(max, value);\n\t}\n\treturn [min, max];\n}\n"],
+  "mappings": "AAOA,MAAM,eAAe;AAAA,EACpB,EAAE,WAAW,KAAK,OAAO,QAAQ,EAAE;AAAA,EACnC,EAAE,WAAW,KAAK,KAAK,EAAE,GAAG,QAAQ,EAAE;AAAA,EACtC,EAAE,WAAW,KAAK,KAAK,EAAE,GAAG,QAAQ,EAAE;AACvC;AAEA,MAAM,qBAAqB;AAE3B,MAAM,qBAAqB;AAM3B,SAAS,YAAY,OAAe,MAAsB;AACzD,MAAI,SAAS,KAAK,CAAC,OAAO,SAAS,IAAI,GAAG;AACzC,WAAO;AAAA,EACR;AACA,QAAM,WAAW,KAAK,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC;AACpE,SAAO,OAAO,MAAM,QAAQ,KAAK,IAAI,UAAU,kBAAkB,CAAC,CAAC;AACpE;AAMO,SAAS,SACf,KACA,KACA,QAAgB,oBACP;AACT,QAAM,OAAO,MAAM;AACnB,MAAI,CAAC,OAAO,SAAS,IAAI,KAAK,QAAQ,KAAK,SAAS,GAAG;AACtD,WAAO;AAAA,EACR;AACA,QAAM,QAAQ,OAAO;AACrB,QAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,KAAK,CAAC;AAC1C,QAAM,QAAQ,QAAQ,MAAM;AAC5B,QAAM,QAAQ,aAAa,KAAK,CAAC,cAAc,QAAQ,UAAU,SAAS;AAC1E,UAAQ,OAAO,UAAU,MAAM,MAAM;AACtC;AAOO,SAAS,UACf,KACA,KACA,QAAgB,oBACQ;AACxB,MAAI,QAAQ,KAAK;AAChB,WAAO,CAAC,GAAG;AAAA,EACZ;AACA,QAAM,OAAO,SAAS,KAAK,KAAK,KAAK;AACrC,MAAI,SAAS,GAAG;AACf,WAAO,CAAC;AAAA,EACT;AACA,QAAM,QAAQ,KAAK,KAAK,MAAM,IAAI;AAClC,QAAM,OAAO,KAAK,MAAM,MAAM,IAAI;AAClC,QAAM,QAAkB,CAAC;AACzB,WAAS,QAAQ,OAAO,SAAS,MAAM,SAAS,GAAG;AAClD,UAAM,KAAK,YAAY,QAAQ,MAAM,IAAI,CAAC;AAAA,EAC3C;AACA,SAAO;AACR;AAMO,SAAS,WACf,KACA,KACA,QAAgB,oBACY;AAC5B,MAAI,CAAC,OAAO,SAAS,GAAG,KAAK,CAAC,OAAO,SAAS,GAAG,GAAG;AACnD,WAAO,CAAC,GAAG,CAAC;AAAA,EACb;AACA,MAAI,QAAQ,KAAK;AAChB,WAAO,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG,GAAG,KAAK,IAAI,GAAG,GAAG,CAAC;AAAA,EAChE;AACA,QAAM,OAAO,SAAS,KAAK,KAAK,KAAK;AACrC,MAAI,SAAS,GAAG;AACf,WAAO,CAAC,KAAK,GAAG;AAAA,EACjB;AACA,SAAO;AAAA,IACN,YAAY,KAAK,MAAM,MAAM,IAAI,IAAI,MAAM,IAAI;AAAA,IAC/C,YAAY,KAAK,KAAK,MAAM,IAAI,IAAI,MAAM,IAAI;AAAA,EAC/C;AACD;AAMO,SAAS,eACf,QAC4B;AAC5B,MAAI,MAAM;AACV,MAAI,MAAM;AACV,aAAW,SAAS,QAAQ;AAC3B,QAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC5B;AAAA,IACD;AACA,UAAM,KAAK,IAAI,KAAK,KAAK;AACzB,UAAM,KAAK,IAAI,KAAK,KAAK;AAAA,EAC1B;AACA,SAAO,CAAC,KAAK,GAAG;AACjB;",
+  "names": []
+}