ggaction 0.0.3 → 0.0.4

package/src/materialization/facetGuides/preparation.js

@@ -0,0 +1,188 @@
+import {
+  unionConcreteGraphicBounds
+} from "../../grammar/schemas/graphicBounds.js";
+import {
+  resolveSharedFacetLegends
+} from "../../grammar/facets/guides.js";
+import { findLayer } from "../../selectors/layers.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+import { allLegendGraphicIds } from "../guides/resources.js";
+import { DEFAULT_COLORS } from "../../theme/defaults.js";
+import { resolveLegacyCategoricalLegend } from "./legacyCategorical.js";
+
+const LEGEND_SOURCE_CANVAS = Object.freeze({
+  width: 640,
+  height: 400,
+  margin: Object.freeze({ top: 40, right: 170, bottom: 60, left: 70 })
+});
+
+export function legendKinds(program) {
+  return Object.keys(program.guideConfigs.legend ?? {});
+}
+
+function legendCandidates(program) {
+  const layers = program.semanticSpec.layers;
+  const color = layers.filter(layer => {
+    const encoding = layer.encoding?.color;
+    return encoding?.scale !== undefined &&
+      findSemanticScale(program, encoding.scale) !== undefined;
+  });
+  if (color.length === 1) {
+    const layer = color[0];
+    return {
+      target: layer.id,
+      channels: ["color", "shape", "strokeDash"].filter(
+        channel => layer.encoding?.[channel]?.scale !== undefined
+      )
+    };
+  }
+  if (color.length > 1) {
+    throw new Error(
+      "Shared facet legend requires one unambiguous color legend target."
+    );
+  }
+  for (const channel of ["shape", "strokeDash", "size", "opacity"]) {
+    const candidates = layers.filter(
+      layer => layer.encoding?.[channel]?.scale !== undefined
+    );
+    if (candidates.length === 1) {
+      return { target: candidates[0].id, channels: [channel] };
+    }
+    if (candidates.length > 1) {
+      throw new Error(
+        `Shared facet legend requires one unambiguous ${channel} legend target.`
+      );
+    }
+  }
+  throw new Error("Shared facet legend requires one eligible encoded scale.");
+}
+
+function compactNumber(value) {
+  if (Math.abs(value) >= 1_000_000_000) {
+    return `${+(value / 1_000_000_000).toFixed(1)}B`;
+  }
+  if (Math.abs(value) >= 1_000_000) {
+    return `${Math.round(value / 1_000_000)}M`;
+  }
+  if (Math.abs(value) >= 1_000) {
+    return `${Math.round(value / 1_000)}K`;
+  }
+  return String(+value.toPrecision(3));
+}
+
+function continuousValues(domain, count) {
+  return Array.from(
+    { length: count },
+    (_, index) => domain[0] + index / (count - 1) * (domain[1] - domain[0])
+  );
+}
+
+function prepareAutoLegendSource(child) {
+  const request = legendCandidates(child);
+  const canvas = child.graphicSpec.objects.canvas;
+  let source = child
+    ._withCanvasConfig({
+      margin: LEGEND_SOURCE_CANVAS.margin,
+      size: { width: "explicit", height: "explicit" }
+    })
+    .editGraphics({
+      target: "canvas",
+      property: "width",
+      value: LEGEND_SOURCE_CANVAS.width
+    })
+    .editGraphics({
+      target: "canvas",
+      property: "height",
+      value: LEGEND_SOURCE_CANVAS.height
+    });
+  if (canvas?.properties.background !== undefined) {
+    source = source.editGraphics({
+      target: "canvas",
+      property: "background",
+      value: canvas.properties.background
+    });
+  }
+  const scale = findSemanticScale(
+    source,
+    findLayer(source, request.target)?.encoding?.color?.scale
+  );
+  const gradient = scale?.type === "sequential";
+  source = source.createLegend({
+    target: request.target,
+    channels: request.channels,
+    ...(gradient ? {
+      count: 5,
+      gradient: { length: 180, thickness: 12 },
+      labels: { offset: 9, fontSize: 10 },
+      titleStyle: { color: DEFAULT_COLORS.strongText, fontSize: 11 }
+    } : {})
+  });
+  if (gradient) {
+    const resolved = source.resolvedScales[scale.id];
+    source = source
+      .editGraphics({
+        target: "colorGradientLabels",
+        property: "text",
+        value: continuousValues(resolved.domain, 5).map(compactNumber)
+      })
+      .editGraphics({
+        target: "colorGradientTitle",
+        property: "y",
+        value: source.graphicSpec.objects.colorGradientTitle.properties.y + 8
+      });
+  }
+  return source;
+}
+
+function compatibleLegendChildren(program, source, inferred) {
+  return program.compositionSpec.children.map(id => {
+    const child = program.children[id];
+    return {
+      id,
+      guideConfigs: inferred ? source.guideConfigs : child.guideConfigs,
+      resolvedScales: child.resolvedScales
+    };
+  });
+}
+
+export function prepareSharedFacetLegend(program) {
+  if (program.compositionSpec.facet.guides.legend !== "shared") {
+    return undefined;
+  }
+  const firstId = program.compositionSpec.children[0];
+  const first = program.children[firstId];
+  const inferred = legendKinds(first).length === 0;
+  if (inferred) {
+    const legacy = resolveLegacyCategoricalLegend(program);
+    if (legacy !== undefined) return legacy;
+  }
+  const source = inferred ? prepareAutoLegendSource(first) : first;
+  const kinds = legendKinds(source);
+  const compatibility = resolveSharedFacetLegends(
+    compatibleLegendChildren(program, source, inferred)
+  );
+  const roots = allLegendGraphicIds(kinds).filter(
+    id => source.graphicSpec.objects[id] !== undefined
+  );
+  if (roots.length === 0) {
+    throw new Error("Shared facet legend has no concrete guide graphics.");
+  }
+  const bounds = unionConcreteGraphicBounds(source.graphicSpec, roots);
+  if (bounds === undefined) {
+    throw new Error("Shared facet legend has no measurable concrete bounds.");
+  }
+  const gradient = kinds.includes("gradient");
+  return {
+    mode: "promoted",
+    source,
+    inferred,
+    kinds,
+    roots,
+    bounds,
+    compatibility,
+    reservation: {
+      gap: gradient ? 24 : 18,
+      width: gradient ? 112 : Math.max(132, Math.ceil(bounds.right - bounds.left))
+    }
+  };
+}

