@pibbl/core 0.0.1 → 0.0.2

package/dist/features/viz/lib/linear-scale-component.d.ts

@@ -0,0 +1,7 @@
+import type { LinearScaleProps } from "./types.js";
+/**
+ * Provides a named linear mapping to descendant visualization components.
+ * @param props - Identity, domain, range, and children. See {@link LinearScaleProps}.
+ * @returns Descendant content within the scale scope.
+ */
+export declare function LinearScale(props: LinearScaleProps): import("@pibbl/core").PibblNode;

package/dist/features/viz/lib/linear-scale-component.js

@@ -0,0 +1,18 @@
+import { resolveSignalValue, useLayoutBox } from "@pibbl/core";
+import { resolveLinearScale } from "./linear-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+function LinearScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(props.id, "linear", () => resolveLinearScale(
+    resolveSignalValue(props.domain),
+    resolveSignalValue(props.range),
+    resolveSignalValue(props.reverse ?? false),
+    width,
+    height
+  ), [props.domain, props.range, props.reverse, width, height]);
+  return props.children;
+}
+export {
+  LinearScale
+};
+//# sourceMappingURL=linear-scale-component.js.map

package/dist/features/viz/lib/linear-scale-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/linear-scale-component.ts"],
+  "sourcesContent": ["import { resolveSignalValue, useLayoutBox } from \"@pibbl/core\";\nimport type { LinearScaleProps } from \"./types.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\n/**\n * Provides a named linear mapping to descendant visualization components.\n * @param props - Identity, domain, range, and children. See {@link LinearScaleProps}.\n * @returns Descendant content within the scale scope.\n */\nexport function LinearScale(props: LinearScaleProps) {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(props.id, \"linear\", () => resolveLinearScale(\n    resolveSignalValue(props.domain), resolveSignalValue(props.range),\n    resolveSignalValue(props.reverse ?? false), width, height,\n  ), [props.domain, props.range, props.reverse, width, height]);\n  return props.children;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB,oBAAoB;AAEjD,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AAM1B,SAAS,YAAY,OAAyB;AACnD,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC,mBAAiB,MAAM,IAAI,UAAU,MAAM;AAAA,IACzC,mBAAmB,MAAM,MAAM;AAAA,IAAG,mBAAmB,MAAM,KAAK;AAAA,IAChE,mBAAmB,MAAM,WAAW,KAAK;AAAA,IAAG;AAAA,IAAO;AAAA,EACrD,GAAG,CAAC,MAAM,QAAQ,MAAM,OAAO,MAAM,SAAS,OAAO,MAAM,CAAC;AAC5D,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/features/viz/lib/linear-scale.js

@@ -61,7 +61,7 @@ function resolveLinearScale(domainInput, rangeInput, reverse, width, height) {
   });
 }
 function equalScale(a, b) {
-  return a.type === b.type && a.domain.length === b.domain.length && a.domain.every((value, index) => Object.is(value, b.domain[index])) && (a.type !== "band" || b.type === "band" && a.bandwidth === b.bandwidth && a.step === b.step) && Object.is(a.range[0], b.range[0]) && Object.is(a.range[1], b.range[1]) && Object.is(a.frame.width, b.frame.width) && Object.is(a.frame.height, b.frame.height);
+  return a.type === b.type && (a.type !== "symlog" || b.type === "symlog" && a.constant === b.constant) && (a.type !== "point" || b.type === "point" && a.padding === b.padding) && (a.type !== "log" || b.type === "log" && a.base === b.base) && a.domain.length === b.domain.length && a.domain.every((value, index) => Object.is(value, b.domain[index])) && (a.type !== "band" || b.type === "band" && a.bandwidth === b.bandwidth && a.step === b.step) && Object.is(a.range[0], b.range[0]) && Object.is(a.range[1], b.range[1]) && Object.is(a.frame.width, b.frame.width) && Object.is(a.frame.height, b.frame.height);
 }
 export {
   equalScale,

package/dist/features/viz/lib/linear-scale.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/features/viz/lib/linear-scale.ts"],
-  "sourcesContent": ["import type {\n  LinearDomain,\n  ResolvedLinearScale,\n  ResolvedScale,\n  ScaleRange,\n} from \"./types.js\";\nfunction finite(value: number, field: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(`Scale ${field} must be finite.`);\n  return value;\n}\nfunction pair(\n  value: readonly number[],\n  field: string,\n): readonly [number, number] {\n  if (!Array.isArray(value) || value.length !== 2)\n    throw new RangeError(`Scale ${field} requires two finite endpoints.`);\n  return Object.freeze([finite(value[0], field), finite(value[1], field)]);\n}\nexport function resolveLinearScale(\n  domainInput: LinearDomain,\n  rangeInput: ScaleRange,\n  reverse: boolean,\n  width: number,\n  height: number,\n): ResolvedLinearScale {\n  finite(width, \"frame.width\");\n  finite(height, \"frame.height\");\n  if (width < 0 || height < 0)\n    throw new RangeError(\"Scale allocation must be nonnegative.\");\n  if (typeof reverse !== \"boolean\")\n    throw new TypeError(\"Scale reverse must be boolean.\");\n  const domain = pair(domainInput, \"domain\");\n  if (domain[0] === domain[1])\n    throw new RangeError(\"Scale domain endpoints must differ.\");\n  const original = pair(\n    rangeInput === \"width\"\n      ? [0, width]\n      : rangeInput === \"height\"\n        ? [0, height]\n        : (rangeInput as readonly number[]),\n    \"range\",\n  );\n  const range = reverse ? pair([original[1], original[0]], \"range\") : original;\n  const domainSpan = finite(domain[1] - domain[0], \"domain span\");\n  const rangeSpan = finite(range[1] - range[0], \"range span\");\n  return Object.freeze({\n    type: \"linear\",\n    domain,\n    range,\n    frame: Object.freeze({ x: 0, y: 0, width, height }),\n    map(value: number) {\n      return finite(\n        range[0] +\n          ((finite(value, \"map input\") - domain[0]) / domainSpan) * rangeSpan,\n        \"mapped output\",\n      );\n    },\n    invert(pixel: number) {\n      if (rangeSpan === 0)\n        throw new RangeError(\n          \"Scale cannot invert a collapsed range; supply a nonzero extent.\",\n        );\n      return finite(\n        domain[0] +\n          ((finite(pixel, \"invert input\") - range[0]) / rangeSpan) * domainSpan,\n        \"inverted output\",\n      );\n    },\n    ticks(count = 5) {\n      if (!Number.isInteger(count) || count < 2 || count > 100)\n        throw new RangeError(\n          \"Scale ticks count must be an integer from 2 to 100.\",\n        );\n      return Object.freeze(\n        Array.from({ length: count }, (_, i) =>\n          i === count - 1\n            ? domain[1]\n            : finite(domain[0] + (domainSpan * i) / (count - 1), \"tick\"),\n        ),\n      );\n    },\n  });\n}\nexport function equalScale(a: ResolvedScale, b: ResolvedScale): boolean {\n  return (\n    a.type === b.type &&\n    a.domain.length === b.domain.length &&\n    a.domain.every((value, index) => Object.is(value, b.domain[index])) &&\n    (a.type !== \"band\" ||\n      (b.type === \"band\" &&\n        a.bandwidth === b.bandwidth &&\n        a.step === b.step)) &&\n    Object.is(a.range[0], b.range[0]) &&\n    Object.is(a.range[1], b.range[1]) &&\n    Object.is(a.frame.width, b.frame.width) &&\n    Object.is(a.frame.height, b.frame.height)\n  );\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type {\n  LinearDomain,\n  ResolvedLinearScale,\n  ResolvedScale,\n  ScaleRange,\n} from \"./types.js\";\nfunction finite(value: number, field: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(`Scale ${field} must be finite.`);\n  return value;\n}\nfunction pair(\n  value: readonly number[],\n  field: string,\n): readonly [number, number] {\n  if (!Array.isArray(value) || value.length !== 2)\n    throw new RangeError(`Scale ${field} requires two finite endpoints.`);\n  return Object.freeze([finite(value[0], field), finite(value[1], field)]);\n}\nexport function resolveLinearScale(\n  domainInput: LinearDomain,\n  rangeInput: ScaleRange,\n  reverse: boolean,\n  width: number,\n  height: number,\n): ResolvedLinearScale {\n  finite(width, \"frame.width\");\n  finite(height, \"frame.height\");\n  if (width < 0 || height < 0)\n    throw new RangeError(\"Scale allocation must be nonnegative.\");\n  if (typeof reverse !== \"boolean\")\n    throw new TypeError(\"Scale reverse must be boolean.\");\n  const domain = pair(domainInput, \"domain\");\n  if (domain[0] === domain[1])\n    throw new RangeError(\"Scale domain endpoints must differ.\");\n  const original = pair(\n    rangeInput === \"width\"\n      ? [0, width]\n      : rangeInput === \"height\"\n        ? [0, height]\n        : (rangeInput as readonly number[]),\n    \"range\",\n  );\n  const range = reverse ? pair([original[1], original[0]], \"range\") : original;\n  const domainSpan = finite(domain[1] - domain[0], \"domain span\");\n  const rangeSpan = finite(range[1] - range[0], \"range span\");\n  return Object.freeze({\n    type: \"linear\",\n    domain,\n    range,\n    frame: Object.freeze({ x: 0, y: 0, width, height }),\n    map(value: number) {\n      return finite(\n        range[0] +\n          ((finite(value, \"map input\") - domain[0]) / domainSpan) * rangeSpan,\n        \"mapped output\",\n      );\n    },\n    invert(pixel: number) {\n      if (rangeSpan === 0)\n        throw new RangeError(\n          \"Scale cannot invert a collapsed range; supply a nonzero extent.\",\n        );\n      return finite(\n        domain[0] +\n          ((finite(pixel, \"invert input\") - range[0]) / rangeSpan) * domainSpan,\n        \"inverted output\",\n      );\n    },\n    ticks(count = 5) {\n      if (!Number.isInteger(count) || count < 2 || count > 100)\n        throw new RangeError(\n          \"Scale ticks count must be an integer from 2 to 100.\",\n        );\n      return Object.freeze(\n        Array.from({ length: count }, (_, i) =>\n          i === count - 1\n            ? domain[1]\n            : finite(domain[0] + (domainSpan * i) / (count - 1), \"tick\"),\n        ),\n      );\n    },\n  });\n}\nexport function equalScale(a: ResolvedScale, b: ResolvedScale): boolean {\n  return (\n    a.type === b.type &&\n    (a.type !== \"symlog\" || (b.type === \"symlog\" && a.constant === b.constant)) &&\n    (a.type !== \"point\" || (b.type === \"point\" && a.padding === b.padding)) &&\n    (a.type !== \"log\" || (b.type === \"log\" && a.base === b.base)) &&\n    a.domain.length === b.domain.length &&\n    a.domain.every((value, index) => Object.is(value, b.domain[index])) &&\n    (a.type !== \"band\" ||\n      (b.type === \"band\" &&\n        a.bandwidth === b.bandwidth &&\n        a.step === b.step)) &&\n    Object.is(a.range[0], b.range[0]) &&\n    Object.is(a.range[1], b.range[1]) &&\n    Object.is(a.frame.width, b.frame.width) &&\n    Object.is(a.frame.height, b.frame.height)\n  );\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/features/viz/lib/log-scale-component.d.ts

@@ -0,0 +1,7 @@
+import type { LogScaleProps } from "./types.js";
+/**
+ * Provides a named positive logarithmic mapping to descendant marks and axes.
+ * @param props - Identity, positive domain, range, and optional tick base. See {@link LogScaleProps}.
+ * @returns Descendant content within the logarithmic scale scope.
+ */
+export declare function LogScale(props: LogScaleProps): import("@pibbl/core").PibblNode;

package/dist/features/viz/lib/log-scale-component.js

@@ -0,0 +1,19 @@
+import { resolveSignalValue, useLayoutBox } from "@pibbl/core";
+import { resolveLogScale } from "./log-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+function LogScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(props.id, "log", () => resolveLogScale(
+    resolveSignalValue(props.domain),
+    resolveSignalValue(props.range),
+    resolveSignalValue(props.reverse ?? false),
+    width,
+    height,
+    resolveSignalValue(props.base ?? 10)
+  ), [props.domain, props.range, props.reverse, props.base, width, height]);
+  return props.children;
+}
+export {
+  LogScale
+};
+//# sourceMappingURL=log-scale-component.js.map

