@ggts-sh/spec 0.43.0

package/src/scale-helpers.ts

@@ -0,0 +1,264 @@
+/**
+ * Scale authoring helpers facade — position, color/fill, and style families.
+ *
+ * Implementation:
+ *  - scale-position-helpers.ts — temporal, discrete, continuous, binned, reverse
+ *  - scale-color-helpers.ts — generic color/fill + ColorBrewer + configuredColorScaleType
+ *  - scale-color-viridis.ts / scale-color-stops.ts / scale-color-hue-grey.ts — palette families
+ *  - scale-style-helpers.ts — numeric and finite-symbol style families
+ *  - scale-multi-helpers.ts — multi-aes identity/manual + scaleType (#833)
+ *
+ * Public package imports continue through this module for stable paths.
+ */
+
+export {
+  scaleXDate,
+  scaleXDatetime,
+  scaleXTime,
+  scaleYDate,
+  scaleYDatetime,
+  scaleYTime,
+  scaleXMonthDay,
+  scaleYMonthDay,
+  scaleXDiscrete,
+  scaleYDiscrete,
+  scale_x_date,
+  scale_x_datetime,
+  scale_x_time,
+  scale_y_date,
+  scale_y_datetime,
+  scale_y_time,
+  scale_x_month_day,
+  scale_y_month_day,
+  scale_x_discrete,
+  scale_y_discrete,
+  scaleXContinuous,
+  scaleYContinuous,
+  scaleXLog10,
+  scaleYLog10,
+  scaleXSqrt,
+  scaleYSqrt,
+  scaleXReverse,
+  scaleYReverse,
+  scaleXBinned,
+  scaleYBinned,
+  scale_x_continuous,
+  scale_y_continuous,
+  scale_x_log10,
+  scale_y_log10,
+  scale_x_sqrt,
+  scale_y_sqrt,
+  scale_x_reverse,
+  scale_y_reverse,
+  scale_x_binned,
+  scale_y_binned,
+  type TemporalScaleOptions,
+  type ContinuousPositionScaleOptions,
+  type TransformedPositionScaleOptions,
+  type DiscretePositionScaleOptions,
+} from "./scale-position-helpers.js";
+
+export {
+  configuredColorScaleType,
+  scaleColorContinuous,
+  scaleColorDiscrete,
+  scaleColorBinned,
+  scaleColorLog10,
+  scaleColorSqrt,
+  scaleColorDate,
+  scaleColorDatetime,
+  scaleColorManual,
+  scaleColorIdentity,
+  scaleColorBrewer,
+  scaleColorDistiller,
+  scaleColorFermenter,
+  scaleColourContinuous,
+  scaleColourDiscrete,
+  scaleColourBinned,
+  scaleColourLog10,
+  scaleColourSqrt,
+  scaleColourDate,
+  scaleColourDatetime,
+  scaleColourManual,
+  scaleColourIdentity,
+  scaleColourBrewer,
+  scaleColourDistiller,
+  scaleColourFermenter,
+  scale_color_continuous,
+  scale_color_discrete,
+  scale_color_binned,
+  scale_color_log10,
+  scale_color_sqrt,
+  scale_color_date,
+  scale_color_datetime,
+  scale_color_manual,
+  scale_color_identity,
+  scale_color_brewer,
+  scale_color_distiller,
+  scale_color_fermenter,
+  scale_colour_continuous,
+  scale_colour_discrete,
+  scale_colour_binned,
+  scale_colour_log10,
+  scale_colour_sqrt,
+  scale_colour_date,
+  scale_colour_datetime,
+  scale_colour_manual,
+  scale_colour_identity,
+  scale_colour_brewer,
+  scale_colour_distiller,
+  scale_colour_fermenter,
+  scaleFillContinuous,
+  scaleFillDiscrete,
+  scaleFillBinned,
+  scaleFillLog10,
+  scaleFillSqrt,
+  scaleFillDate,
+  scaleFillDatetime,
+  scaleFillManual,
+  scaleFillIdentity,
+  scaleFillBrewer,
+  scaleFillDistiller,
+  scaleFillFermenter,
+  scale_fill_continuous,
+  scale_fill_discrete,
+  scale_fill_binned,
+  scale_fill_log10,
+  scale_fill_sqrt,
+  scale_fill_date,
+  scale_fill_datetime,
+  scale_fill_manual,
+  scale_fill_identity,
+  scale_fill_brewer,
+  scale_fill_distiller,
+  scale_fill_fermenter,
+  type ColorScaleOptions,
+  type SequentialColorScaleOptions,
+  type BinnedColorScaleOptions,
+  type DiscreteColorScaleOptions,
+  type TransformedColorScaleOptions,
+  type TemporalColorScaleOptions,
+  type ManualColorScaleOptions,
+  type IdentityColorScaleOptions,
+  type ColorBrewerScaleOptions,
+  type ColorDistillerScaleOptions,
+  type ColorFermenterScaleOptions,
+} from "./scale-color-helpers.js";
+
+export {
+  scaleColorViridisC,
+  scaleColorViridisD,
+  scaleColorViridisB,
+  scaleColourViridisC,
+  scaleColourViridisD,
+  scaleColourViridisB,
+  scaleFillViridisC,
+  scaleFillViridisD,
+  scaleFillViridisB,
+  scale_color_viridis_c,
+  scale_color_viridis_d,
+  scale_color_viridis_b,
+  scale_colour_viridis_c,
+  scale_colour_viridis_d,
+  scale_colour_viridis_b,
+  scale_fill_viridis_c,
+  scale_fill_viridis_d,
+  scale_fill_viridis_b,
+  type ViridisScaleOptions,
+  type ViridisOptionName,
+} from "./scale-color-viridis.js";
+
+export {
+  scaleColorSteps,
+  scaleColorSteps2,
+  scaleColorStepsn,
+  scaleColorGradient,
+  scaleColorGradient2,
+  scaleColorGradientn,
+  scaleColourSteps,
+  scaleColourSteps2,
+  scaleColourStepsn,
+  scaleColourGradient,
+  scaleColourGradient2,
+  scaleColourGradientn,
+  scaleFillSteps,
+  scaleFillSteps2,
+  scaleFillStepsn,
+  scaleFillGradient,
+  scaleFillGradient2,
+  scaleFillGradientn,
+  scale_color_steps,
+  scale_color_steps2,
+  scale_color_stepsn,
+  scale_color_gradient,
+  scale_color_gradient2,
+  scale_color_gradientn,
+  scale_colour_steps,
+  scale_colour_steps2,
+  scale_colour_stepsn,
+  scale_colour_gradient,
+  scale_colour_gradient2,
+  scale_colour_gradientn,
+  scale_fill_steps,
+  scale_fill_steps2,
+  scale_fill_stepsn,
+  scale_fill_gradient,
+  scale_fill_gradient2,
+  scale_fill_gradientn,
+  type StepsScaleOptions,
+  type Steps2ScaleOptions,
+  type StepsnScaleOptions,
+  type GradientScaleOptions,
+  type Gradient2ScaleOptions,
+  type GradientnScaleOptions,
+} from "./scale-color-stops.js";
+
+export {
+  scaleColorHue,
+  scaleColorGrey,
+  scaleColorGray,
+  scaleColorOrdinal,
+  scaleColourHue,
+  scaleColourGrey,
+  scaleColourGray,
+  scaleColourOrdinal,
+  scaleFillHue,
+  scaleFillGrey,
+  scaleFillGray,
+  scaleFillOrdinal,
+  scale_color_hue,
+  scale_color_grey,
+  scale_color_gray,
+  scale_color_ordinal,
+  scale_colour_hue,
+  scale_colour_grey,
+  scale_colour_gray,
+  scale_colour_ordinal,
+  scale_fill_hue,
+  scale_fill_grey,
+  scale_fill_gray,
+  scale_fill_ordinal,
+  type HueScaleOptions,
+  type GreyScaleOptions,
+  type OrdinalColorScaleOptions,
+} from "./scale-color-hue-grey.js";
+
+export * from "./scale-style-helpers.js";
+
+export {
+  scaleContinuousIdentity,
+  scaleDiscreteIdentity,
+  scaleDiscreteManual,
+  scaleType,
+  scale_continuous_identity,
+  scale_discrete_identity,
+  scale_discrete_manual,
+  scale_type,
+  canonicalMultiScaleChannel,
+  type MultiScaleAesthetic,
+  type MultiScaleChannel,
+  type MultiIdentityScaleOptions,
+  type MultiManualScaleOptions,
+  type ScaleTypeAesthetic,
+  type RecommendedScaleType,
+} from "./scale-multi-helpers.js";

