ggaction 0.0.3 → 0.0.5

package/src/grammar/window.js

@@ -0,0 +1,339 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "partitionBy", "sortBy", "operations"
+]);
+const SORT_KEYS = Object.freeze(["field", "order"]);
+const ORDER_VALUES = Object.freeze(["ascending", "descending"]);
+const OPERATION_VALUES = Object.freeze([
+  "rowNumber", "rank", "denseRank", "cumulativeSum", "lag", "lead"
+]);
+const POSITION_OPERATIONS = new Set(["rowNumber", "rank", "denseRank"]);
+const OFFSET_OPERATIONS = new Set(["lag", "lead"]);
+
+function requireField(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+function rejectUnknownKeys(value, supported, label) {
+  const unknown = Object.keys(value).find(key => !supported.includes(key));
+  if (unknown !== undefined) {
+    throw new Error(`Unknown ${label} property "${unknown}".`);
+  }
+}
+
+function validateFieldList(value, label) {
+  if (
+    !Array.isArray(value) ||
+    value.some(field => typeof field !== "string" || field.length === 0)
+  ) {
+    throw new TypeError(`${label} must contain field names.`);
+  }
+  if (new Set(value).size !== value.length) {
+    throw new Error(`${label} fields must be unique.`);
+  }
+}
+
+function validateSortBy(sortBy) {
+  if (!Array.isArray(sortBy)) {
+    throw new TypeError("Window sortBy must be an array.");
+  }
+  const fields = [];
+  sortBy.forEach((sort, index) => {
+    if (!isPlainObject(sort)) {
+      throw new TypeError(`Window sortBy[${index}] must be a plain object.`);
+    }
+    rejectUnknownKeys(sort, SORT_KEYS, `window sortBy[${index}]`);
+    fields.push(requireField(sort.field, `Window sortBy[${index}].field`));
+    if (!ORDER_VALUES.includes(sort.order)) {
+      throw new Error(`Unsupported window sort order "${sort.order}".`);
+    }
+  });
+  if (new Set(fields).size !== fields.length) {
+    throw new Error("Window sortBy fields must be unique.");
+  }
+}
+
+function operationKeys(operation) {
+  if (POSITION_OPERATIONS.has(operation.op)) return ["op", "as"];
+  if (operation.op === "cumulativeSum") return ["op", "field", "as"];
+  if (OFFSET_OPERATIONS.has(operation.op)) {
+    return ["op", "field", "as", "offset", "default"];
+  }
+  return ["op"];
+}
+
+function validateOperations(operations, sortBy) {
+  if (!Array.isArray(operations) || operations.length === 0) {
+    throw new TypeError("Window operations must be a non-empty array.");
+  }
+  const outputs = new Set();
+  operations.forEach((operation, index) => {
+    if (!isPlainObject(operation)) {
+      throw new TypeError(`Window operation ${index} must be a plain object.`);
+    }
+    if (!OPERATION_VALUES.includes(operation.op)) {
+      throw new Error(`Unsupported window operation "${operation.op}".`);
+    }
+    rejectUnknownKeys(operation, operationKeys(operation), `window operation ${index}`);
+    const output = requireField(operation.as, `Window operation ${index} as`);
+    if (outputs.has(output)) {
+      throw new Error(`Window output field "${output}" must be unique.`);
+    }
+    outputs.add(output);
+    if (["rank", "denseRank"].includes(operation.op) && sortBy.length === 0) {
+      throw new Error(`${operation.op} requires a non-empty window sortBy.`);
+    }
+    if (!POSITION_OPERATIONS.has(operation.op)) {
+      requireField(operation.field, `Window ${operation.op} field`);
+    }
+    if (OFFSET_OPERATIONS.has(operation.op)) {
+      if (!Number.isInteger(operation.offset) || operation.offset <= 0) {
+        throw new RangeError(`Window ${operation.op} offset must be a positive integer.`);
+      }
+      if (!Object.hasOwn(operation, "default")) {
+        throw new TypeError(`Window ${operation.op} requires a default value.`);
+      }
+    }
+  });
+}
+
+export function validateWindowTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Window transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "window transform");
+  if (transform.type !== "window") {
+    throw new Error(`Unsupported window transform "${transform.type}".`);
+  }
+  validateFieldList(transform.partitionBy, "Window partitionBy");
+  validateSortBy(transform.sortBy);
+  validateOperations(transform.operations, transform.sortBy);
+  return transform;
+}
+
+function normalizePartitionBy(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? [...value] : [value];
+}
+
+function normalizeSortBy(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) return value;
+  return value.map(sort => isPlainObject(sort)
+    ? { field: sort.field, order: sort.order ?? "ascending" }
+    : sort
+  );
+}
+
+function normalizeOperations(value) {
+  if (!Array.isArray(value)) return value;
+  return value.map(operation => {
+    if (!isPlainObject(operation) || !OFFSET_OPERATIONS.has(operation.op)) {
+      return operation;
+    }
+    return {
+      ...operation,
+      offset: operation.offset ?? 1,
+      default: Object.hasOwn(operation, "default") ? operation.default : null
+    };
+  });
+}
+
+export function normalizeWindowTransform({
+  partitionBy,
+  sortBy,
+  operations
+} = {}) {
+  const transform = {
+    type: "window",
+    partitionBy: normalizePartitionBy(partitionBy),
+    sortBy: normalizeSortBy(sortBy),
+    operations: normalizeOperations(operations)
+  };
+  validateWindowTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+function scalarKey(value, label) {
+  if (value === null) return "null";
+  if (typeof value === "string") return `string:${value.length}:${value}`;
+  if (typeof value === "boolean") return `boolean:${value}`;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `number:${Object.is(value, -0) ? 0 : value}`;
+  }
+  throw new TypeError(
+    `${label} must contain null, strings, booleans, or finite numbers.`
+  );
+}
+
+function compareScalar(left, right, label) {
+  const leftMissing = left === null || left === undefined;
+  const rightMissing = right === null || right === undefined;
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0;
+    return leftMissing ? 1 : -1;
+  }
+  if (typeof left !== typeof right || !["number", "string", "boolean"].includes(
+    typeof left
+  )) {
+    throw new TypeError(`${label} must contain one comparable primitive type.`);
+  }
+  if (typeof left === "number" && (!Number.isFinite(left) || !Number.isFinite(right))) {
+    throw new TypeError(`${label} must contain finite numbers.`);
+  }
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function compareEntries(left, right, sortBy, stable = true) {
+  for (const sort of sortBy) {
+    const comparison = compareScalar(
+      left.row[sort.field],
+      right.row[sort.field],
+      `Window sort field "${sort.field}"`
+    );
+    if (comparison !== 0) {
+      return sort.order === "ascending" ? comparison : -comparison;
+    }
+  }
+  return stable ? left.index - right.index : 0;
+}
+
+function validateSourceFields(rows, transform) {
+  const sourceFields = new Set(rows.flatMap(row => Object.keys(row)));
+  for (const field of [...transform.partitionBy, ...transform.sortBy.map(sort => sort.field)]) {
+    if (!sourceFields.has(field)) {
+      throw new Error(`Window source does not contain field "${field}".`);
+    }
+  }
+  const available = new Set(sourceFields);
+  for (const operation of transform.operations) {
+    if (
+      !POSITION_OPERATIONS.has(operation.op) &&
+      !available.has(operation.field)
+    ) {
+      throw new Error(`Window source does not contain field "${operation.field}".`);
+    }
+    if (available.has(operation.as)) {
+      throw new Error(`Window output field "${operation.as}" already exists.`);
+    }
+    available.add(operation.as);
+  }
+}
+
+function validatePartitionSortValues(partition, transform) {
+  for (const field of transform.partitionBy) {
+    partition.forEach(entry => scalarKey(
+      entry.row[field],
+      `Window partition field "${field}"`
+    ));
+  }
+  for (const sort of transform.sortBy) {
+    const types = new Set(partition.flatMap(({ row }) => {
+      const value = row[sort.field];
+      if (value === null || value === undefined) return [];
+      if (
+        !["number", "string", "boolean"].includes(typeof value) ||
+        (typeof value === "number" && !Number.isFinite(value))
+      ) {
+        throw new TypeError(
+          `Window sort field "${sort.field}" must contain comparable primitive values.`
+        );
+      }
+      return [typeof value];
+    }));
+    if (types.size > 1) {
+      throw new TypeError(
+        `Window sort field "${sort.field}" must contain one comparable primitive type.`
+      );
+    }
+  }
+}
+
+function partitionRows(entries, partitionBy) {
+  const partitions = new Map();
+  for (const entry of entries) {
+    const key = partitionBy.length === 0
+      ? "all"
+      : partitionBy.map(field => scalarKey(
+        entry.row[field],
+        `Window partition field "${field}"`
+      )).join("\0");
+    if (!partitions.has(key)) partitions.set(key, []);
+    partitions.get(key).push(entry);
+  }
+  return [...partitions.values()];
+}
+
+function applyOperation(partition, operation, sortBy) {
+  if (operation.op === "rowNumber") {
+    partition.forEach((entry, index) => {
+      entry.row[operation.as] = index + 1;
+    });
+    return;
+  }
+  if (["rank", "denseRank"].includes(operation.op)) {
+    let rank = 1;
+    let denseRank = 1;
+    partition.forEach((entry, index) => {
+      if (
+        index > 0 &&
+        compareEntries(entry, partition[index - 1], sortBy, false) !== 0
+      ) {
+        rank = index + 1;
+        denseRank += 1;
+      }
+      entry.row[operation.as] = operation.op === "rank" ? rank : denseRank;
+    });
+    return;
+  }
+  if (operation.op === "cumulativeSum") {
+    let total = 0;
+    for (const entry of partition) {
+      const value = entry.row[operation.field];
+      if (!Number.isFinite(value)) {
+        throw new TypeError(
+          `Window cumulativeSum field "${operation.field}" must contain finite numbers.`
+        );
+      }
+      total += value;
+      entry.row[operation.as] = total;
+    }
+    return;
+  }
+  const direction = operation.op === "lag" ? -1 : 1;
+  partition.forEach((entry, index) => {
+    const peer = partition[index + direction * operation.offset];
+    entry.row[operation.as] = peer === undefined
+      ? operation.default
+      : peer.row[operation.field];
+  });
+}
+
+export function deriveWindowRows(rows, transform) {
+  if (!Array.isArray(rows)) {
+    throw new TypeError("Window source rows must be an array.");
+  }
+  if (!rows.every(isPlainObject)) {
+    throw new TypeError("Window source rows must be plain objects.");
+  }
+  validateWindowTransform(transform);
+  validateSourceFields(rows, transform);
+  const entries = rows.map((row, index) => ({ index, row: { ...row } }));
+  const partitions = partitionRows(entries, transform.partitionBy);
+  for (const partition of partitions) {
+    validatePartitionSortValues(partition, transform);
+    partition.sort((left, right) => compareEntries(left, right, transform.sortBy));
+  }
+  for (const operation of transform.operations) {
+    for (const partition of partitions) {
+      applyOperation(partition, operation, transform.sortBy);
+    }
+  }
+  entries.sort((left, right) => left.index - right.index);
+  return cloneAndFreeze(entries.map(entry => entry.row));
+}