package/dist/features/viz/lib/log-scale-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/log-scale-component.ts"],
+  "sourcesContent": ["import { resolveSignalValue, useLayoutBox } from \"@pibbl/core\";\nimport type { LogScaleProps } from \"./types.js\";\nimport { resolveLogScale } from \"./log-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\n/**\n * Provides a named positive logarithmic mapping to descendant marks and axes.\n * @param props - Identity, positive domain, range, and optional tick base. See {@link LogScaleProps}.\n * @returns Descendant content within the logarithmic scale scope.\n */\nexport function LogScale(props: LogScaleProps) {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(props.id, \"log\", () => resolveLogScale(\n    resolveSignalValue(props.domain), resolveSignalValue(props.range),\n    resolveSignalValue(props.reverse ?? false), width, height, resolveSignalValue(props.base ?? 10),\n  ), [props.domain, props.range, props.reverse, props.base, width, height]);\n  return props.children;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB,oBAAoB;AAEjD,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AAM1B,SAAS,SAAS,OAAsB;AAC7C,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC,mBAAiB,MAAM,IAAI,OAAO,MAAM;AAAA,IACtC,mBAAmB,MAAM,MAAM;AAAA,IAAG,mBAAmB,MAAM,KAAK;AAAA,IAChE,mBAAmB,MAAM,WAAW,KAAK;AAAA,IAAG;AAAA,IAAO;AAAA,IAAQ,mBAAmB,MAAM,QAAQ,EAAE;AAAA,EAChG,GAAG,CAAC,MAAM,QAAQ,MAAM,OAAO,MAAM,SAAS,MAAM,MAAM,OAAO,MAAM,CAAC;AACxE,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/features/viz/lib/log-scale.d.ts

@@ -0,0 +1,2 @@
+import type { LinearDomain, ResolvedLogScale, ScaleRange } from "./types.js";
+export declare function resolveLogScale(domainInput: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, base: number): ResolvedLogScale;

package/dist/features/viz/lib/log-scale.js

@@ -0,0 +1,53 @@
+import { resolveLinearScale } from "./linear-scale.js";
+function positive(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    throw new RangeError(`LogScale ${field} must be finite and positive.`);
+  return value;
+}
+function resolveLogScale(domainInput, range, reverse, width, height, base) {
+  if (typeof base !== "number" || !Number.isFinite(base) || base <= 1)
+    throw new RangeError("LogScale base must be finite and greater than one.");
+  if (!Array.isArray(domainInput) || domainInput.length !== 2)
+    throw new RangeError("LogScale domain requires two positive endpoints.");
+  const domain = Object.freeze([positive(domainInput[0], "domain"), positive(domainInput[1], "domain")]);
+  const logarithm = (value) => Math.log(positive(value, "map input"));
+  const mapping = resolveLinearScale([logarithm(domain[0]), logarithm(domain[1])], range, reverse, width, height);
+  return Object.freeze({
+    ...mapping,
+    type: "log",
+    domain,
+    base,
+    map(value) {
+      return mapping.map(logarithm(value));
+    },
+    invert(pixel) {
+      if (pixel === mapping.range[0] && mapping.range[0] !== mapping.range[1]) return domain[0];
+      if (pixel === mapping.range[1] && mapping.range[0] !== mapping.range[1]) return domain[1];
+      return positive(Math.exp(mapping.invert(pixel)), "inverted output");
+    },
+    ticks(count = 5) {
+      if (!Number.isInteger(count) || count < 2 || count > 100)
+        throw new RangeError("LogScale ticks count must be an integer from 2 to 100.");
+      if (count === 2) return Object.freeze([...domain]);
+      const lo = Math.min(...domain), hi = Math.max(...domain);
+      const first = Math.floor(Math.log(lo) / Math.log(base)) + 1;
+      const last = Math.ceil(Math.log(hi) / Math.log(base)) - 1;
+      if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last))
+        throw new RangeError("LogScale tick exponents exceed numeric precision; choose a larger base.");
+      const stride = Math.max(1, Math.ceil((last - first + 1) / (count - 2)));
+      const ticks = [lo];
+      for (let i = 0; i < count - 2; i++) {
+        const exponent = first + i * stride;
+        if (exponent > last) break;
+        const value = base ** exponent;
+        if (Number.isFinite(value) && value > ticks[ticks.length - 1] && value < hi) ticks.push(value);
+      }
+      ticks.push(hi);
+      return Object.freeze(domain[0] > domain[1] ? ticks.reverse() : ticks);
+    }
+  });
+}
+export {
+  resolveLogScale
+};
+//# sourceMappingURL=log-scale.js.map