package/src/scale-multi-helpers.ts

@@ -0,0 +1,220 @@
+/**
+ * Multi-aesthetic scale helpers (#833) — ggplot2 scale_*_identity /
+ * scale_discrete_manual ergonomics over PortableSpec's per-channel `scales`.
+ *
+ * Helpers expand to a `Scales` object with the same config on each requested
+ * aesthetic (British "colour" → "color"). No new PortableSpec branch: the
+ * expanded object is what normalize/validate already understand.
+ *
+ * `scaleType` is a small registry for agent/tooling default selection — not
+ * an R S3 generic (agent tooling).
+ */
+
+import type { CellValue, Scales } from "./schema.js";
+import type { ProfileFieldType } from "./validate-data.js";
+
+/** Aesthetics accepted by multi-aes identity/manual helpers (not x/y). */
+export type MultiScaleAesthetic =
+  | "color"
+  | "colour"
+  | "fill"
+  | "size"
+  | "linewidth"
+  | "alpha"
+  | "shape"
+  | "linetype";
+
+/** Canonical Scales keys for multi-aes helpers. */
+export type MultiScaleChannel = Exclude<keyof Scales, "x" | "y">;
+
+const MULTI_AES = new Set<string>([
+  "color",
+  "colour",
+  "fill",
+  "size",
+  "linewidth",
+  "alpha",
+  "shape",
+  "linetype",
+]);
+
+const CONTINUOUS_IDENTITY_AES = new Set<MultiScaleChannel>([
+  "color",
+  "fill",
+  "size",
+  "linewidth",
+  "alpha",
+]);
+
+const DISCRETE_IDENTITY_AES = new Set<MultiScaleChannel>([
+  "color",
+  "fill",
+  "size",
+  "linewidth",
+  "alpha",
+  "shape",
+  "linetype",
+]);
+
+export function canonicalMultiScaleChannel(aesthetic: MultiScaleAesthetic): MultiScaleChannel {
+  if (aesthetic === "colour") return "color";
+  return aesthetic;
+}
+
+function assertAesthetics(
+  aesthetics: readonly MultiScaleAesthetic[],
+  allowed: ReadonlySet<MultiScaleChannel>,
+  kind: string,
+): MultiScaleChannel[] {
+  if (aesthetics.length === 0) {
+    throw new Error(`${kind}: aesthetics must be a non-empty array.`);
+  }
+  const channels: MultiScaleChannel[] = [];
+  const seen = new Set<MultiScaleChannel>();
+  for (const raw of aesthetics) {
+    if (!MULTI_AES.has(raw)) {
+      throw new Error(
+        `${kind}: unsupported aesthetic "${raw}". Expected one of: color, colour, fill, size, linewidth, alpha, shape, linetype.`,
+      );
+    }
+    const channel = canonicalMultiScaleChannel(raw);
+    if (!allowed.has(channel)) {
+      throw new Error(
+        `${kind}: aesthetic "${raw}" is not valid for this helper (resolved channel "${channel}").`,
+      );
+    }
+    if (seen.has(channel)) continue;
+    seen.add(channel);
+    channels.push(channel);
+  }
+  return channels;
+}
+
+export type MultiIdentityScaleOptions = {
+  /** Target aesthetics; British "colour" is an alias of "color". */
+  aesthetics: readonly MultiScaleAesthetic[];
+};
+
+export type MultiManualScaleOptions = {
+  aesthetics: readonly MultiScaleAesthetic[];
+  /** Positional range values applied to every listed aesthetic. */
+  values: readonly (string | number)[];
+  domain?: readonly CellValue[];
+};
+
+/**
+ * Build a Scales bag by assigning the same JSON config to each channel.
+ * Deep-clone so nested range/domain arrays are not shared across channels
+ * (shallow `{ ...entry }` would alias them — mutating one channel mutates all).
+ * Channel-specific Output types differ (colors vs numbers vs symbols); callers
+ * and tier-1 validation own value/channel compatibility.
+ */
+function cloneScaleEntry(entry: Record<string, unknown>): Record<string, unknown> {
+  const copy: Record<string, unknown> = { ...entry };
+  const range = copy["range"];
+  if (Array.isArray(range)) copy["range"] = range.slice();
+  const domain = copy["domain"];
+  if (Array.isArray(domain)) copy["domain"] = domain.slice();
+  return copy;
+}
+
+function assignChannels(
+  channels: readonly MultiScaleChannel[],
+  entry: Record<string, unknown>,
+): Scales {
+  const scales: Record<string, unknown> = {};
+  for (const channel of channels) {
+    scales[channel] = cloneScaleEntry(entry);
+  }
+  // Expanded subset of Scales keys; entries are identity/manual JSON objects.
+  // tsc needs the cast; type-aware lint mis-accepts Record→Scales without it.
+  // oxlint-disable-next-line typescript/no-unnecessary-type-assertion -- tsc TS2322
+  return scales as Scales;
+}
+
+/**
+ * Apply an identity scale to every listed continuous-friendly aesthetic
+ * (color/fill/size/linewidth/alpha). Shape/linetype are rejected.
+ */
+export function scaleContinuousIdentity(options: MultiIdentityScaleOptions): Scales {
+  const channels = assertAesthetics(
+    options.aesthetics,
+    CONTINUOUS_IDENTITY_AES,
+    "scaleContinuousIdentity",
+  );
+  return assignChannels(channels, { type: "identity" });
+}
+
+/**
+ * Apply an identity scale to every listed discrete-capable aesthetic
+ * (including shape/linetype).
+ */
+export function scaleDiscreteIdentity(options: MultiIdentityScaleOptions): Scales {
+  const channels = assertAesthetics(
+    options.aesthetics,
+    DISCRETE_IDENTITY_AES,
+    "scaleDiscreteIdentity",
+  );
+  return assignChannels(channels, { type: "identity" });
+}
+
+/**
+ * Apply the same manual domain/range mapping to every listed aesthetic.
+ * Callers must ensure `values` match each channel's output type (CSS colors
+ * for color/fill, numbers for size/alpha/linewidth, named tokens for
+ * shape/linetype) — tier-1 validation enforces that on the full plot.
+ */
+export function scaleDiscreteManual(options: MultiManualScaleOptions): Scales {
+  if (options.values.length === 0) {
+    throw new Error("scaleDiscreteManual: values must be a non-empty array.");
+  }
+  const channels = assertAesthetics(
+    options.aesthetics,
+    DISCRETE_IDENTITY_AES,
+    "scaleDiscreteManual",
+  );
+  const entry: Record<string, unknown> = {
+    type: "manual",
+    range: [...options.values],
+  };
+  if (options.domain !== undefined) {
+    entry["domain"] = [...options.domain];
+  }
+  return assignChannels(channels, entry);
+}
+
+export const scale_continuous_identity = scaleContinuousIdentity;
+export const scale_discrete_identity = scaleDiscreteIdentity;
+export const scale_discrete_manual = scaleDiscreteManual;
+
+// --- scale_type registry (agent/tooling default selection) -------------------
+
+export type ScaleTypeAesthetic = MultiScaleAesthetic | "x" | "y";
+
+/**
+ * Recommended PortableSpec scale family for an aesthetic + data kind.
+ * Not a full ggplot2 `scale_type` S3 registry — a small deterministic map for
+ * generators and repair tools.
+ */
+export type RecommendedScaleType = "linear" | "band" | "ordinal" | "sequential" | "identity";
+
+export function scaleType(query: {
+  aesthetic: ScaleTypeAesthetic;
+  dataKind: ProfileFieldType;
+}): RecommendedScaleType {
+  const aes = query.aesthetic === "colour" ? "color" : query.aesthetic;
+  if (aes === "x" || aes === "y") {
+    if (query.dataKind === "nominal" || query.dataKind === "ordinal") return "band";
+    // quantitative + temporal position → continuous linear (temporalKind is separate)
+    return "linear";
+  }
+  if (aes === "shape" || aes === "linetype") {
+    return "ordinal";
+  }
+  if (query.dataKind === "quantitative" || query.dataKind === "temporal") {
+    return "sequential";
+  }
+  return "ordinal";
+}
+
+export const scale_type = scaleType;