package/src/materialization/facets.js

@@ -6,7 +6,7 @@ import {
 } from "../layout/title.js";
 import { resolveFacetLayout } from "../layout/facets.js";
 import { namespaceGraphicSnapshot } from "./compositionSnapshot.js";
-import { prepareSharedFacetLegend } from "./facetGuides.js";
+import { prepareSharedFacetLegend } from "./facetGuides/index.js";
 import {
   attachSnapshotObject,
   clearCompositionChildren,

package/src/materialization/marks/capabilities.js

@@ -0,0 +1,141 @@
+import { findDataset } from "../../selectors/datasets.js";
+import { findLayer } from "../../selectors/layers.js";
+import { isAggregate } from "../../grammar/aggregate.js";
+import {
+  BAR_GRAINS,
+  resolveBarColorLayout,
+  resolveBarOffsetChannel,
+  resolveBarGrain
+} from "../../grammar/bars/policy.js";
+import { resolveRuleMode } from "../../grammar/rules.js";
+import { findUpstreamTransform } from "../dataProvenance.js";
+import { resolveRectMode } from "../../grammar/rects.js";
+
+function hasCartesianPositionScales(layer) {
+  return (
+    layer.encoding?.x?.scale !== undefined &&
+    layer.encoding?.y?.scale !== undefined
+  );
+}
+
+function hasPolarPositionScales(layer) {
+  return (
+    layer.encoding?.theta?.scale !== undefined &&
+    layer.encoding?.radius?.scale !== undefined
+  );
+}
+
+export function canMaterializePoint(_program, layer) {
+  return layer.mark?.type === "point" && (
+    hasCartesianPositionScales(layer) || hasPolarPositionScales(layer)
+  );
+}
+
+export function canMaterializeLine(program, layer) {
+  const dataset = findDataset(program, layer.data);
+  const interval = dataset?.transform?.some(item => item.type === "interval");
+  if (hasPolarPositionScales(layer)) {
+    return (
+      layer.mark?.type === "line" &&
+      ["quantitative", "temporal", "ordinal", "nominal"].includes(
+        layer.encoding.theta.fieldType
+      ) &&
+      layer.encoding.radius.fieldType === "quantitative"
+    );
+  }
+  return (
+    layer.mark?.type === "line" &&
+    hasCartesianPositionScales(layer) &&
+    (isAggregate(layer.encoding.y.aggregate) ||
+      (layer.encoding.x.fieldType === "quantitative" &&
+        layer.encoding.y.fieldType === "quantitative") ||
+      ((interval || layer.encoding.y.aggregate === undefined) &&
+        ["quantitative", "temporal"].includes(layer.encoding.x.fieldType) &&
+        ["quantitative", "temporal"].includes(layer.encoding.y.fieldType) &&
+        layer.encoding.x.fieldType !== layer.encoding.y.fieldType))
+  );
+}
+
+export function canMaterializeArea(program, layer) {
+  if (layer.mark?.type !== "area" || !hasCartesianPositionScales(layer)) {
+    return false;
+  }
+  const dataset = findDataset(program, layer.data);
+  const densityTransform = findUpstreamTransform(program, dataset, "density");
+  const completeDensity =
+    densityTransform !== undefined &&
+    (densityTransform.groupBy === undefined ||
+      layer.encoding?.group?.field === densityTransform.groupBy);
+  return (
+    completeDensity ||
+    layer.encoding?.y2?.scale === layer.encoding.y.scale ||
+    layer.encoding?.x2?.scale === layer.encoding.x.scale
+  );
+}
+
+export function canMaterializeArc(_program, layer) {
+  if (
+    layer.mark?.type !== "arc" ||
+    layer.encoding?.theta?.scale === undefined ||
+    !["nominal", "ordinal"].includes(layer.encoding.theta.fieldType)
+  ) {
+    return false;
+  }
+  if (layer.encoding.theta.aggregate === "count") {
+    return layer.encoding?.radius === undefined;
+  }
+  return (
+    layer.encoding.theta.aggregate === undefined &&
+    layer.encoding?.radius?.scale !== undefined &&
+    layer.encoding.radius.fieldType === "quantitative"
+  );
+}
+
+export function canMaterializeBar(program, layer) {
+  if (layer.mark?.type !== "bar" || !hasCartesianPositionScales(layer)) {
+    return false;
+  }
+  const grain = resolveBarGrain(layer);
+  if (![BAR_GRAINS.histogram, BAR_GRAINS.aggregate, BAR_GRAINS.ranged].includes(grain)) {
+    return false;
+  }
+  if (
+    grain === BAR_GRAINS.aggregate &&
+    resolveBarColorLayout(layer) === "group"
+  ) {
+    const offsetChannel = resolveBarOffsetChannel(layer);
+    return (
+      layer.encoding?.color?.field !== undefined &&
+      layer.encoding?.[offsetChannel]?.field === layer.encoding.color.field &&
+      layer.encoding[offsetChannel].scale !== undefined
+    );
+  }
+  return true;
+}
+
+export function canMaterializeRule(program, layer) {
+  const fixedSpan = program.markConfigs[layer.id]?.fixedSpan;
+  const boxSpanOwner = program.markConfigs[layer.id]?.boxSpanOwner;
+  return layer.mark?.type === "rule" && (
+    resolveRuleMode(layer) !== undefined ||
+    (boxSpanOwner !== undefined && hasCartesianPositionScales(layer)) ||
+    (fixedSpan !== undefined && hasCartesianPositionScales(layer))
+  );
+}
+
+export function canMaterializeText(program, layer) {
+  if (layer.mark?.type !== "text" || layer.encoding?.text === undefined) {
+    return false;
+  }
+  if (layer.source !== undefined) {
+    const source = findLayer(program, layer.source);
+    return source !== undefined &&
+      ["point", "bar", "rule", "rect"].includes(source.mark?.type) &&
+      Array.isArray(program.graphicSpec.objects[source.id]?.items);
+  }
+  return hasCartesianPositionScales(layer);
+}
+
+export function canMaterializeRect(_program, layer) {
+  return resolveRectMode(layer) !== undefined;
+}

package/src/materialization/marks/index.js

@@ -0,0 +1,105 @@
+import { POSITION_CHANNELS } from "../../core/vocabulary.js";
+import { getMarkMaterializationPolicy } from "./policies.js";
+
+export {
+  canMaterializeArc,
+  canMaterializeArea,
+  canMaterializeBar,
+  canMaterializeLine,
+  canMaterializePoint,
+  canMaterializeRect,
+  canMaterializeRule,
+  canMaterializeText
+} from "./capabilities.js";
+
+export function getMarkRematerializationStep(layer) {
+  const policy = getMarkMaterializationPolicy(layer);
+  return policy === undefined
+    ? undefined
+    : { op: policy.op, args: { id: layer.id } };
+}
+
+export function getMarkMaterializationStep(program, layer) {
+  const policy = getMarkMaterializationPolicy(layer);
+  if (policy === undefined || !policy.canMaterialize(program, layer)) {
+    return undefined;
+  }
+  return getMarkRematerializationStep(layer);
+}
+
+export function getSourceDependentMarkSteps(program, sourceId) {
+  return program.semanticSpec.layers.flatMap(layer =>
+    layer.source === sourceId &&
+    getMarkMaterializationPolicy(layer)?.sourceDependent === true
+      ? [getMarkMaterializationStep(program, layer)].filter(
+          step => step !== undefined
+        )
+      : []
+  );
+}
+
+export function getPositionEncodingMaterializationSteps(program, layer, scaleId) {
+  const policy = getMarkMaterializationPolicy(layer);
+  if (policy === undefined) return [];
+  const scale = { op: "rematerializeScale", args: { id: scaleId } };
+  const complete = policy.canMaterialize(program, layer);
+  const mark = getMarkRematerializationStep(layer);
+  if (!complete) {
+    if (policy.positionEncoding.incomplete === "scale") return [scale];
+    return policy.positionEncoding.scaleFirst ? [scale, mark] : [mark];
+  }
+  return policy.positionEncoding.scaleFirst ? [scale, mark] : [mark];
+}
+
+export function getScaleConsumerMaterializationMode(layer, channel) {
+  const policy = getMarkMaterializationPolicy(layer);
+  if (policy === undefined) return "direct";
+  if (POSITION_CHANNELS.includes(channel)) {
+    return policy.scaleApplication.position ?? policy.scaleApplication.default;
+  }
+  if (policy.scaleApplication.deferredChannels?.includes(channel)) {
+    return "defer";
+  }
+  return policy.scaleApplication.default;
+}
+
+export function canDeferScaleConsumerApplication(layer) {
+  return getMarkMaterializationPolicy(layer)?.scaleApplication.deferWithMark === true;
+}
+
+export function getExistingMarkRematerializationStep(program, layer) {
+  const policy = getMarkMaterializationPolicy(layer);
+  if (
+    policy?.rematerializeIncompleteExisting !== true ||
+    program.graphicSpec.objects[layer.id] === undefined
+  ) {
+    return undefined;
+  }
+  return getMarkRematerializationStep(layer);
+}
+
+export function getEncodingMaterializationStages(program, layer, channel, scale) {
+  const policy = getMarkMaterializationPolicy(layer);
+  if (policy === undefined) return { scales: [], marks: [] };
+  const scales = policy.encoding?.scaleFirst === true && scale !== undefined
+    ? [{
+        op: "rematerializeScale",
+        args: { id: scale, guides: false, marks: false }
+      }]
+    : [];
+  const shared = policy.encoding?.sharedChannels?.includes(channel) === true &&
+    scale !== undefined;
+  const candidates = shared
+    ? program.semanticSpec.layers.filter(candidate =>
+        candidate.mark?.type === layer.mark?.type &&
+        candidate.encoding?.[channel]?.scale === scale
+      )
+    : [layer];
+  const marks = candidates.flatMap(candidate => {
+    const step = policy.encoding?.completeOnly === true
+      ? getMarkMaterializationStep(program, candidate)
+      : getMarkRematerializationStep(candidate);
+    return step === undefined ? [] : [step];
+  });
+  return { scales, marks };
+}

package/src/materialization/marks/policies.js

@@ -0,0 +1,87 @@
+import {
+  canMaterializeArc,
+  canMaterializeArea,
+  canMaterializeBar,
+  canMaterializeLine,
+  canMaterializePoint,
+  canMaterializeRect,
+  canMaterializeRule,
+  canMaterializeText
+} from "./capabilities.js";
+
+const MARK_MATERIALIZATION_POLICIES = Object.freeze({
+  point: Object.freeze({
+    canMaterialize: canMaterializePoint,
+    op: "rematerializePointMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      deferredChannels: Object.freeze(["size", "shape"]),
+      default: "direct"
+    }),
+    rematerializeIncompleteExisting: true
+  }),
+  line: Object.freeze({
+    canMaterialize: canMaterializeLine,
+    op: "rematerializeLineMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  area: Object.freeze({
+    canMaterialize: canMaterializeArea,
+    op: "rematerializeAreaMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
+    encoding: Object.freeze({ sharedChannels: Object.freeze(["color"]) }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  arc: Object.freeze({
+    canMaterialize: canMaterializeArc,
+    op: "rematerializeArcMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    encoding: Object.freeze({ completeOnly: true }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  bar: Object.freeze({
+    canMaterialize: canMaterializeBar,
+    op: "rematerializeBarMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  rule: Object.freeze({
+    canMaterialize: canMaterializeRule,
+    op: "rematerializeRuleMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  text: Object.freeze({
+    canMaterialize: canMaterializeText,
+    op: "rematerializeTextMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      default: "defer"
+    }),
+    rematerializeIncompleteExisting: true,
+    sourceDependent: true
+  }),
+  rect: Object.freeze({
+    canMaterialize: canMaterializeRect,
+    op: "rematerializeRectMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      default: "defer"
+    }),
+    rematerializeIncompleteExisting: true
+  })
+});
+
+export function getMarkMaterializationPolicy(layer) {
+  return MARK_MATERIALIZATION_POLICIES[layer.mark?.type];
+}