package/dist/features/viz/lib/log-scale.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/log-scale.ts"],
+  "sourcesContent": ["import type { LinearDomain, ResolvedLogScale, ScaleRange } from \"./types.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nfunction positive(value: number, field: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value <= 0)\n    throw new RangeError(`LogScale ${field} must be finite and positive.`);\n  return value;\n}\nexport function resolveLogScale(domainInput: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, base: number): ResolvedLogScale {\n  if (typeof base !== \"number\" || !Number.isFinite(base) || base <= 1)\n    throw new RangeError(\"LogScale base must be finite and greater than one.\");\n  if (!Array.isArray(domainInput) || domainInput.length !== 2)\n    throw new RangeError(\"LogScale domain requires two positive endpoints.\");\n  const domain = Object.freeze([positive(domainInput[0], \"domain\"), positive(domainInput[1], \"domain\")] as const);\n  const logarithm = (value: number) => Math.log(positive(value, \"map input\"));\n  const mapping = resolveLinearScale([logarithm(domain[0]), logarithm(domain[1])], range, reverse, width, height);\n  return Object.freeze({\n    ...mapping, type: \"log\", domain, base,\n    map(value: number) { return mapping.map(logarithm(value)); },\n    invert(pixel: number) {\n      if (pixel === mapping.range[0] && mapping.range[0] !== mapping.range[1]) return domain[0];\n      if (pixel === mapping.range[1] && mapping.range[0] !== mapping.range[1]) return domain[1];\n      return positive(Math.exp(mapping.invert(pixel)), \"inverted output\");\n    },\n    ticks(count = 5) {\n      if (!Number.isInteger(count) || count < 2 || count > 100)\n        throw new RangeError(\"LogScale ticks count must be an integer from 2 to 100.\");\n      if (count === 2) return Object.freeze([...domain]);\n      const lo = Math.min(...domain), hi = Math.max(...domain);\n      const first = Math.floor(Math.log(lo) / Math.log(base)) + 1;\n      const last = Math.ceil(Math.log(hi) / Math.log(base)) - 1;\n      if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last))\n        throw new RangeError(\"LogScale tick exponents exceed numeric precision; choose a larger base.\");\n      const stride = Math.max(1, Math.ceil((last - first + 1) / (count - 2)));\n      const ticks: number[] = [lo];\n      for (let i = 0; i < count - 2; i++) {\n        const exponent = first + i * stride;\n        if (exponent > last) break;\n        const value = base ** exponent;\n        if (Number.isFinite(value) && value > ticks[ticks.length - 1] && value < hi) ticks.push(value);\n      }\n      ticks.push(hi);\n      return Object.freeze(domain[0] > domain[1] ? ticks.reverse() : ticks);\n    },\n  });\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AACnC,SAAS,SAAS,OAAe,OAAuB;AACtD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS;AACnE,UAAM,IAAI,WAAW,YAAY,KAAK,+BAA+B;AACvE,SAAO;AACT;AACO,SAAS,gBAAgB,aAA2B,OAAmB,SAAkB,OAAe,QAAgB,MAAgC;AAC7J,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,SAAS,IAAI,KAAK,QAAQ;AAChE,UAAM,IAAI,WAAW,oDAAoD;AAC3E,MAAI,CAAC,MAAM,QAAQ,WAAW,KAAK,YAAY,WAAW;AACxD,UAAM,IAAI,WAAW,kDAAkD;AACzE,QAAM,SAAS,OAAO,OAAO,CAAC,SAAS,YAAY,CAAC,GAAG,QAAQ,GAAG,SAAS,YAAY,CAAC,GAAG,QAAQ,CAAC,CAAU;AAC9G,QAAM,YAAY,CAAC,UAAkB,KAAK,IAAI,SAAS,OAAO,WAAW,CAAC;AAC1E,QAAM,UAAU,mBAAmB,CAAC,UAAU,OAAO,CAAC,CAAC,GAAG,UAAU,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,SAAS,OAAO,MAAM;AAC9G,SAAO,OAAO,OAAO;AAAA,IACnB,GAAG;AAAA,IAAS,MAAM;AAAA,IAAO;AAAA,IAAQ;AAAA,IACjC,IAAI,OAAe;AAAE,aAAO,QAAQ,IAAI,UAAU,KAAK,CAAC;AAAA,IAAG;AAAA,IAC3D,OAAO,OAAe;AACpB,UAAI,UAAU,QAAQ,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,EAAG,QAAO,OAAO,CAAC;AACxF,UAAI,UAAU,QAAQ,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,EAAG,QAAO,OAAO,CAAC;AACxF,aAAO,SAAS,KAAK,IAAI,QAAQ,OAAO,KAAK,CAAC,GAAG,iBAAiB;AAAA,IACpE;AAAA,IACA,MAAM,QAAQ,GAAG;AACf,UAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACnD,cAAM,IAAI,WAAW,wDAAwD;AAC/E,UAAI,UAAU,EAAG,QAAO,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC;AACjD,YAAM,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,GAAG,MAAM;AACvD,YAAM,QAAQ,KAAK,MAAM,KAAK,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI;AAC1D,YAAM,OAAO,KAAK,KAAK,KAAK,IAAI,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI;AACxD,UAAI,CAAC,OAAO,cAAc,KAAK,KAAK,CAAC,OAAO,cAAc,IAAI;AAC5D,cAAM,IAAI,WAAW,yEAAyE;AAChG,YAAM,SAAS,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,QAAQ,MAAM,QAAQ,EAAE,CAAC;AACtE,YAAM,QAAkB,CAAC,EAAE;AAC3B,eAAS,IAAI,GAAG,IAAI,QAAQ,GAAG,KAAK;AAClC,cAAM,WAAW,QAAQ,IAAI;AAC7B,YAAI,WAAW,KAAM;AACrB,cAAM,QAAQ,QAAQ;AACtB,YAAI,OAAO,SAAS,KAAK,KAAK,QAAQ,MAAM,MAAM,SAAS,CAAC,KAAK,QAAQ,GAAI,OAAM,KAAK,KAAK;AAAA,MAC/F;AACA,YAAM,KAAK,EAAE;AACb,aAAO,OAAO,OAAO,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,MAAM,QAAQ,IAAI,KAAK;AAAA,IACtE;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/features/viz/lib/nearest.d.ts

@@ -1,10 +1,10 @@
-import type { ResolvedLinearScale } from "./types.js";
+import type { ResolvedContinuousScale } from "./types.js";
 import type { PointAccessor } from "./point-types.js";
 /**
  * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.
  *
  * @see {@link PointAccessor}
- * @see {@link ResolvedLinearScale}
+ * @see {@link ResolvedContinuousScale}
  * @see {@link nearestPoint}
  */
 export interface NearestPointOptions<D> {
@@ -12,10 +12,10 @@ export interface NearestPointOptions<D> {
     readonly x: PointAccessor<D>;
     /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */
     readonly y: PointAccessor<D>;
-    /** The scale used to map horizontal data coordinates. See {@link ResolvedLinearScale}. */
-    readonly xScale: ResolvedLinearScale;
-    /** The scale used to map vertical data coordinates. See {@link ResolvedLinearScale}. */
-    readonly yScale: ResolvedLinearScale;
+    /** The scale used to map horizontal data coordinates. See {@link ResolvedContinuousScale}. */
+    readonly xScale: ResolvedContinuousScale;
+    /** The scale used to map vertical data coordinates. See {@link ResolvedContinuousScale}. */
+    readonly yScale: ResolvedContinuousScale;
     /**
      * Returns whether a datum contributes drawable or queryable coordinates. See
      * {@link NearestPointOptions}.
@@ -57,12 +57,12 @@ export interface NearestPoint<D> {
  *
  * @param values - Candidate domain values.
  * @param rangeValue - Pointer coordinate in the scale's range.
- * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedLinearScale}.
+ * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedContinuousScale}.
  * @returns The nearest domain value, or undefined when no candidate can be selected.
  *
- * @see {@link ResolvedLinearScale}
+ * @see {@link ResolvedContinuousScale}
  */
-export declare function nearestDomainValue(values: readonly number[], rangeValue: number, scale: ResolvedLinearScale): number | undefined;
+export declare function nearestDomainValue(values: readonly number[], rangeValue: number, scale: ResolvedContinuousScale): number | undefined;
 /**
  * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.
  *

package/dist/features/viz/lib/nearest.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/features/viz/lib/nearest.ts"],
-  "sourcesContent": ["import type { ResolvedLinearScale } from \"./types.js\";\nimport type { PointAccessor } from \"./point-types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\n/**\n * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.\n *\n * @see {@link PointAccessor}\n * @see {@link ResolvedLinearScale}\n * @see {@link nearestPoint}\n */\nexport interface NearestPointOptions<D> {\n  /** Property key or callback extracting the horizontal domain coordinate. See {@link PointAccessor}. */\n  readonly x: PointAccessor<D>;\n  /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */\n  readonly y: PointAccessor<D>;\n  /** The scale used to map horizontal data coordinates. See {@link ResolvedLinearScale}. */\n  readonly xScale: ResolvedLinearScale;\n  /** The scale used to map vertical data coordinates. See {@link ResolvedLinearScale}. */\n  readonly yScale: ResolvedLinearScale;\n  /**\n   * Returns whether a datum contributes drawable or queryable coordinates. See\n   * {@link NearestPointOptions}.\n   * @param datum - Datum to test.\n   * @param index - Zero-based index in the source data.\n   * @param data - Complete source data array.\n   * @returns Whether this datum should participate in the series or query.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Maximum distance accepted by the query. See {@link NearestPointOptions}. */\n  readonly maxDistance?: number;\n}\n/**\n * The selected datum, source index, mapped coordinates, and distance from the query point.\n *\n * @see {@link nearestPoint}\n */\nexport interface NearestPoint<D> {\n  /** The original data item selected by this result. See {@link NearestPoint}. */\n  readonly datum: D;\n  /** Index of the selected datum in its source data. See {@link NearestPoint}. */\n  readonly index: number;\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly y: number;\n  /** Distance measured in this query or guide's coordinate system. See {@link NearestPoint}. */\n  readonly distance: number;\n}\nfunction finite(value: unknown, name: string): asserts value is number {\n  if (!finiteCoordinate(value)) throw new RangeError(`${name} must be finite.`);\n}\n/**\n * Finds the domain value nearest to a logical range coordinate; returns undefined for no\n * candidate.\n *\n * @param values - Candidate domain values.\n * @param rangeValue - Pointer coordinate in the scale's range.\n * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedLinearScale}.\n * @returns The nearest domain value, or undefined when no candidate can be selected.\n *\n * @see {@link ResolvedLinearScale}\n */\nexport function nearestDomainValue(\n  values: readonly number[],\n  rangeValue: number,\n  scale: ResolvedLinearScale,\n): number | undefined {\n  pointData(values, \"nearestDomainValue\");\n  finite(rangeValue, \"nearestDomainValue rangeValue\");\n  let best: number | undefined,\n    distance = Infinity;\n  for (const value of values) {\n    if (!finiteCoordinate(value)) continue;\n    const next = Math.abs(scale.map(value) - rangeValue);\n    finite(next, \"nearestDomainValue distance\");\n    if (next < distance) {\n      best = value;\n      distance = next;\n    }\n  }\n  return best;\n}\n/**\n * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.\n *\n * @param data - Candidate data records.\n * @param point - Query point in plotted range coordinates.\n * @param options - Accessors, scales, eligibility, and distance settings. See\n * {@link NearestPointOptions} .\n * @returns The nearest matching point, or undefined when no candidate qualifies. See\n * {@link NearestPoint} .\n *\n * @see {@link NearestPointOptions}\n * @see {@link NearestPoint}\n */\nexport function nearestPoint<D>(\n  data: readonly D[],\n  point: Readonly<{ x: number; y: number }>,\n  options: NearestPointOptions<D>,\n): NearestPoint<D> | undefined {\n  pointData(data, \"nearestPoint\");\n  finite(point.x, \"nearestPoint x\");\n  finite(point.y, \"nearestPoint y\");\n  const max = options.maxDistance;\n  if (max !== undefined) {\n    finite(max, \"nearestPoint maxDistance\");\n    if (max < 0)\n      throw new RangeError(\"nearestPoint maxDistance must be nonnegative.\");\n  }\n  const x = pointAccessor(options.x),\n    y = pointAccessor(options.y);\n  let best: NearestPoint<D> | undefined,\n    distance = Infinity;\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (options.defined && !options.defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = options.xScale.map(xv),\n      py = options.yScale.map(yv);\n    const next = Math.hypot(px - point.x, py - point.y);\n    finite(next, \"nearestPoint distance\");\n    if (next < distance && (max === undefined || next <= max)) {\n      distance = next;\n      best = { datum, index: i, x: px, y: py, distance: next };\n    }\n  }\n  return best;\n}\n"],
+  "sourcesContent": ["import type { ResolvedContinuousScale } from \"./types.js\";\nimport type { PointAccessor } from \"./point-types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\n/**\n * Coordinate accessors, resolved scales, and candidate filtering for a nearest-point search.\n *\n * @see {@link PointAccessor}\n * @see {@link ResolvedContinuousScale}\n * @see {@link nearestPoint}\n */\nexport interface NearestPointOptions<D> {\n  /** Property key or callback extracting the horizontal domain coordinate. See {@link PointAccessor}. */\n  readonly x: PointAccessor<D>;\n  /** Property key or callback extracting the vertical domain coordinate. See {@link PointAccessor}. */\n  readonly y: PointAccessor<D>;\n  /** The scale used to map horizontal data coordinates. See {@link ResolvedContinuousScale}. */\n  readonly xScale: ResolvedContinuousScale;\n  /** The scale used to map vertical data coordinates. See {@link ResolvedContinuousScale}. */\n  readonly yScale: ResolvedContinuousScale;\n  /**\n   * Returns whether a datum contributes drawable or queryable coordinates. See\n   * {@link NearestPointOptions}.\n   * @param datum - Datum to test.\n   * @param index - Zero-based index in the source data.\n   * @param data - Complete source data array.\n   * @returns Whether this datum should participate in the series or query.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Maximum distance accepted by the query. See {@link NearestPointOptions}. */\n  readonly maxDistance?: number;\n}\n/**\n * The selected datum, source index, mapped coordinates, and distance from the query point.\n *\n * @see {@link nearestPoint}\n */\nexport interface NearestPoint<D> {\n  /** The original data item selected by this result. See {@link NearestPoint}. */\n  readonly datum: D;\n  /** Index of the selected datum in its source data. See {@link NearestPoint}. */\n  readonly index: number;\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly x: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link NearestPoint}.\n   */\n  readonly y: number;\n  /** Distance measured in this query or guide's coordinate system. See {@link NearestPoint}. */\n  readonly distance: number;\n}\nfunction finite(value: unknown, name: string): asserts value is number {\n  if (!finiteCoordinate(value)) throw new RangeError(`${name} must be finite.`);\n}\n/**\n * Finds the domain value nearest to a logical range coordinate; returns undefined for no\n * candidate.\n *\n * @param values - Candidate domain values.\n * @param rangeValue - Pointer coordinate in the scale's range.\n * @param scale - Scale mapping candidates into range coordinates. See {@link ResolvedContinuousScale}.\n * @returns The nearest domain value, or undefined when no candidate can be selected.\n *\n * @see {@link ResolvedContinuousScale}\n */\nexport function nearestDomainValue(\n  values: readonly number[],\n  rangeValue: number,\n  scale: ResolvedContinuousScale,\n): number | undefined {\n  pointData(values, \"nearestDomainValue\");\n  finite(rangeValue, \"nearestDomainValue rangeValue\");\n  let best: number | undefined,\n    distance = Infinity;\n  for (const value of values) {\n    if (!finiteCoordinate(value)) continue;\n    const next = Math.abs(scale.map(value) - rangeValue);\n    finite(next, \"nearestDomainValue distance\");\n    if (next < distance) {\n      best = value;\n      distance = next;\n    }\n  }\n  return best;\n}\n/**\n * Finds the nearest defined datum in scaled coordinates, subject to an optional maximum distance.\n *\n * @param data - Candidate data records.\n * @param point - Query point in plotted range coordinates.\n * @param options - Accessors, scales, eligibility, and distance settings. See\n * {@link NearestPointOptions} .\n * @returns The nearest matching point, or undefined when no candidate qualifies. See\n * {@link NearestPoint} .\n *\n * @see {@link NearestPointOptions}\n * @see {@link NearestPoint}\n */\nexport function nearestPoint<D>(\n  data: readonly D[],\n  point: Readonly<{ x: number; y: number }>,\n  options: NearestPointOptions<D>,\n): NearestPoint<D> | undefined {\n  pointData(data, \"nearestPoint\");\n  finite(point.x, \"nearestPoint x\");\n  finite(point.y, \"nearestPoint y\");\n  const max = options.maxDistance;\n  if (max !== undefined) {\n    finite(max, \"nearestPoint maxDistance\");\n    if (max < 0)\n      throw new RangeError(\"nearestPoint maxDistance must be nonnegative.\");\n  }\n  const x = pointAccessor(options.x),\n    y = pointAccessor(options.y);\n  let best: NearestPoint<D> | undefined,\n    distance = Infinity;\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (options.defined && !options.defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = options.xScale.map(xv),\n      py = options.yScale.map(yv);\n    const next = Math.hypot(px - point.x, py - point.y);\n    finite(next, \"nearestPoint distance\");\n    if (next < distance && (max === undefined || next <= max)) {\n      distance = next;\n      best = { datum, index: i, x: px, y: py, distance: next };\n    }\n  }\n  return best;\n}\n"],
   "mappings": "AAEA,SAAS,kBAAkB,eAAe,iBAAiB;AAoD3D,SAAS,OAAO,OAAgB,MAAuC;AACrE,MAAI,CAAC,iBAAiB,KAAK,EAAG,OAAM,IAAI,WAAW,GAAG,IAAI,kBAAkB;AAC9E;AAYO,SAAS,mBACd,QACA,YACA,OACoB;AACpB,YAAU,QAAQ,oBAAoB;AACtC,SAAO,YAAY,+BAA+B;AAClD,MAAI,MACF,WAAW;AACb,aAAW,SAAS,QAAQ;AAC1B,QAAI,CAAC,iBAAiB,KAAK,EAAG;AAC9B,UAAM,OAAO,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,UAAU;AACnD,WAAO,MAAM,6BAA6B;AAC1C,QAAI,OAAO,UAAU;AACnB,aAAO;AACP,iBAAW;AAAA,IACb;AAAA,EACF;AACA,SAAO;AACT;AAcO,SAAS,aACd,MACA,OACA,SAC6B;AAC7B,YAAU,MAAM,cAAc;AAC9B,SAAO,MAAM,GAAG,gBAAgB;AAChC,SAAO,MAAM,GAAG,gBAAgB;AAChC,QAAM,MAAM,QAAQ;AACpB,MAAI,QAAQ,QAAW;AACrB,WAAO,KAAK,0BAA0B;AACtC,QAAI,MAAM;AACR,YAAM,IAAI,WAAW,+CAA+C;AAAA,EACxE;AACA,QAAM,IAAI,cAAc,QAAQ,CAAC,GAC/B,IAAI,cAAc,QAAQ,CAAC;AAC7B,MAAI,MACF,WAAW;AACb,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,QAAQ,KAAK,CAAC;AACpB,QAAI,QAAQ,WAAW,CAAC,QAAQ,QAAQ,OAAO,GAAG,IAAI,EAAG;AACzD,UAAM,KAAK,EAAE,OAAO,GAAG,IAAI,GACzB,KAAK,EAAE,OAAO,GAAG,IAAI;AACvB,QAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,EAAG;AACpD,UAAM,KAAK,QAAQ,OAAO,IAAI,EAAE,GAC9B,KAAK,QAAQ,OAAO,IAAI,EAAE;AAC5B,UAAM,OAAO,KAAK,MAAM,KAAK,MAAM,GAAG,KAAK,MAAM,CAAC;AAClD,WAAO,MAAM,uBAAuB;AACpC,QAAI,OAAO,aAAa,QAAQ,UAAa,QAAQ,MAAM;AACzD,iBAAW;AACX,aAAO,EAAE,OAAO,OAAO,GAAG,GAAG,IAAI,GAAG,IAAI,UAAU,KAAK;AAAA,IACzD;AAAA,EACF;AACA,SAAO;AACT;",
   "names": []
 }

package/dist/features/viz/lib/numeric-ticks.d.ts

@@ -0,0 +1,38 @@
+import type { NumericDomain } from "./types.js";
+/** Readable linear tick density. See {@link linearTicks}. */
+export interface LinearTickOptions {
+    /** Target number of intervals, from 2 to 100; defaults to 5. */
+    readonly count?: number;
+}
+/**
+ * Generates bounded ticks at readable 1, 2, or 5 × powers-of-ten intervals.
+ * Endpoints are included only when aligned. Does not change scale geometry.
+ * @param domain - Distinct finite endpoints, ascending or descending.
+ * @param options - Target density; defaults to five intervals.
+ * @returns Frozen ticks in domain order. See {@link niceLinearDomain}.
+ */
+export declare function linearTicks(domain: NumericDomain, options?: LinearTickOptions): readonly number[];
+/**
+ * Expands a linear domain to readable tick boundaries, preserving direction.
+ * @param domain - Distinct finite numeric endpoints; never mutated.
+ * @param options - Target density; defaults to five intervals.
+ * @returns Frozen expanded endpoints. See {@link linearTicks}.
+ */
+export declare function niceLinearDomain(domain: NumericDomain, options?: LinearTickOptions): NumericDomain;
+/** Number formatting with explicit locale and literal unit affixes. See {@link formatNumber}. */
+export interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    /** Locale for formatting; defaults to en-US. */
+    readonly locale?: string;
+    /** Literal prefix; defaults to empty. */
+    readonly prefix?: string;
+    /** Literal suffix, including any desired space; defaults to empty. */
+    readonly suffix?: string;
+}
+/**
+ * Formats a finite number with Intl precision, currency, percent, or unit options.
+ * Rounded negative zero is displayed as positive zero.
+ * @param value - Finite numeric value.
+ * @param options - Intl options plus locale and literal affixes; default maximum fraction digits is 3.
+ * @returns Formatted text. Invalid Intl options retain native errors. See {@link NumberFormatOptions}.
+ */
+export declare function formatNumber(value: number, options?: NumberFormatOptions): string;

package/dist/features/viz/lib/numeric-ticks.js

@@ -0,0 +1,54 @@
+function parameters(domain, options) {
+  const count = options.count ?? 5;
+  if (!Number.isInteger(count) || count < 2 || count > 100)
+    throw new RangeError("Linear tick count must be an integer from 2 to 100.");
+  if (!Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite))
+    throw new RangeError("Linear tick domain requires two finite endpoints.");
+  const lo = Math.min(...domain), hi = Math.max(...domain);
+  const span = hi - lo;
+  if (!Number.isFinite(span) || span === 0)
+    throw new RangeError("Linear tick domain must have a finite nonzero span.");
+  const raw = span / count;
+  const power = 10 ** Math.floor(Math.log10(raw));
+  const error = raw / power;
+  let step = power * (error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.sqrt(2) ? 2 : 1);
+  if (!Number.isFinite(step) || step === 0 || !Number.isSafeInteger(Math.floor(lo / step)) || !Number.isSafeInteger(Math.ceil(hi / step)))
+    throw new RangeError("Linear tick spacing exceeds numeric precision.");
+  if (Math.floor(hi / step) - Math.ceil(lo / step) + 1 > 100) {
+    const magnitude = 10 ** Math.floor(Math.log10(step));
+    const factor = step / magnitude;
+    step = magnitude * (factor < 1.5 ? 2 : factor < 3 ? 5 : 10);
+  }
+  return { lo, hi, step };
+}
+function clean(value) {
+  return Number(value.toPrecision(15)) || 0;
+}
+function linearTicks(domain, options = {}) {
+  const { lo, hi, step } = parameters(domain, options);
+  const start = Math.ceil(lo / step), end = Math.floor(hi / step);
+  const values = Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => clean((start + i) * step)).filter((v) => v >= lo && v <= hi);
+  return Object.freeze(domain[0] > domain[1] ? values.reverse() : values);
+}
+function niceLinearDomain(domain, options = {}) {
+  const { lo, hi, step } = parameters(domain, options);
+  const a = clean(Math.floor(lo / step) * step), b = clean(Math.ceil(hi / step) * step);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) throw new RangeError("Nice linear domain exceeds finite numeric bounds.");
+  return Object.freeze(domain[0] > domain[1] ? [b, a] : [a, b]);
+}
+function formatNumber(value, options = {}) {
+  if (!Number.isFinite(value)) throw new RangeError("formatNumber value must be finite.");
+  const { locale = "en-US", prefix = "", suffix = "", ...intl } = options;
+  const formatter = new Intl.NumberFormat(locale, intl);
+  const parts = formatter.formatToParts(value);
+  const zeroDigit = Array.from(formatter.formatToParts(0).find((p) => p.type === "integer").value).at(-1);
+  const digits = parts.filter((p) => p.type === "integer" || p.type === "fraction");
+  const zero = digits.length > 0 && digits.every((p) => Array.from(p.value).every((digit) => digit === zeroDigit));
+  return prefix + formatter.format(zero ? 0 : value) + suffix;
+}
+export {
+  formatNumber,
+  linearTicks,
+  niceLinearDomain
+};
+//# sourceMappingURL=numeric-ticks.js.map