package/src/scale-position-helpers.ts

@@ -0,0 +1,231 @@
+/**
+ * Position scale authoring helpers (x/y continuous, binned, temporal, discrete).
+ * Color/fill helpers: scale-color-helpers.ts (+ viridis/stops/hue-grey siblings). Facade re-exports: scale-helpers.ts.
+ */
+
+import type { TemporalScaleKind } from "./temporal-parse-core.js";
+import type { PositionScaleSpec, Scales } from "./schema.js";
+
+export type TemporalScaleOptions = Omit<PositionScaleSpec, "type" | "temporalKind">;
+
+/**
+ * Options for the continuous/binned position families. Temporal-only fields are
+ * excluded (use the date/datetime helpers for those). `limits` is authoring
+ * sugar for `domain`; supplying both throws.
+ */
+export type ContinuousPositionScaleOptions = Omit<
+  PositionScaleSpec,
+  | "type"
+  | "temporalKind"
+  | "parse"
+  | "parseFailure"
+  | "timezone"
+  | "disambiguation"
+  | "dateBreaks"
+  | "dateMinorBreaks"
+  | "dateLabels"
+  | "locale"
+  | "weekStart"
+> & {
+  /** Pin the scale to [min, max] in source units (sugar for `domain`). */
+  limits?: PositionScaleSpec["domain"];
+};
+
+/** Options for the transform-forcing helpers (log10/sqrt): `transform` is fixed. */
+export type TransformedPositionScaleOptions = Omit<ContinuousPositionScaleOptions, "transform">;
+export type DiscretePositionScaleOptions = Omit<
+  PositionScaleSpec,
+  | "type"
+  | "temporalKind"
+  | "parse"
+  | "parseFailure"
+  | "timezone"
+  | "disambiguation"
+  | "dateBreaks"
+  | "dateMinorBreaks"
+  | "dateLabels"
+  | "locale"
+  | "weekStart"
+>;
+
+function temporalScale(
+  axis: "x" | "y",
+  temporalKind: TemporalScaleKind,
+  options: TemporalScaleOptions = {},
+): Scales {
+  return { [axis]: { type: "time", temporalKind, ...options } };
+}
+
+function discreteScale(axis: "x" | "y", options: DiscretePositionScaleOptions = {}): Scales {
+  const {
+    type: _,
+    temporalKind: __,
+    parse: ___,
+    parseFailure: ____,
+    timezone: _____,
+    disambiguation: ______,
+    dateBreaks: _______,
+    dateMinorBreaks: ________,
+    dateLabels: _________,
+    locale: __________,
+    weekStart: ___________,
+    ...discrete
+  } = options as PositionScaleSpec;
+  return { [axis]: { type: "band", ...discrete } };
+}
+
+export function scaleXDate(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("x", "date", options);
+}
+
+export function scaleXDatetime(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("x", "datetime", options);
+}
+
+export function scaleYDate(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("y", "date", options);
+}
+
+export function scaleYDatetime(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("y", "datetime", options);
+}
+
+/**
+ * Time-of-day position scale (ggplot2 `scale_x_time`).
+ * Portable numbers are **seconds since midnight** (0…86400); see TemporalKind `"time"`.
+ */
+export function scaleXTime(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("x", "time", options);
+}
+
+/** Time-of-day position scale (ggplot2 `scale_y_time`). */
+export function scaleYTime(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("y", "time", options);
+}
+
+/**
+ * Month-day position scale: the year collapses, so the same calendar day from
+ * any year shares one position. Values, `domain`, and `breaks` are all written
+ * without a year (`"04-05"`), and no year reaches a label. See TemporalKind
+ * `"monthDay"`. A window cannot cross the year boundary.
+ */
+export function scaleXMonthDay(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("x", "monthDay", options);
+}
+
+/** Month-day position scale; see {@link scaleXMonthDay}. */
+export function scaleYMonthDay(options: TemporalScaleOptions = {}): Scales {
+  return temporalScale("y", "monthDay", options);
+}
+
+export function scaleXDiscrete(options: DiscretePositionScaleOptions = {}): Scales {
+  return discreteScale("x", options);
+}
+
+export function scaleYDiscrete(options: DiscretePositionScaleOptions = {}): Scales {
+  return discreteScale("y", options);
+}
+
+export const scale_x_date = scaleXDate;
+export const scale_x_datetime = scaleXDatetime;
+export const scale_x_time = scaleXTime;
+export const scale_y_date = scaleYDate;
+export const scale_y_datetime = scaleYDatetime;
+export const scale_y_time = scaleYTime;
+export const scale_x_month_day = scaleXMonthDay;
+export const scale_y_month_day = scaleYMonthDay;
+export const scale_x_discrete = scaleXDiscrete;
+export const scale_y_discrete = scaleYDiscrete;
+
+// --- continuous / binned position families ----------------------------------
+
+function continuousScale(
+  axis: "x" | "y",
+  type: "linear" | "binned",
+  options: ContinuousPositionScaleOptions,
+  forced: { transform?: "log10" | "sqrt"; reverse?: true } = {},
+): Scales {
+  const { limits, domain, transform, reverse, ...rest } = options;
+  if (limits !== undefined && domain !== undefined) {
+    throw new TypeError(
+      "scale helper: supply either `limits` or `domain`, not both (both pin the scale).",
+    );
+  }
+  const resolvedDomain = domain ?? limits;
+  const resolvedTransform = forced.transform ?? transform;
+  const resolvedReverse = forced.reverse ?? reverse;
+  return {
+    [axis]: {
+      type,
+      ...(resolvedTransform !== undefined && { transform: resolvedTransform }),
+      ...(resolvedReverse !== undefined && { reverse: resolvedReverse }),
+      ...(resolvedDomain !== undefined && { domain: resolvedDomain }),
+      ...rest,
+    },
+  };
+}
+
+/** Configure the x scale as a continuous linear scale (default numeric family). */
+export function scaleXContinuous(options: ContinuousPositionScaleOptions = {}): Scales {
+  return continuousScale("x", "linear", options);
+}
+
+/** Configure the y scale as a continuous linear scale (default numeric family). */
+export function scaleYContinuous(options: ContinuousPositionScaleOptions = {}): Scales {
+  return continuousScale("y", "linear", options);
+}
+
+/** Configure the x scale as a base-10 log scale (pre-stat log10 transform). */
+export function scaleXLog10(options: TransformedPositionScaleOptions = {}): Scales {
+  return continuousScale("x", "linear", options, { transform: "log10" });
+}
+
+/** Configure the y scale as a base-10 log scale (pre-stat log10 transform). */
+export function scaleYLog10(options: TransformedPositionScaleOptions = {}): Scales {
+  return continuousScale("y", "linear", options, { transform: "log10" });
+}
+
+/** Configure the x scale as a square-root scale (pre-stat sqrt transform). */
+export function scaleXSqrt(options: TransformedPositionScaleOptions = {}): Scales {
+  return continuousScale("x", "linear", options, { transform: "sqrt" });
+}
+
+/** Configure the y scale as a square-root scale (pre-stat sqrt transform). */
+export function scaleYSqrt(options: TransformedPositionScaleOptions = {}): Scales {
+  return continuousScale("y", "linear", options, { transform: "sqrt" });
+}
+
+/** Reverse the x scale's output direction (identity continuous scale, reverse: true). */
+export function scaleXReverse(
+  options: Omit<ContinuousPositionScaleOptions, "transform" | "reverse"> = {},
+): Scales {
+  return continuousScale("x", "linear", options, { reverse: true });
+}
+
+/** Reverse the y scale's output direction (identity continuous scale, reverse: true). */
+export function scaleYReverse(
+  options: Omit<ContinuousPositionScaleOptions, "transform" | "reverse"> = {},
+): Scales {
+  return continuousScale("y", "linear", options, { reverse: true });
+}
+
+/** Configure the x scale as a binned (ordered-bin) quantitative scale. */
+export function scaleXBinned(options: ContinuousPositionScaleOptions = {}): Scales {
+  return continuousScale("x", "binned", options);
+}
+
+/** Configure the y scale as a binned (ordered-bin) quantitative scale. */
+export function scaleYBinned(options: ContinuousPositionScaleOptions = {}): Scales {
+  return continuousScale("y", "binned", options);
+}
+
+export const scale_x_continuous = scaleXContinuous;
+export const scale_y_continuous = scaleYContinuous;
+export const scale_x_log10 = scaleXLog10;
+export const scale_y_log10 = scaleYLog10;
+export const scale_x_sqrt = scaleXSqrt;
+export const scale_y_sqrt = scaleYSqrt;
+export const scale_x_reverse = scaleXReverse;
+export const scale_y_reverse = scaleYReverse;
+export const scale_x_binned = scaleXBinned;
+export const scale_y_binned = scaleYBinned;