package/src/materialization/rect.js

@@ -1,7 +1,7 @@
 import {
   mapOrdinalPositionValues,
   readScaleField
-} from "../grammar/scales.js";
+} from "../grammar/scales/index.js";
 import { RECT_MODES, resolveRectMode } from "../grammar/rects.js";
 import { DEFAULT_RECT_MARK } from "./rectConfig.js";
 import { mapScaleConsumerValues } from "./scales/map.js";

package/src/materialization/rowEncoding.js

@@ -5,7 +5,7 @@ import {
   readQuantitativeField,
   readScaleField,
   readTemporalField
-} from "../grammar/scales.js";
+} from "../grammar/scales/index.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
 export function resolveRowEncodingValues(program, layer, dataset, channel) {

package/src/materialization/scaleGuideDependencies.js

@@ -0,0 +1,94 @@
+import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
+import { materializedLegendUsesScale } from "./legends.js";
+import { buildMaterializationPlan } from "./planner.js";
+
+const CARTESIAN_AXES = Object.freeze([
+  Object.freeze({ channel: "x", prefix: "X", lineObject: "xAxisLine" }),
+  Object.freeze({ channel: "y", prefix: "Y", lineObject: "yAxisLine" })
+]);
+const POLAR_AXES = Object.freeze([
+  Object.freeze({ channel: "theta", prefix: "Theta" }),
+  Object.freeze({ channel: "radius", prefix: "Radial" })
+]);
+const GRIDS = Object.freeze([
+  Object.freeze({ role: "horizontal", op: "rematerializeHorizontalGrid" }),
+  Object.freeze({ role: "vertical", op: "rematerializeVerticalGrid" }),
+  Object.freeze({ role: "theta", op: "rematerializeThetaGrid" }),
+  Object.freeze({ role: "radial", op: "rematerializeRadialGrid" })
+]);
+
+function usesPositionalScale(program, id) {
+  return program.semanticSpec.layers.some(layer =>
+    POSITION_ENCODING_CHANNELS.some(
+      channel => layer.encoding?.[channel]?.scale === id
+    )
+  );
+}
+
+function usesRadialScale(program, id) {
+  return program.semanticSpec.layers.some(layer =>
+    layer.encoding?.radius?.scale === id
+  );
+}
+
+function semanticGuideUsesScale(program, id) {
+  return [
+    ...CARTESIAN_AXES.map(({ channel }) =>
+      program.semanticSpec.guides.axis?.[channel]
+    ),
+    ...POLAR_AXES.map(({ channel }) =>
+      program.semanticSpec.guides.axis?.[channel]
+    ),
+    ...GRIDS.map(({ role }) => program.semanticSpec.guides.grid?.[role])
+  ].some(guide => guide?.scale === id);
+}
+
+export function needsCanvasScaleRematerialization(program, scale) {
+  return (
+    (scale.range === "auto" ||
+      usesRadialScale(program, scale.id) ||
+      semanticGuideUsesScale(program, scale.id)) &&
+    program.resolvedScales[scale.id] !== undefined &&
+    usesPositionalScale(program, scale.id)
+  );
+}
+
+function componentEditOperation(prefix, component) {
+  const suffix = component[0].toUpperCase() + component.slice(1);
+  return `edit${prefix}Axis${suffix}`;
+}
+
+export function planScaleGuideRematerialization(program, id) {
+  const guides = [];
+  const objects = program.graphicSpec?.objects ?? {};
+  const guideConfigs = program.guideConfigs ?? {};
+  for (const axis of CARTESIAN_AXES) {
+    if (
+      objects[axis.lineObject] &&
+      program.semanticSpec.guides.axis?.[axis.channel]?.scale === id
+    ) {
+      guides.push({ op: componentEditOperation(axis.prefix, "line") });
+    }
+    for (const component of ["ticks", "labels", "title"]) {
+      if (guideConfigs.axis?.[axis.channel]?.[component]?.scale === id) {
+        guides.push({ op: componentEditOperation(axis.prefix, component) });
+      }
+    }
+  }
+  for (const axis of POLAR_AXES) {
+    for (const component of ["line", "ticks", "labels", "title"]) {
+      if (guideConfigs.axis?.[axis.channel]?.[component]?.scale === id) {
+        guides.push({ op: componentEditOperation(axis.prefix, component) });
+      }
+    }
+  }
+  for (const grid of GRIDS) {
+    if (guideConfigs.grid?.[grid.role]?.scale === id) {
+      guides.push({ op: grid.op });
+    }
+  }
+  if (materializedLegendUsesScale(program, id)) {
+    guides.push({ op: "rematerializeLegend" });
+  }
+  return buildMaterializationPlan({ guides });
+}

package/src/materialization/scales/map.js

@@ -6,7 +6,7 @@ import {
   mapDiscretizedColors,
   mapOrdinalValues,
   mapSequentialColors
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 
 export function mapScaleConsumerValues(values, resolvedScale, channel) {
   if (channel === "color" && isDiscretizedColorScaleType(resolvedScale.type)) {

package/src/materialization/scales/policies/series.js

@@ -2,7 +2,7 @@ import {
   isTransformedScaleType,
   resolveContinuousDomain,
   resolveTransformedDomain
-} from "../../../grammar/scales.js";
+} from "../../../grammar/scales/index.js";
 
 export function resolveSeriesLayoutDomain({
   id,

package/src/materialization/scales/resolve.js

@@ -24,7 +24,7 @@ import {
   validateOrdinalScaleType,
   validateScaleTypeForRole,
   validateTimeScaleType
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { resolveArcAutoPositionRange } from "./policies/arc.js";
 import {
   resolveBinnedBarDomain,

package/src/materialization/selection/items/bar.js

@@ -10,7 +10,7 @@ import { layoutSeriesPartition } from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
   readTemporalField
-} from "../../../grammar/scales.js";
+} from "../../../grammar/scales/index.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 import { deriveHistogramSegments } from "../../bars/histogram.js";
 import {