package/dist/features/viz/lib/numeric-ticks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/numeric-ticks.ts"],
+  "sourcesContent": ["import type { NumericDomain } from \"./types.js\";\n\n/** Readable linear tick density. See {@link linearTicks}. */\nexport interface LinearTickOptions {\n  /** Target number of intervals, from 2 to 100; defaults to 5. */\n  readonly count?: number;\n}\nfunction parameters(domain: NumericDomain, options: LinearTickOptions) {\n  const count = options.count ?? 5;\n  if (!Number.isInteger(count) || count < 2 || count > 100)\n    throw new RangeError(\"Linear tick count must be an integer from 2 to 100.\");\n  if (!Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite))\n    throw new RangeError(\"Linear tick domain requires two finite endpoints.\");\n  const lo = Math.min(...domain), hi = Math.max(...domain);\n  const span = hi - lo;\n  if (!Number.isFinite(span) || span === 0)\n    throw new RangeError(\"Linear tick domain must have a finite nonzero span.\");\n  const raw = span / count;\n  const power = 10 ** Math.floor(Math.log10(raw));\n  const error = raw / power;\n  let step = power * (error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.sqrt(2) ? 2 : 1);\n  if (!Number.isFinite(step) || step === 0 || !Number.isSafeInteger(Math.floor(lo / step)) || !Number.isSafeInteger(Math.ceil(hi / step)))\n    throw new RangeError(\"Linear tick spacing exceeds numeric precision.\");\n  if (Math.floor(hi / step) - Math.ceil(lo / step) + 1 > 100) {\n    const magnitude = 10 ** Math.floor(Math.log10(step));\n    const factor = step / magnitude;\n    step = magnitude * (factor < 1.5 ? 2 : factor < 3 ? 5 : 10);\n  }\n  return { lo, hi, step };\n}\nfunction clean(value: number) { return Number(value.toPrecision(15)) || 0; }\n/**\n * Generates bounded ticks at readable 1, 2, or 5 \u00D7 powers-of-ten intervals.\n * Endpoints are included only when aligned. Does not change scale geometry.\n * @param domain - Distinct finite endpoints, ascending or descending.\n * @param options - Target density; defaults to five intervals.\n * @returns Frozen ticks in domain order. See {@link niceLinearDomain}.\n */\nexport function linearTicks(domain: NumericDomain, options: LinearTickOptions = {}): readonly number[] {\n  const { lo, hi, step } = parameters(domain, options);\n  const start = Math.ceil(lo / step), end = Math.floor(hi / step);\n  const values = Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => clean((start + i) * step)).filter(v => v >= lo && v <= hi);\n  return Object.freeze(domain[0] > domain[1] ? values.reverse() : values);\n}\n/**\n * Expands a linear domain to readable tick boundaries, preserving direction.\n * @param domain - Distinct finite numeric endpoints; never mutated.\n * @param options - Target density; defaults to five intervals.\n * @returns Frozen expanded endpoints. See {@link linearTicks}.\n */\nexport function niceLinearDomain(domain: NumericDomain, options: LinearTickOptions = {}): NumericDomain {\n  const { lo, hi, step } = parameters(domain, options);\n  const a = clean(Math.floor(lo / step) * step), b = clean(Math.ceil(hi / step) * step);\n  if (!Number.isFinite(a) || !Number.isFinite(b)) throw new RangeError(\"Nice linear domain exceeds finite numeric bounds.\");\n  return Object.freeze(domain[0] > domain[1] ? [b, a] : [a, b]);\n}\n/** Number formatting with explicit locale and literal unit affixes. See {@link formatNumber}. */\nexport interface NumberFormatOptions extends Intl.NumberFormatOptions {\n  /** Locale for formatting; defaults to en-US. */\n  readonly locale?: string;\n  /** Literal prefix; defaults to empty. */\n  readonly prefix?: string;\n  /** Literal suffix, including any desired space; defaults to empty. */\n  readonly suffix?: string;\n}\n/**\n * Formats a finite number with Intl precision, currency, percent, or unit options.\n * Rounded negative zero is displayed as positive zero.\n * @param value - Finite numeric value.\n * @param options - Intl options plus locale and literal affixes; default maximum fraction digits is 3.\n * @returns Formatted text. Invalid Intl options retain native errors. See {@link NumberFormatOptions}.\n */\nexport function formatNumber(value: number, options: NumberFormatOptions = {}): string {\n  if (!Number.isFinite(value)) throw new RangeError(\"formatNumber value must be finite.\");\n  const { locale = \"en-US\", prefix = \"\", suffix = \"\", ...intl } = options;\n  const formatter = new Intl.NumberFormat(locale, intl);\n  const parts = formatter.formatToParts(value);\n  const zeroDigit = Array.from(formatter.formatToParts(0).find(p => p.type === \"integer\")!.value).at(-1)!;\n  const digits = parts.filter(p => p.type === \"integer\" || p.type === \"fraction\");\n  const zero = digits.length > 0 && digits.every(p => Array.from(p.value).every(digit => digit === zeroDigit));\n  return prefix + formatter.format(zero ? 0 : value) + suffix;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/plot-series.js

@@ -1,7 +1,7 @@
 import { jsx } from "@pibbl/core/jsx-runtime";
 import { Group, resolveSignalValue } from "@pibbl/core";
 import { pointAccessor, pointData, finiteCoordinate } from "./point-data.js";
-import { useScale } from "./use-scale.js";
+import { useContinuousScale } from "./use-continuous-scale.js";
 function PlotRow({
   datum,
   index,
@@ -21,7 +21,7 @@ function PlotSeries({
   render,
   ...events
 }) {
-  const xs = useScale(xId).get(), ys = useScale(yId).get();
+  const xs = useContinuousScale(xId).get(), ys = useContinuousScale(yId).get();
   const data = pointData(resolveSignalValue(input), "PlotSeries");
   if (typeof render !== "function")
     throw new TypeError("PlotSeries: render must be a synchronous function.");

package/dist/features/viz/lib/plot-series.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/features/viz/lib/plot-series.tsx"],
-  "sourcesContent": ["import { Group, resolveSignalValue } from \"@pibbl/core\";\nimport type { PibblNode } from \"@pibbl/core\";\nimport type { PlotSeriesProps } from \"./plot-types.js\";\nimport { pointAccessor, pointData, finiteCoordinate } from \"./point-data.js\";\nimport { useScale } from \"./use-scale.js\";\nfunction PlotRow<D>({\n  datum,\n  index,\n  data,\n  render,\n}: {\n  datum: D;\n  index: number;\n  data: readonly D[];\n  render: PlotSeriesProps<D>[\"render\"];\n}): PibblNode {\n  return render(datum, index, data);\n}\n/**\n * Places keyed custom Pibbl subtrees at local data coordinates.\n *\n * @param props - Data, coordinate accessors, scales, keys, and per-datum renderer. See\n * {@link PlotSeriesProps} .\n * @returns Pibbl nodes placing each rendered datum at its mapped coordinates. See {@link PibblNode}.\n *\n * @see {@link PlotSeriesProps}\n * @see {@link PibblNode}\n */\nexport function PlotSeries<D>({\n  data: input,\n  x: xInput,\n  y: yInput,\n  xScale: xId,\n  yScale: yId,\n  defined,\n  keyBy,\n  render,\n  ...events\n}: PlotSeriesProps<D>): PibblNode {\n  const xs = useScale(xId).get(),\n    ys = useScale(yId).get();\n  const data = pointData(resolveSignalValue(input), \"PlotSeries\");\n  if (typeof render !== \"function\")\n    throw new TypeError(\"PlotSeries: render must be a synchronous function.\");\n  const x = pointAccessor(xInput),\n    y = pointAccessor(yInput);\n  const keys = new Set<string>();\n  const nodes: PibblNode[] = [];\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (defined && !defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = xs.map(xv),\n      py = ys.map(yv);\n    const key =\n      keyBy === undefined\n        ? i\n        : typeof keyBy === \"function\"\n          ? keyBy(datum, i, data)\n          : datum[keyBy];\n    if (typeof key !== \"string\" && typeof key !== \"number\")\n      throw new TypeError(\"PlotSeries: keyBy must return a string or number.\");\n    const normalized = String(key);\n    if (keys.has(normalized))\n      throw new Error(`PlotSeries: duplicate key \"${normalized}\".`);\n    keys.add(normalized);\n    nodes.push(\n      <Group key={normalized} style={{ translateX: px, translateY: py }}>\n        <PlotRow datum={datum} index={i} data={data} render={render} />\n      </Group>,\n    );\n  }\n  return <Group {...events}>{nodes}</Group>;\n}\n"],
-  "mappings": "AAsEQ;AAtER,SAAS,OAAO,0BAA0B;AAG1C,SAAS,eAAe,WAAW,wBAAwB;AAC3D,SAAS,gBAAgB;AACzB,SAAS,QAAW;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKc;AACZ,SAAO,OAAO,OAAO,OAAO,IAAI;AAClC;AAWO,SAAS,WAAc;AAAA,EAC5B,MAAM;AAAA,EACN,GAAG;AAAA,EACH,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAAkC;AAChC,QAAM,KAAK,SAAS,GAAG,EAAE,IAAI,GAC3B,KAAK,SAAS,GAAG,EAAE,IAAI;AACzB,QAAM,OAAO,UAAU,mBAAmB,KAAK,GAAG,YAAY;AAC9D,MAAI,OAAO,WAAW;AACpB,UAAM,IAAI,UAAU,oDAAoD;AAC1E,QAAM,IAAI,cAAc,MAAM,GAC5B,IAAI,cAAc,MAAM;AAC1B,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,QAAqB,CAAC;AAC5B,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,QAAQ,KAAK,CAAC;AACpB,QAAI,WAAW,CAAC,QAAQ,OAAO,GAAG,IAAI,EAAG;AACzC,UAAM,KAAK,EAAE,OAAO,GAAG,IAAI,GACzB,KAAK,EAAE,OAAO,GAAG,IAAI;AACvB,QAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,EAAG;AACpD,UAAM,KAAK,GAAG,IAAI,EAAE,GAClB,KAAK,GAAG,IAAI,EAAE;AAChB,UAAM,MACJ,UAAU,SACN,IACA,OAAO,UAAU,aACf,MAAM,OAAO,GAAG,IAAI,IACpB,MAAM,KAAK;AACnB,QAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ;AAC5C,YAAM,IAAI,UAAU,mDAAmD;AACzE,UAAM,aAAa,OAAO,GAAG;AAC7B,QAAI,KAAK,IAAI,UAAU;AACrB,YAAM,IAAI,MAAM,8BAA8B,UAAU,IAAI;AAC9D,SAAK,IAAI,UAAU;AACnB,UAAM;AAAA,MACJ,oBAAC,SAAuB,OAAO,EAAE,YAAY,IAAI,YAAY,GAAG,GAC9D,8BAAC,WAAQ,OAAc,OAAO,GAAG,MAAY,QAAgB,KADnD,UAEZ;AAAA,IACF;AAAA,EACF;AACA,SAAO,oBAAC,SAAO,GAAG,QAAS,iBAAM;AACnC;",
+  "sourcesContent": ["import { Group, resolveSignalValue } from \"@pibbl/core\";\nimport type { PibblNode } from \"@pibbl/core\";\nimport type { PlotSeriesProps } from \"./plot-types.js\";\nimport { pointAccessor, pointData, finiteCoordinate } from \"./point-data.js\";\nimport { useContinuousScale } from \"./use-continuous-scale.js\";\nfunction PlotRow<D>({\n  datum,\n  index,\n  data,\n  render,\n}: {\n  datum: D;\n  index: number;\n  data: readonly D[];\n  render: PlotSeriesProps<D>[\"render\"];\n}): PibblNode {\n  return render(datum, index, data);\n}\n/**\n * Places keyed custom Pibbl subtrees at local data coordinates.\n *\n * @param props - Data, coordinate accessors, scales, keys, and per-datum renderer. See\n * {@link PlotSeriesProps} .\n * @returns Pibbl nodes placing each rendered datum at its mapped coordinates. See {@link PibblNode}.\n *\n * @see {@link PlotSeriesProps}\n * @see {@link PibblNode}\n */\nexport function PlotSeries<D>({\n  data: input,\n  x: xInput,\n  y: yInput,\n  xScale: xId,\n  yScale: yId,\n  defined,\n  keyBy,\n  render,\n  ...events\n}: PlotSeriesProps<D>): PibblNode {\n  const xs = useContinuousScale(xId).get(),\n    ys = useContinuousScale(yId).get();\n  const data = pointData(resolveSignalValue(input), \"PlotSeries\");\n  if (typeof render !== \"function\")\n    throw new TypeError(\"PlotSeries: render must be a synchronous function.\");\n  const x = pointAccessor(xInput),\n    y = pointAccessor(yInput);\n  const keys = new Set<string>();\n  const nodes: PibblNode[] = [];\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    if (defined && !defined(datum, i, data)) continue;\n    const xv = x(datum, i, data),\n      yv = y(datum, i, data);\n    if (!finiteCoordinate(xv) || !finiteCoordinate(yv)) continue;\n    const px = xs.map(xv),\n      py = ys.map(yv);\n    const key =\n      keyBy === undefined\n        ? i\n        : typeof keyBy === \"function\"\n          ? keyBy(datum, i, data)\n          : datum[keyBy];\n    if (typeof key !== \"string\" && typeof key !== \"number\")\n      throw new TypeError(\"PlotSeries: keyBy must return a string or number.\");\n    const normalized = String(key);\n    if (keys.has(normalized))\n      throw new Error(`PlotSeries: duplicate key \"${normalized}\".`);\n    keys.add(normalized);\n    nodes.push(\n      <Group key={normalized} style={{ translateX: px, translateY: py }}>\n        <PlotRow datum={datum} index={i} data={data} render={render} />\n      </Group>,\n    );\n  }\n  return <Group {...events}>{nodes}</Group>;\n}\n"],
+  "mappings": "AAsEQ;AAtER,SAAS,OAAO,0BAA0B;AAG1C,SAAS,eAAe,WAAW,wBAAwB;AAC3D,SAAS,0BAA0B;AACnC,SAAS,QAAW;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKc;AACZ,SAAO,OAAO,OAAO,OAAO,IAAI;AAClC;AAWO,SAAS,WAAc;AAAA,EAC5B,MAAM;AAAA,EACN,GAAG;AAAA,EACH,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAAkC;AAChC,QAAM,KAAK,mBAAmB,GAAG,EAAE,IAAI,GACrC,KAAK,mBAAmB,GAAG,EAAE,IAAI;AACnC,QAAM,OAAO,UAAU,mBAAmB,KAAK,GAAG,YAAY;AAC9D,MAAI,OAAO,WAAW;AACpB,UAAM,IAAI,UAAU,oDAAoD;AAC1E,QAAM,IAAI,cAAc,MAAM,GAC5B,IAAI,cAAc,MAAM;AAC1B,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,QAAqB,CAAC;AAC5B,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,QAAQ,KAAK,CAAC;AACpB,QAAI,WAAW,CAAC,QAAQ,OAAO,GAAG,IAAI,EAAG;AACzC,UAAM,KAAK,EAAE,OAAO,GAAG,IAAI,GACzB,KAAK,EAAE,OAAO,GAAG,IAAI;AACvB,QAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,EAAG;AACpD,UAAM,KAAK,GAAG,IAAI,EAAE,GAClB,KAAK,GAAG,IAAI,EAAE;AAChB,UAAM,MACJ,UAAU,SACN,IACA,OAAO,UAAU,aACf,MAAM,OAAO,GAAG,IAAI,IACpB,MAAM,KAAK;AACnB,QAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ;AAC5C,YAAM,IAAI,UAAU,mDAAmD;AACzE,UAAM,aAAa,OAAO,GAAG;AAC7B,QAAI,KAAK,IAAI,UAAU;AACrB,YAAM,IAAI,MAAM,8BAA8B,UAAU,IAAI;AAC9D,SAAK,IAAI,UAAU;AACnB,UAAM;AAAA,MACJ,oBAAC,SAAuB,OAAO,EAAE,YAAY,IAAI,YAAY,GAAG,GAC9D,8BAAC,WAAQ,OAAc,OAAO,GAAG,MAAY,QAAgB,KADnD,UAEZ;AAAA,IACF;AAAA,EACF;AACA,SAAO,oBAAC,SAAO,GAAG,QAAS,iBAAM;AACnC;",
   "names": []
 }

package/dist/features/viz/lib/point-scale-component.d.ts

@@ -0,0 +1,7 @@
+import type { PointScaleProps } from "./types.js";
+/**
+ * Provides a named point mapping to descendant visualization components.
+ * @param props - Identity, domain, range, and padding. See {@link PointScaleProps}.
+ * @returns Descendant content within the scale scope.
+ */
+export declare function PointScale(props: PointScaleProps): import("@pibbl/core").PibblNode;

package/dist/features/viz/lib/point-scale-component.js

@@ -0,0 +1,19 @@
+import { resolveSignalValue, useLayoutBox } from "@pibbl/core";
+import { resolvePointScale } from "./point-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+function PointScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(props.id, "point", () => resolvePointScale(
+    resolveSignalValue(props.domain),
+    resolveSignalValue(props.range),
+    resolveSignalValue(props.reverse ?? false),
+    width,
+    height,
+    resolveSignalValue(props.padding ?? 0)
+  ), [props.domain, props.range, props.reverse, props.padding, width, height]);
+  return props.children;
+}
+export {
+  PointScale
+};
+//# sourceMappingURL=point-scale-component.js.map