package/src/layout/labels.js

@@ -0,0 +1,270 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { resolveTextBounds } from "../core/textMetrics.js";
+import {
+  validateNonNegativeFinite,
+  validateOptionObject
+} from "../core/validation.js";
+
+const AXES = new Set(["x", "y", "both"]);
+const BOUNDS = new Set(["plot", "canvas"]);
+const POLICY_OPTIONS = Object.freeze([
+  "axis", "padding", "maxDisplacement", "bounds"
+]);
+
+export const DEFAULT_LABEL_LAYOUT_GEOMETRY = cloneAndFreeze({
+  axis: "both",
+  padding: 3,
+  maxDisplacement: 48,
+  bounds: "plot"
+});
+
+export function normalizeLabelLayoutGeometry(options = {}) {
+  validateOptionObject(options, POLICY_OPTIONS, "label layout");
+  const normalized = {
+    ...DEFAULT_LABEL_LAYOUT_GEOMETRY,
+    ...options
+  };
+  if (!AXES.has(normalized.axis)) {
+    throw new Error(`Unsupported label layout axis "${normalized.axis}".`);
+  }
+  if (!BOUNDS.has(normalized.bounds)) {
+    throw new Error(`Unsupported label layout bounds "${normalized.bounds}".`);
+  }
+  validateNonNegativeFinite(normalized.padding, "Label layout padding");
+  validateNonNegativeFinite(
+    normalized.maxDisplacement,
+    "Label layout maxDisplacement"
+  );
+  return cloneAndFreeze(normalized);
+}
+
+function validateBounds(bounds) {
+  if (
+    !isPlainObject(bounds) ||
+    ![bounds.left, bounds.right, bounds.top, bounds.bottom].every(Number.isFinite) ||
+    bounds.right <= bounds.left ||
+    bounds.bottom <= bounds.top
+  ) {
+    throw new RangeError("Label layout requires ordered finite bounds.");
+  }
+}
+
+function validateItem(item, ids) {
+  if (!isPlainObject(item)) {
+    throw new TypeError("Label layout items must be plain objects.");
+  }
+  if (typeof item.id !== "string" || item.id.length === 0 || ids.has(item.id)) {
+    throw new TypeError("Label layout items require unique non-empty ids.");
+  }
+  if (
+    ![item.x, item.y, item.sourceX, item.sourceY, item.fontSize]
+      .every(Number.isFinite) ||
+    item.fontSize <= 0 ||
+    typeof item.text !== "string" ||
+    item.text.length === 0
+  ) {
+    throw new TypeError(
+      "Label layout items require text, positive fontSize, and finite geometry."
+    );
+  }
+  ids.add(item.id);
+}
+
+function expanded(bounds, padding) {
+  const half = padding / 2;
+  return {
+    left: bounds.left - half,
+    right: bounds.right + half,
+    top: bounds.top - half,
+    bottom: bounds.bottom + half
+  };
+}
+
+function intersectionArea(first, second) {
+  const width = Math.min(first.right, second.right) -
+    Math.max(first.left, second.left);
+  const height = Math.min(first.bottom, second.bottom) -
+    Math.max(first.top, second.top);
+  return width > 0 && height > 0 ? width * height : 0;
+}
+
+function overflow(bounds, boundary) {
+  return Math.max(0, boundary.left - bounds.left) +
+    Math.max(0, bounds.right - boundary.right) +
+    Math.max(0, boundary.top - bounds.top) +
+    Math.max(0, bounds.bottom - boundary.bottom);
+}
+
+export function enumerateLabelOffsets({ axis, padding, maxDisplacement }) {
+  const policy = normalizeLabelLayoutGeometry({ axis, padding, maxDisplacement });
+  const step = Math.max(2, policy.padding);
+  const limit = Math.ceil(policy.maxDisplacement / step);
+  const candidates = [];
+  for (let x = -limit; x <= limit; x += 1) {
+    for (let y = -limit; y <= limit; y += 1) {
+      if (policy.axis === "x" && y !== 0) continue;
+      if (policy.axis === "y" && x !== 0) continue;
+      const offset = { x: x * step, y: y * step };
+      const distanceSquared = offset.x ** 2 + offset.y ** 2;
+      if (Math.sqrt(distanceSquared) > policy.maxDisplacement + 1e-9) continue;
+      candidates.push({ ...offset, distanceSquared });
+    }
+  }
+  candidates.sort((first, second) =>
+    first.distanceSquared - second.distanceSquared ||
+    Math.abs(first.x) - Math.abs(second.x) ||
+    first.y - second.y ||
+    second.x - first.x
+  );
+  return cloneAndFreeze(candidates);
+}
+
+function textBounds(item, offset = { x: 0, y: 0 }) {
+  return resolveTextBounds({
+    x: item.x + offset.x,
+    y: item.y + offset.y,
+    text: item.text,
+    fontSize: item.fontSize,
+    textAlign: item.textAlign,
+    textBaseline: item.textBaseline,
+    rotation: item.rotation
+  });
+}
+
+function candidateScore(bounds, boundary, placed, candidate, order) {
+  return {
+    outside: overflow(bounds, boundary),
+    overlap: placed.reduce(
+      (area, prior) => area + intersectionArea(bounds, prior),
+      0
+    ),
+    distanceSquared: candidate.distanceSquared,
+    order
+  };
+}
+
+function compareScore(first, second) {
+  return Number(first.outside > 0) - Number(second.outside > 0) ||
+    first.outside - second.outside ||
+    first.overlap - second.overlap ||
+    first.distanceSquared - second.distanceSquared ||
+    first.order - second.order;
+}
+
+function overlapPairs(items) {
+  const pairs = [];
+  for (let first = 0; first < items.length; first += 1) {
+    for (let second = first + 1; second < items.length; second += 1) {
+      if (
+        intersectionArea(
+          items[first].collisionBounds,
+          items[second].collisionBounds
+        ) > 0
+      ) {
+        pairs.push([items[first].id, items[second].id]);
+      }
+    }
+  }
+  return pairs;
+}
+
+export function resolveLabelLayout({ items, bounds, ...options } = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError("Label layout requires an item array.");
+  }
+  validateBounds(bounds);
+  const policy = normalizeLabelLayoutGeometry(options);
+  const ids = new Set();
+  for (const item of items) validateItem(item, ids);
+  const candidates = enumerateLabelOffsets(policy);
+  const base = items.map(item => ({
+    id: item.id,
+    collisionBounds: expanded(textBounds(item), policy.padding)
+  }));
+  const placed = [];
+  const resolved = [];
+  for (const item of items) {
+    let best;
+    for (const [order, candidate] of candidates.entries()) {
+      const boundsAtCandidate = textBounds(item, candidate);
+      const collisionBounds = expanded(boundsAtCandidate, policy.padding);
+      const score = candidateScore(
+        collisionBounds,
+        bounds,
+        placed,
+        candidate,
+        order
+      );
+      if (best === undefined || compareScore(score, best.score) < 0) {
+        best = { candidate, bounds: boundsAtCandidate, collisionBounds, score };
+      }
+      if (score.outside === 0 && score.overlap === 0) break;
+    }
+    const resolvedItem = {
+      ...item,
+      baseX: item.x,
+      baseY: item.y,
+      x: item.x + best.candidate.x,
+      y: item.y + best.candidate.y,
+      dx: best.candidate.x,
+      dy: best.candidate.y,
+      distance: Math.sqrt(best.candidate.distanceSquared),
+      bounds: best.bounds,
+      collisionBounds: best.collisionBounds
+    };
+    placed.push(resolvedItem.collisionBounds);
+    resolved.push(resolvedItem);
+  }
+  const beforePairs = overlapPairs(base);
+  const afterPairs = overlapPairs(resolved);
+  const outside = resolved
+    .filter(item => overflow(item.collisionBounds, bounds) > 0)
+    .map(item => item.id);
+  const warnings = [];
+  if (afterPairs.length > 0) warnings.push({ code: "overlap", pairs: afterPairs });
+  if (outside.length > 0) warnings.push({ code: "bounds", items: outside });
+  return cloneAndFreeze({
+    items: resolved,
+    overlapBefore: beforePairs.length,
+    overlapAfter: afterPairs.length,
+    warnings
+  });
+}
+
+function contains(bounds, point) {
+  return point.x >= bounds.left && point.x <= bounds.right &&
+    point.y >= bounds.top && point.y <= bounds.bottom;
+}
+
+export function resolveLabelLeader(item) {
+  if (!isPlainObject(item) || ![item.dx, item.dy].every(Number.isFinite)) {
+    throw new TypeError("Label leader requires a resolved label item.");
+  }
+  if (item.dx === 0 && item.dy === 0) return undefined;
+  const source = { x: item.sourceX, y: item.sourceY };
+  if (contains(item.bounds, source)) return undefined;
+  const center = {
+    x: (item.bounds.left + item.bounds.right) / 2,
+    y: (item.bounds.top + item.bounds.bottom) / 2
+  };
+  const dx = center.x - source.x;
+  const dy = center.y - source.y;
+  const enterX = dx > 0
+    ? (item.bounds.left - source.x) / dx
+    : dx < 0
+      ? (item.bounds.right - source.x) / dx
+      : 0;
+  const enterY = dy > 0
+    ? (item.bounds.top - source.y) / dy
+    : dy < 0
+      ? (item.bounds.bottom - source.y) / dy
+      : 0;
+  const ratio = Math.max(0, Math.min(1, Math.max(enterX, enterY)));
+  return cloneAndFreeze({
+    id: item.id,
+    x1: source.x,
+    y1: source.y,
+    x2: source.x + dx * ratio,
+    y2: source.y + dy * ratio
+  });
+}

