ggaction 0.0.10 → 0.0.12

package/types/svg.d.ts

@@ -3,6 +3,7 @@ import type { ChartProgram } from "./program.js";
 export interface SVGRenderOptions {
   readonly title?: string;
   readonly description?: string;
+  readonly resourceNamespace?: string;
 }
 
 export function renderToSVG(

package/src/actions/errorBands/components.js

@@ -1,81 +0,0 @@
-import { action } from "../../core/action.js";
-
-function positionOptions({ target, field, fieldType, coordinate, scale }) {
-  return {
-    target,
-    field,
-    fieldType,
-    coordinate,
-    scale: { id: scale }
-  };
-}
-
-export const createErrorBandBoundary = action(
-  {
-    op: "createErrorBandBoundary",
-    description: "Create one lower or upper error-band boundary line."
-  },
-  function ({
-    id,
-    data,
-    orientation,
-    bound,
-    position,
-    coordinate,
-    intervalScale,
-    positionScale,
-    groupBy,
-    stroke,
-    strokeWidth,
-    strokeDash,
-    opacity,
-    curve
-  } = {}) {
-    let next = this.createLineMark({ id, data, strokeWidth, curve });
-    if (orientation === "vertical") {
-      next = next
-        .encodeY(positionOptions({
-          target: id,
-          field: bound,
-          fieldType: "quantitative",
-          coordinate,
-          scale: intervalScale
-        }))
-        .encodeX(positionOptions({
-          target: id,
-          field: position.field,
-          fieldType: position.fieldType,
-          coordinate,
-          scale: positionScale
-        }));
-    } else {
-      next = next
-        .encodeY(positionOptions({
-          target: id,
-          field: position.field,
-          fieldType: position.fieldType,
-          coordinate,
-          scale: positionScale
-        }))
-        .encodeX(positionOptions({
-          target: id,
-          field: bound,
-          fieldType: "quantitative",
-          coordinate,
-          scale: intervalScale
-        }));
-    }
-    if (groupBy !== undefined) {
-      next = next.encodeGroup({ target: id, field: groupBy });
-    }
-    next = next
-      .editGraphics({ target: id, property: "stroke", value: stroke })
-      .editGraphics({
-        target: id,
-        property: "strokeDash",
-        value: next.graphicSpec.objects[id].items.map(() => strokeDash)
-      })
-      .editGraphics({ target: id, property: "opacity", value: opacity });
-    return next;
-  }
-);

package/src/actions/errorBands/options.js

@@ -1,39 +0,0 @@
-import { isPlainObject } from "../../core/immutable.js";
-import {
-  validateKeys,
-  validateNonEmptyString,
-  validateNonNegativeFinite,
-  validateUnitInterval
-} from "../../core/validation.js";
-import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
-import { normalizeStrokeDashPattern } from "../../grammar/scales/index.js";
-
-export const ERROR_BAND_BOUNDARY_OPTIONS = Object.freeze([
-  "stroke", "strokeWidth", "strokeDash", "opacity", "curve"
-]);
-
-export function resolveBoundaryAppearance(value, {
-  defaults,
-  operation
-}) {
-  if (!isPlainObject(value)) {
-    throw new TypeError(`${operation} must be a plain object.`);
-  }
-  validateKeys(value, ERROR_BAND_BOUNDARY_OPTIONS, operation);
-  const stroke = value.stroke ?? defaults.stroke;
-  const strokeWidth = value.strokeWidth ?? defaults.strokeWidth;
-  const strokeDash = value.strokeDash ?? defaults.strokeDash;
-  const opacity = value.opacity ?? defaults.opacity;
-  const curve = validateCurveInterpolation(value.curve ?? defaults.curve);
-  validateNonEmptyString(stroke, `${operation} stroke`);
-  validateNonNegativeFinite(strokeWidth, `${operation} strokeWidth`);
-  const resolvedStrokeDash = normalizeStrokeDashPattern(strokeDash);
-  validateUnitInterval(opacity, `${operation} opacity`);
-  return {
-    stroke,
-    strokeWidth,
-    strokeDash: resolvedStrokeDash,
-    opacity,
-    curve
-  };
-}

package/src/actions/errorBands/resolve.js

@@ -1,28 +0,0 @@
-import { resolveIntervalComposite } from "../intervals/resolve.js";
-
-const ERROR_BAND_POLICY = Object.freeze({
-  operation: "createErrorBand",
-  resourceLabel: "error-band",
-  defaultId: "errorBand",
-  ownerLabel: "Error-band id",
-  positionTypes: Object.freeze(["quantitative", "temporal"]),
-  defaultPositionType: "quantitative",
-  defaultIntervalChannel: "y",
-  scaleDefaults: fieldType => fieldType === "temporal"
-    ? { nice: true }
-    : { nice: true, zero: false },
-  intervalScaleDefaults: Object.freeze({ nice: true, zero: false }),
-  allowExplicitGrouping: true,
-  ambiguousMessage:
-    "createErrorBand cannot infer the interval axis when both positions are quantitative; provide an interval option."
-});
-
-export function resolveErrorBand(program, args) {
-  const resolved = resolveIntervalComposite(program, args, ERROR_BAND_POLICY);
-  if (resolved.groupField === resolved.position.field) {
-    throw new Error(
-      "createErrorBand groupBy must differ from the independent position field."
-    );
-  }
-  return resolved;
-}

package/src/actions/errorBars/components.js

@@ -1,62 +0,0 @@
-import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
-
-const OPTIONS = Object.freeze([
-  "id",
-  "data",
-  "orientation",
-  "positionField",
-  "positionFieldType",
-  "intervalField",
-  "coordinate",
-  "positionScale",
-  "intervalScale",
-  "capSize",
-  "stroke",
-  "strokeWidth",
-  "strokeDash",
-  "opacity"
-]);
-
-export const createErrorBarCap = action(
-  {
-    op: "createErrorBarCap",
-    description: "Create one fixed-pixel error-bar cap."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createErrorBarCap");
-    if (!["vertical", "horizontal"].includes(args.orientation)) {
-      throw new Error(`Unsupported error-bar orientation "${args.orientation}".`);
-    }
-    const positionChannel = args.orientation === "vertical" ? "x" : "y";
-    const intervalChannel = args.orientation === "vertical" ? "y" : "x";
-    const positionAction = positionChannel === "x" ? "encodeX" : "encodeY";
-    const intervalAction = intervalChannel === "x" ? "encodeX" : "encodeY";
-
-    return this
-      .createRuleMark({ id: args.id, data: args.data })
-      [positionAction]({
-        target: args.id,
-        field: args.positionField,
-        fieldType: args.positionFieldType,
-        coordinate: args.coordinate,
-        scale: { id: args.positionScale }
-      })
-      [intervalAction]({
-        target: args.id,
-        field: args.intervalField,
-        fieldType: "quantitative",
-        coordinate: args.coordinate,
-        scale: { id: args.intervalScale }
-      })
-      .encodeStroke({ target: args.id, value: args.stroke })
-      .encodeStrokeWidth({ target: args.id, value: args.strokeWidth })
-      .encodeStrokeDash({ target: args.id, value: args.strokeDash })
-      .encodeOpacity({ target: args.id, value: args.opacity })
-      .materializeRuleSpan({
-        id: args.id,
-        orientation: args.orientation === "vertical" ? "horizontal" : "vertical",
-        size: args.capSize
-      });
-  }
-);

package/src/actions/errorBars/options.js

@@ -1,58 +0,0 @@
-import {
-  validateKeys,
-  validatePositiveFinite
-} from "../../core/validation.js";
-import {
-  normalizeStrokeDashPattern,
-  validateOpacityValue
-} from "../../grammar/scales/index.js";
-import {
-  validateRuleStroke,
-  validateRuleStrokeWidth
-} from "../../grammar/ruleAppearance.js";
-
-export const ERROR_BAR_EDIT_OPTIONS = Object.freeze([
-  "target", "caps", "capSize", "stroke", "strokeWidth",
-  "strokeDash", "opacity", "statistics"
-]);
-
-export const ERROR_BAR_APPEARANCE_OPTIONS = Object.freeze(
-  ERROR_BAR_EDIT_OPTIONS.filter(option =>
-    option !== "target" && option !== "statistics"
-  )
-);
-
-export function resolveErrorBarAppearance(args, {
-  defaults,
-  operation
-}) {
-  validateKeys(args, ERROR_BAR_EDIT_OPTIONS, operation);
-  const caps = args.caps ?? defaults.caps;
-  if (typeof caps !== "boolean") {
-    throw new TypeError(`${operation} caps must be a boolean.`);
-  }
-  const capSize = args.capSize ?? defaults.capSize;
-  validatePositiveFinite(capSize, `${operation} capSize`);
-  const stroke = validateRuleStroke(
-    args.stroke ?? defaults.stroke,
-    `${operation} stroke`
-  );
-  const strokeWidth = validateRuleStrokeWidth(
-    args.strokeWidth ?? defaults.strokeWidth,
-    `${operation} strokeWidth`
-  );
-  const strokeDash = args.strokeDash ?? defaults.strokeDash;
-  normalizeStrokeDashPattern(strokeDash);
-  const opacity = validateOpacityValue(
-    args.opacity ?? defaults.opacity,
-    `${operation} opacity`
-  );
-  return {
-    caps,
-    capSize,
-    stroke,
-    strokeWidth,
-    strokeDash,
-    opacity
-  };
-}

package/src/actions/errorBars/resolve.js

@@ -1,25 +0,0 @@
-import { resolveIntervalComposite } from "../intervals/resolve.js";
-
-const ERROR_BAR_POLICY = Object.freeze({
-  operation: "createErrorBar",
-  resourceLabel: "error-bar",
-  defaultId: "errorBar",
-  ownerLabel: "Error-bar id",
-  positionTypes: Object.freeze(["nominal", "ordinal", "temporal"]),
-  defaultPositionType: "nominal",
-  defaultIntervalChannel: "y",
-  scaleDefaults: () => ({}),
-  intervalScaleDefaults: Object.freeze({ nice: true, zero: false }),
-  allowExplicitGrouping: false,
-  ambiguousMessage:
-    "createErrorBar requires one quantitative interval axis and one nominal, ordinal, or temporal position axis."
-});
-
-export function resolveErrorBar(program, args) {
-  const resolved = resolveIntervalComposite(program, args, ERROR_BAR_POLICY);
-  return {
-    ...resolved,
-    lowerCapId: `${resolved.id}LowerCap`,
-    upperCapId: `${resolved.id}UpperCap`
-  };
-}