package/dist/features/viz/lib/point-scale-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/point-scale-component.ts"],
+  "sourcesContent": ["import { resolveSignalValue, useLayoutBox } from \"@pibbl/core\";\nimport type { PointScaleProps } from \"./types.js\";\nimport { resolvePointScale } from \"./point-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\n/**\n * Provides a named point mapping to descendant visualization components.\n * @param props - Identity, domain, range, and padding. See {@link PointScaleProps}.\n * @returns Descendant content within the scale scope.\n */\nexport function PointScale(props: PointScaleProps) {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(props.id, \"point\", () => resolvePointScale(\n    resolveSignalValue(props.domain), resolveSignalValue(props.range),\n    resolveSignalValue(props.reverse ?? false), width, height, resolveSignalValue(props.padding ?? 0),\n  ), [props.domain, props.range, props.reverse, props.padding, width, height]);\n  return props.children;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB,oBAAoB;AAEjD,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AAM1B,SAAS,WAAW,OAAwB;AACjD,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC,mBAAiB,MAAM,IAAI,SAAS,MAAM;AAAA,IACxC,mBAAmB,MAAM,MAAM;AAAA,IAAG,mBAAmB,MAAM,KAAK;AAAA,IAChE,mBAAmB,MAAM,WAAW,KAAK;AAAA,IAAG;AAAA,IAAO;AAAA,IAAQ,mBAAmB,MAAM,WAAW,CAAC;AAAA,EAClG,GAAG,CAAC,MAAM,QAAQ,MAAM,OAAO,MAAM,SAAS,MAAM,SAAS,OAAO,MAAM,CAAC;AAC3E,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/features/viz/lib/point-scale.d.ts

@@ -0,0 +1,2 @@
+import type { BandDomain, ResolvedPointScale, ScaleRange } from "./types.js";
+export declare function resolvePointScale(input: BandDomain, rangeInput: ScaleRange, reverse: boolean, width: number, height: number, padding: number): ResolvedPointScale;

package/dist/features/viz/lib/point-scale.js

@@ -0,0 +1,45 @@
+import { resolveLinearScale } from "./linear-scale.js";
+function resolvePointScale(input, rangeInput, reverse, width, height, padding) {
+  if (!Array.isArray(input)) throw new TypeError("PointScale domain must be an array.");
+  const indices = /* @__PURE__ */ new Map();
+  for (const category of input) {
+    if (typeof category !== "string" && (typeof category !== "number" || !Number.isFinite(category))) throw new TypeError("PointScale categories must be strings or finite numbers.");
+    if (indices.has(category)) throw new TypeError("PointScale domain must not contain duplicate categories.");
+    indices.set(category, indices.size);
+  }
+  if (typeof padding !== "number" || !Number.isFinite(padding) || padding < 0 || !Number.isFinite(2 * padding)) throw new RangeError("PointScale padding must be finite and nonnegative with finite arithmetic.");
+  const { range, frame } = resolveLinearScale([0, 1], rangeInput, reverse, width, height);
+  const domain = Object.freeze([...input]), span = range[1] - range[0];
+  const step = domain.length < 2 ? 0 : span / Math.max(1, domain.length - 1 + 2 * padding);
+  const start = range[0] + (span - step * (domain.length - 1)) / 2;
+  const map = (value) => {
+    const index = indices.get(value);
+    return index === void 0 ? void 0 : start + index * step;
+  };
+  return Object.freeze({
+    type: "point",
+    domain,
+    range,
+    frame,
+    padding,
+    step: Math.abs(step),
+    map,
+    invert(pixel) {
+      if (typeof pixel !== "number" || !Number.isFinite(pixel)) throw new RangeError("PointScale invert input must be finite.");
+      if (!domain.length) return void 0;
+      if (!step) return domain[0];
+      const position = (pixel - start) / step;
+      const index = Math.max(0, Math.min(domain.length - 1, Math.ceil(position - 0.5)));
+      return domain[index];
+    },
+    ticks(count = 5) {
+      if (!Number.isInteger(count) || count < 0 || count > 100) throw new RangeError("PointScale ticks count must be an integer from 0 to 100.");
+      const size = Math.min(count, domain.length);
+      return Object.freeze(size === 0 ? [] : size === 1 ? [domain[0]] : Array.from({ length: size }, (_, i) => domain[Math.round(i * (domain.length - 1) / (size - 1))]));
+    }
+  });
+}
+export {
+  resolvePointScale
+};
+//# sourceMappingURL=point-scale.js.map

package/dist/features/viz/lib/point-scale.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/point-scale.ts"],
+  "sourcesContent": ["import type { BandCategory, BandDomain, ResolvedPointScale, ScaleRange } from \"./types.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nexport function resolvePointScale(input: BandDomain, rangeInput: ScaleRange, reverse: boolean, width: number, height: number, padding: number): ResolvedPointScale {\n  if (!Array.isArray(input)) throw new TypeError(\"PointScale domain must be an array.\");\n  const indices = new Map<BandCategory, number>();\n  for (const category of input) {\n    if (typeof category !== \"string\" && (typeof category !== \"number\" || !Number.isFinite(category))) throw new TypeError(\"PointScale categories must be strings or finite numbers.\");\n    if (indices.has(category)) throw new TypeError(\"PointScale domain must not contain duplicate categories.\");\n    indices.set(category, indices.size);\n  }\n  if (typeof padding !== \"number\" || !Number.isFinite(padding) || padding < 0 || !Number.isFinite(2 * padding)) throw new RangeError(\"PointScale padding must be finite and nonnegative with finite arithmetic.\");\n  const { range, frame } = resolveLinearScale([0, 1], rangeInput, reverse, width, height);\n  const domain = Object.freeze([...input]), span = range[1] - range[0];\n  const step = domain.length < 2 ? 0 : span / Math.max(1, domain.length - 1 + 2 * padding);\n  const start = range[0] + (span - step * (domain.length - 1)) / 2;\n  const map = (value: BandCategory) => { const index = indices.get(value); return index === undefined ? undefined : start + index * step; };\n  return Object.freeze({\n    type: \"point\", domain, range, frame, padding, step: Math.abs(step), map,\n    invert(pixel: number) {\n      if (typeof pixel !== \"number\" || !Number.isFinite(pixel)) throw new RangeError(\"PointScale invert input must be finite.\");\n      if (!domain.length) return undefined;\n      if (!step) return domain[0];\n      const position = (pixel - start) / step;\n      const index = Math.max(0, Math.min(domain.length - 1, Math.ceil(position - 0.5)));\n      return domain[index];\n    },\n    ticks(count = 5) {\n      if (!Number.isInteger(count) || count < 0 || count > 100) throw new RangeError(\"PointScale ticks count must be an integer from 0 to 100.\");\n      const size = Math.min(count, domain.length);\n      return Object.freeze(size === 0 ? [] : size === 1 ? [domain[0]] : Array.from({ length: size }, (_, i) => domain[Math.round(i * (domain.length - 1) / (size - 1))]));\n    },\n  });\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AAC5B,SAAS,kBAAkB,OAAmB,YAAwB,SAAkB,OAAe,QAAgB,SAAqC;AACjK,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,OAAM,IAAI,UAAU,qCAAqC;AACpF,QAAM,UAAU,oBAAI,IAA0B;AAC9C,aAAW,YAAY,OAAO;AAC5B,QAAI,OAAO,aAAa,aAAa,OAAO,aAAa,YAAY,CAAC,OAAO,SAAS,QAAQ,GAAI,OAAM,IAAI,UAAU,0DAA0D;AAChL,QAAI,QAAQ,IAAI,QAAQ,EAAG,OAAM,IAAI,UAAU,0DAA0D;AACzG,YAAQ,IAAI,UAAU,QAAQ,IAAI;AAAA,EACpC;AACA,MAAI,OAAO,YAAY,YAAY,CAAC,OAAO,SAAS,OAAO,KAAK,UAAU,KAAK,CAAC,OAAO,SAAS,IAAI,OAAO,EAAG,OAAM,IAAI,WAAW,2EAA2E;AAC9M,QAAM,EAAE,OAAO,MAAM,IAAI,mBAAmB,CAAC,GAAG,CAAC,GAAG,YAAY,SAAS,OAAO,MAAM;AACtF,QAAM,SAAS,OAAO,OAAO,CAAC,GAAG,KAAK,CAAC,GAAG,OAAO,MAAM,CAAC,IAAI,MAAM,CAAC;AACnE,QAAM,OAAO,OAAO,SAAS,IAAI,IAAI,OAAO,KAAK,IAAI,GAAG,OAAO,SAAS,IAAI,IAAI,OAAO;AACvF,QAAM,QAAQ,MAAM,CAAC,KAAK,OAAO,QAAQ,OAAO,SAAS,MAAM;AAC/D,QAAM,MAAM,CAAC,UAAwB;AAAE,UAAM,QAAQ,QAAQ,IAAI,KAAK;AAAG,WAAO,UAAU,SAAY,SAAY,QAAQ,QAAQ;AAAA,EAAM;AACxI,SAAO,OAAO,OAAO;AAAA,IACnB,MAAM;AAAA,IAAS;AAAA,IAAQ;AAAA,IAAO;AAAA,IAAO;AAAA,IAAS,MAAM,KAAK,IAAI,IAAI;AAAA,IAAG;AAAA,IACpE,OAAO,OAAe;AACpB,UAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,OAAM,IAAI,WAAW,yCAAyC;AACxH,UAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,UAAI,CAAC,KAAM,QAAO,OAAO,CAAC;AAC1B,YAAM,YAAY,QAAQ,SAAS;AACnC,YAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,IAAI,OAAO,SAAS,GAAG,KAAK,KAAK,WAAW,GAAG,CAAC,CAAC;AAChF,aAAO,OAAO,KAAK;AAAA,IACrB;AAAA,IACA,MAAM,QAAQ,GAAG;AACf,UAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ,IAAK,OAAM,IAAI,WAAW,0DAA0D;AACzI,YAAM,OAAO,KAAK,IAAI,OAAO,OAAO,MAAM;AAC1C,aAAO,OAAO,OAAO,SAAS,IAAI,CAAC,IAAI,SAAS,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,MAAM,KAAK,EAAE,QAAQ,KAAK,GAAG,CAAC,GAAG,MAAM,OAAO,KAAK,MAAM,KAAK,OAAO,SAAS,MAAM,OAAO,EAAE,CAAC,CAAC,CAAC;AAAA,IACpK;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/features/viz/lib/point-series.js

@@ -6,7 +6,7 @@ import {
   resolveSignalValue,
   useCanvasContext
 } from "@pibbl/core";
-import { useScale } from "./use-scale.js";
+import { useContinuousScale } from "./use-continuous-scale.js";
 import { finiteCoordinate, pointAccessor, pointData } from "./point-data.js";
 import { appendPointTarget, pointPath } from "./point-geometry.js";
 import { opacity, width } from "./paint.js";
@@ -55,7 +55,7 @@ function PointSeries({
   style: styleInput,
   ...events
 }) {
-  const xs = useScale(xId).get(), ys = useScale(yId).get();
+  const xs = useContinuousScale(xId).get(), ys = useContinuousScale(yId).get();
   const data = pointData(resolveSignalValue(input), "PointSeries");
   const x = pointAccessor(xInput), y = pointAccessor(yInput);
   const specified = resolveSignalValue(styleInput);