package/src/layout/text.js

@@ -1,6 +1,9 @@
 import { measureTextWidth } from "../core/textMetrics.js";
 
-export { measureTextWidth } from "../core/textMetrics.js";
+export {
+  measureTextWidth,
+  resolveTextBounds
+} from "../core/textMetrics.js";
 
 function wrapCodePoints(text, maxWidth, style) {
   const lines = [];

package/src/layout/title.js

@@ -1,4 +1,4 @@
-import { measureTextWidth, wrapText } from "./text.js";
+import { measureTextWidth, resolveTextBounds, wrapText } from "./text.js";
 
 function lineCenters(lines, style, lineHeight, start) {
   return lines.map((_, index) => start + style.fontSize / 2 + index * lineHeight);
@@ -62,25 +62,15 @@ export function alignedTextAnchor(start, length, align) {
 }
 
 function axisAlignedTextBounds({ x, y, text, style, align, rotation }) {
-  const width = measureTextWidth(text, style);
-  const left = align === "left" ? 0 : align === "center" ? -width / 2 : -width;
-  const right = left + width;
-  const top = -style.fontSize / 2;
-  const bottom = style.fontSize / 2;
-  const cosine = Math.cos(rotation);
-  const sine = Math.sin(rotation);
-  const corners = [
-    [left, top], [right, top], [right, bottom], [left, bottom]
-  ].map(([localX, localY]) => ({
-    x: x + localX * cosine - localY * sine,
-    y: y + localX * sine + localY * cosine
-  }));
-  return {
-    left: Math.min(...corners.map(point => point.x)),
-    right: Math.max(...corners.map(point => point.x)),
-    top: Math.min(...corners.map(point => point.y)),
-    bottom: Math.max(...corners.map(point => point.y))
-  };
+  return resolveTextBounds({
+    x,
+    y,
+    text,
+    ...style,
+    textAlign: align,
+    textBaseline: "middle",
+    rotation
+  });
 }
 
 function unionBounds(bounds) {

package/src/materialization/bars/aggregate.js

@@ -13,7 +13,7 @@ import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues,
   mapSequentialColors
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import {
   DEFAULT_BAR_FILL,
   DEFAULT_BAR_STROKE,

package/src/materialization/bars/grouped.js

@@ -2,7 +2,7 @@ import { deriveBarAggregates } from "../../grammar/bars/aggregate.js";
 import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { sameOrderedValues } from "../../core/validation.js";
 import {
   DEFAULT_BAR_STROKE,

package/src/materialization/bars/histogram.js

@@ -8,7 +8,7 @@ import {
   mapOrdinalValues,
   readNominalField,
   readQuantitativeField
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { resolveBarColorLayout } from "../../grammar/bars/policy.js";
 import { layoutSeriesPartition } from "../../grammar/seriesLayout.js";
 import {

package/src/materialization/bars/ranged.js

@@ -1,4 +1,4 @@
-import { mapContinuousScaleValues, mapOrdinalPositionValues, mapOrdinalValues } from "../../grammar/scales.js";
+import { mapContinuousScaleValues, mapOrdinalPositionValues, mapOrdinalValues } from "../../grammar/scales/index.js";
 import { resolveBarWidth } from "../../grammar/bars/geometry.js";
 import { DEFAULT_BAR_FILL, DEFAULT_BAR_STROKE, DEFAULT_BAR_STROKE_WIDTH } from "./resolve.js";