ggaction 0.0.13 → 0.0.16

package/src/actions/theme/state.js

@@ -0,0 +1,160 @@
+import {
+  cloneAndFreeze,
+  freezeOwned,
+  isPlainObject
+} from "../../core/immutable.js";
+import {
+  normalizeThemeDefinition,
+  resolveThemeTokens
+} from "../../theme/defaults.js";
+
+export const LOCAL_THEME_OWNER = "local";
+
+function ownArray(value) {
+  return freezeOwned([...(value ?? [])]);
+}
+
+function requireThemeScope(value) {
+  if (!["self", "descendants"].includes(value)) {
+    throw new Error(`Unsupported theme scope "${value}".`);
+  }
+  return value;
+}
+
+function requireThemeOwner(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError("Theme frame owner must be a non-empty string.");
+  }
+  return value;
+}
+
+export function compositionThemeOwner(id, scope = "descendants") {
+  if (typeof id !== "string" || id.length === 0) {
+    throw new TypeError("Composition theme owner requires a non-empty id.");
+  }
+  requireThemeScope(scope);
+  return scope === "self" ? `composition:${id}:self` : `composition:${id}`;
+}
+
+export function createThemeFrame({
+  owner = LOCAL_THEME_OWNER,
+  scope = "self",
+  definition
+}) {
+  const normalized = normalizeThemeDefinition(definition);
+  return freezeOwned({
+    owner: requireThemeOwner(owner),
+    scope: requireThemeScope(scope),
+    name: normalized.name,
+    tokens: normalized.tokens
+  });
+}
+
+export function upsertThemeFrame(frames = [], frame) {
+  if (!Array.isArray(frames)) {
+    throw new TypeError("Theme frames must be an array.");
+  }
+  if (!isPlainObject(frame)) {
+    throw new TypeError("Theme frame must be a plain object.");
+  }
+  return freezeOwned([
+    ...frames.filter(current => current.owner !== frame.owner),
+    frame
+  ]);
+}
+
+export function removeThemeFrameOwner(frames = [], owner) {
+  if (!Array.isArray(frames)) {
+    throw new TypeError("Theme frames must be an array.");
+  }
+  requireThemeOwner(owner);
+  const next = frames.filter(frame => frame.owner !== owner);
+  return freezeOwned({
+    frames: freezeOwned(next),
+    removed: next.length !== frames.length
+  });
+}
+
+export function moveLocalThemeScope(localOrder = [], scope) {
+  if (!Array.isArray(localOrder)) {
+    throw new TypeError("Theme localOrder must be an array.");
+  }
+  requireThemeScope(scope);
+  return freezeOwned([
+    ...localOrder.filter(current => current !== scope),
+    scope
+  ]);
+}
+
+function ownCanonicalThemeState(state, composition) {
+  const frames = ownArray(state.frames);
+  const localOrder = ownArray(state.localOrder);
+  const overrides = ownArray(state.overrides);
+  const result = { frames, localOrder, overrides };
+  if (composition || state.descendantFrames !== undefined) {
+    result.descendantFrames = ownArray(state.descendantFrames);
+  }
+  return cloneAndFreeze(result);
+}
+
+export function normalizeThemeState(state, { composition = false } = {}) {
+  if (state === undefined) {
+    return freezeOwned({
+      frames: freezeOwned([]),
+      ...(composition ? { descendantFrames: freezeOwned([]) } : {}),
+      localOrder: freezeOwned([]),
+      overrides: freezeOwned([])
+    });
+  }
+  if (!isPlainObject(state)) {
+    throw new TypeError("Program theme state must be a plain object.");
+  }
+  if (Array.isArray(state.frames)) {
+    return ownCanonicalThemeState(state, composition);
+  }
+
+  const name = state.name ?? "light";
+  const tokens = state.tokens ?? {};
+  const scope = state.scope ?? "self";
+  const origin = state.origin?.ownerCompositionId;
+  const owner = origin === undefined
+    ? LOCAL_THEME_OWNER
+    : compositionThemeOwner(origin, "descendants");
+  const frame = createThemeFrame({
+    owner,
+    scope,
+    definition: { base: name, tokens }
+  });
+  return freezeOwned({
+    frames: freezeOwned([frame]),
+    ...(composition && scope === "descendants"
+      ? { descendantFrames: freezeOwned([frame]) }
+      : composition
+        ? { descendantFrames: freezeOwned([]) }
+        : {}),
+    localOrder: origin === undefined ? freezeOwned([scope]) : freezeOwned([]),
+    overrides: cloneAndFreeze(state.overrides ?? [])
+  });
+}
+
+export function resolveEffectiveThemeFrame(state) {
+  const frames = state?.frames;
+  return Array.isArray(frames) ? frames.at(-1) : undefined;
+}
+
+export function resolveEffectiveThemeTokens(state) {
+  const frame = resolveEffectiveThemeFrame(state);
+  return frame === undefined
+    ? resolveThemeTokens("light")
+    : resolveThemeTokens({ base: frame.name, tokens: frame.tokens });
+}
+
+export function setThemeStateOverrides(state, overrides) {
+  if (!Array.isArray(overrides)) {
+    throw new TypeError("Theme overrides must be an array.");
+  }
+  return freezeOwned({
+    ...state,
+    overrides: cloneAndFreeze([...overrides].sort())
+  });
+}

package/src/actions/titles/actions.js

@@ -115,12 +115,12 @@ function titleTextAction(kind, create) {
   }));
 }
 
-export const editTitleText = titleTextAction("title", false);
-export const createTitleText = titleTextAction("title", true);
-export const editSubtitleText = titleTextAction("subtitle", false);
-export const createSubtitleText = titleTextAction("subtitle", true);
+export const editTitleText = /* @__PURE__ */ titleTextAction("title", false);
+export const createTitleText = /* @__PURE__ */ titleTextAction("title", true);
+export const editSubtitleText = /* @__PURE__ */ titleTextAction("subtitle", false);
+export const createSubtitleText = /* @__PURE__ */ titleTextAction("subtitle", true);
 
-export const rematerializeTitle = action(
+export const rematerializeTitle = /* @__PURE__ */ action(
   { op: "rematerializeTitle", description: "Rematerialize chart title graphics." },
   withGuideLayoutValidation(function (args = {}) {
     noOptions(args, "rematerializeTitle");
@@ -142,7 +142,7 @@ export const rematerializeTitle = action(
   })
 );
 
-export const createTitle = action(
+export const createTitle = /* @__PURE__ */ action(
   {
     op: "createTitle",
     description: "Create a chart title and optional subtitle.",
@@ -176,7 +176,7 @@ export const createTitle = action(
   })
 );
 
-export const editTitle = action(
+export const editTitle = /* @__PURE__ */ action(
   {
     op: "editTitle",
     description: "Edit one stable chart title resource.",
@@ -214,7 +214,7 @@ export const editTitle = action(
   })
 );
 
-export const removeTitle = action(
+export const removeTitle = /* @__PURE__ */ action(
   {
     op: "removeTitle",
     description: "Remove the complete chart title resource.",

package/src/actions/titles/resolve.js

@@ -212,7 +212,7 @@ export function resolveTitleLayout(program, config) {
           program.semanticSpec.title.subtitle,
           "Chart subtitle"
         )
-  }, config);
+  }, config, program.materializationConfigs.textMetrics);
   const horizontal = ["top", "bottom"].includes(config.position);
   let component;
   if (horizontal) {
@@ -249,10 +249,10 @@ export function resolveTitleLayout(program, config) {
     ? undefined
     : component(block.subtitleLines, block.subtitleCenters);
   const titleBounds = unionTitleBounds([
-    resolveTitleComponentBounds(title, config.titleStyle),
+    resolveTitleComponentBounds(title, config.titleStyle, program.materializationConfigs.textMetrics),
     ...(subtitle === undefined
       ? []
-      : [resolveTitleComponentBounds(subtitle, config.subtitleStyle)])
+      : [resolveTitleComponentBounds(subtitle, config.subtitleStyle, program.materializationConfigs.textMetrics)])
   ]);
   validateLayout(
     config.position,

package/src/actions/violinPlots/create.js

@@ -2,6 +2,7 @@ import { action } from "../../core/action.js";
 import { validateOptionObject } from "../../core/validation.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -20,12 +21,13 @@ const OPTIONS = Object.freeze([
 ]);
 const POSITION_OPTIONS = Object.freeze(["field", "fieldType", "scale"]);
 const DENSITY_OPTIONS = Object.freeze([
-  "bandwidth", "extent", "steps", "kernel", "normalization", "width", "side"
+  "bandwidth", "extent", "steps", "kernel", "normalization", "weight", "width", "side"
 ]);
 const WIDTH_OPTIONS = Object.freeze(["band", "resolve"]);
 const SPLIT_OPTIONS = Object.freeze(["field", "domain"]);
 const AREA_OPTIONS = Object.freeze([
-  "fill", "opacity", "stroke", "strokeWidth", "curve"
+  "fill", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const CATEGORICAL_TYPES = Object.freeze(["nominal", "ordinal"]);
 const OPERATION = "createViolinPlot";
@@ -130,7 +132,7 @@ function guideOptions(guides, x, y, category, color) {
   };
 }
 
-export const createViolinPlot = action(
+export const createViolinPlot = /* @__PURE__ */ action(
   {
     op: "createViolinPlot",
     description: "Create a categorical kernel-density violin plot."
@@ -221,6 +223,7 @@ export const createViolinPlot = action(
           steps: transform.steps,
           kernel: transform.kernel,
           normalization: transform.normalization,
+          ...(transform.weight === undefined ? {} : { weight: transform.weight }),
           width: transform.placement.width,
           side: transform.placement.side
         },

package/src/actions/violinPlots/edit.js

@@ -74,7 +74,7 @@ function assertSplitSelectionCompatibility(program, owner, changesSplit) {
   }
 }
 
-export const editViolinPlot = action(
+export const editViolinPlot = /* @__PURE__ */ action(
   {
     op: OPERATION,
     description: "Revise one violin plot's data and statistical roles."
@@ -181,6 +181,7 @@ export const editViolinPlot = action(
           steps: transform.steps,
           kernel: transform.kernel,
           normalization: transform.normalization,
+          ...(transform.weight === undefined ? {} : { weight: transform.weight }),
           width: transform.placement.width,
           side: transform.placement.side
         }

package/src/core/action.js

@@ -1,6 +1,9 @@
-import { cloneAndFreeze, freezeOwned, isPlainObject } from "./immutable.js";
+import { validateKeys } from "./validation.js";
+import { annotateError } from "./diagnostics.js";
+import { cloneAndFreeze, freezeOwned, isOwned, isPlainObject } from "./immutable.js";
 
 const metadataByWrappedAction = new WeakMap();
+const implementationByWrappedAction = new WeakMap();
 let actionCompletionHook;
 
 export function setActionCompletionHook(hook) {
@@ -14,6 +17,14 @@ export function getWrappedActionMetadata(value) {
   return metadataByWrappedAction.get(value);
 }
 
+export function invokeWrappedActionImplementation(value, program, args = {}) {
+  const implementation = implementationByWrappedAction.get(value);
+  if (implementation === undefined) {
+    throw new TypeError("Expected an action created by action().");
+  }
+  return implementation.call(program, args);
+}
+
 function summarizeObject(value, ancestors = new WeakSet()) {
   if (ancestors.has(value)) {
     throw new TypeError("Action arguments must not contain circular references.");
@@ -26,6 +37,8 @@ function summarizeObject(value, ancestors = new WeakSet()) {
       summary[`${key}Count`] = item.length;
     } else if (isPlainObject(item)) {
       summary[key] = summarizeObject(item, ancestors);
+    } else if (typeof item === "function") {
+      summary[`${key}Type`] = "function";
     } else if (item !== null && typeof item === "object") {
       summary[`${key}Type`] = item.constructor?.name ?? "object";
     } else {
@@ -62,13 +75,59 @@ export function createActionNode({ id, op, description, args }) {
   });
 }
 
+// Persistent child tails make appending the active (last) branch independent
+// of sibling count. The public children property remains a stable frozen Array.
+const childLists = new WeakMap();
+
+function childList(node) {
+  let list = childLists.get(node);
+  if (list !== undefined) return list;
+  let tail;
+  for (const child of node.children) tail = { value: child, previous: tail };
+  list = { tail, length: node.children.length };
+  if (isOwned(node)) childLists.set(node, list);
+  return list;
+}
+
+function withChildList(node, list) {
+  let children;
+  const next = {};
+  for (const key of Object.keys(node)) {
+    if (key !== "children") Object.defineProperty(next, key, {
+      value: node[key], enumerable: true
+    });
+  }
+  Object.defineProperty(next, "children", {
+    enumerable: true,
+    get() {
+      if (children === undefined) {
+        const values = new Array(list.length);
+        let item = list.tail;
+        for (let index = list.length - 1; index >= 0; index -= 1) {
+          values[index] = item.value;
+          item = item.previous;
+        }
+        children = freezeOwned(values);
+      }
+      return children;
+    }
+  });
+  childLists.set(next, list);
+  return freezeOwned(next);
+}
+
+function childAt(node, index) {
+  const list = childList(node);
+  return index === list.length - 1 ? list.tail.value : node.children[index];
+}
+
 function nodeAtPath(root, path) {
   let node = root;
   for (const index of path) {
-    if (!Number.isInteger(index) || index < 0 || index >= node.children.length) {
+    if (!Number.isInteger(index) || index < 0 || index >= childList(node).length) {
       throw new Error(`Unknown parent action path "${path.join(".")}".`);
     }
-    node = node.children[index];
+    node = childAt(node, index);
   }
   return node;
 }
@@ -78,19 +137,28 @@ export function appendActionNodeAtPath(root, parentPath, actionNode) {
     throw new TypeError("Parent action path must be an array.");
   }
   const parent = nodeAtPath(root, parentPath);
-  const path = [...parentPath, parent.children.length];
+  const path = [...parentPath, childList(parent).length];
 
   function append(node, depth) {
+    const list = childList(node);
     if (depth === parentPath.length) {
-      return freezeOwned({
-        ...node,
-        children: freezeOwned([...node.children, actionNode])
+      return withChildList(node, {
+        tail: { value: actionNode, previous: list.tail }, length: list.length + 1
       });
     }
     const index = parentPath[depth];
-    const children = [...node.children];
-    children[index] = append(children[index], depth + 1);
-    return freezeOwned({ ...node, children: freezeOwned(children) });
+    const child = append(childAt(node, index), depth + 1);
+    if (index === list.length - 1) {
+      return withChildList(node, {
+        tail: { value: child, previous: list.tail.previous }, length: list.length
+      });
+    }
+    // Restored/extension traces may address an older sibling explicitly.
+    let tail;
+    for (let position = 0; position < list.length; position += 1) {
+      tail = { value: position === index ? child : node.children[position], previous: tail };
+    }
+    return withChildList(node, { tail, length: list.length });
   }
 
   return { root: append(root, 0), path };
@@ -128,38 +196,52 @@ export function action(metadata, implementation) {
   });
 
   const wrappedAction = function wrappedAction(args = {}) {
-    if (!isPlainObject(args)) {
-      throw new TypeError("Action arguments must be a plain object.");
-    }
-
-    if (scope === "unit") this._assertUnitProgram(ownedMetadata.op);
-    if (scope === "composition") this._assertCompositionProgram(ownedMetadata.op);
-
-    const summarizedArgs = summarizeArgs(args);
-    const entered = this._enterAction({
-      ...ownedMetadata,
-      args: summarizedArgs
-    });
-    let result = implementation.call(entered, args);
-
-    if (!(result instanceof this.constructor)) {
-      throw new TypeError(`${ownedMetadata.op} must return a ChartProgram.`);
-    }
-
-    if (this.actionStack.length === 0 && actionCompletionHook !== undefined) {
-      result = actionCompletionHook(result, {
-        source: this,
-        metadata: ownedMetadata,
+    try {
+      if (!isPlainObject(args)) {
+        throw new TypeError("Action arguments must be a plain object.");
+      }
+  
+      if (scope === "unit") this._assertUnitProgram(ownedMetadata.op);
+      if (scope === "composition") this._assertCompositionProgram(ownedMetadata.op);
+  
+      const summarizedArgs = summarizeArgs(args);
+      const entered = this._enterAction({
+        ...ownedMetadata,
         args: summarizedArgs
       });
+      let result = implementation.call(entered, args);
+  
       if (!(result instanceof this.constructor)) {
-        throw new TypeError("Action completion hook must return a ChartProgram.");
+        throw new TypeError(`${ownedMetadata.op} must return a ChartProgram.`);
       }
+  
+      if (this.actionStack.length === 0 && actionCompletionHook !== undefined) {
+        result = actionCompletionHook(result, {
+          source: this,
+          metadata: ownedMetadata,
+          args: summarizedArgs
+        });
+        if (!(result instanceof this.constructor)) {
+          throw new TypeError("Action completion hook must return a ChartProgram.");
+        }
+      }
+  
+      return result._exitAction();
+    } catch (error) {
+      throw annotateError(error, { code: "action-failed", operation: ownedMetadata.op });
     }
-
-    return result._exitAction();
   };
 
   metadataByWrappedAction.set(wrappedAction, ownedMetadata);
+  implementationByWrappedAction.set(wrappedAction, implementation);
   return wrappedAction;
 }
+
+// Private built-in convenience: action() owns the object boundary and trace,
+// while each definition supplies its closed option vocabulary exactly once.
+export function closedAction(metadata, options, implementation) {
+  return action(metadata, function (args = {}) {
+    if (options !== undefined) validateKeys(args, options, metadata.op);
+    return implementation.call(this, args);
+  });
+}

package/src/core/compositionState.js

@@ -150,8 +150,13 @@ function validateFacetSpec(compositionSpec) {
         "compositionSpec.facet.repeat requires target, channel, and fields."
       );
     }
+    const repeatChannel = ["x", "y", "theta", "r"].includes(repeat.channel) ||
+      (isPlainObject(repeat.channel) &&
+        Object.keys(repeat.channel).length === 1 &&
+        typeof repeat.channel.parallelDimension === "string" &&
+        repeat.channel.parallelDimension.length > 0);
     if (typeof repeat.target !== "string" || repeat.target.length === 0 ||
-        !["x", "y"].includes(repeat.channel) ||
+        !repeatChannel ||
         !Array.isArray(repeat.fields) || repeat.fields.length === 0 ||
         repeat.fields.some(field => typeof field !== "string" || field.length === 0) ||
         new Set(repeat.fields).size !== repeat.fields.length) {

package/src/core/diagnostics.js

@@ -0,0 +1,16 @@
+const detailsByError = new WeakMap();
+
+export function getErrorDetails(error) {
+  return error !== null && (typeof error === "object" || typeof error === "function")
+    ? detailsByError.get(error) : undefined;
+}
+
+// Attach metadata without modifying the thrown value or its existing class.
+export function annotateError(error, details) {
+  if (!(error instanceof Error)) return error;
+  const previous = getErrorDetails(error);
+  const merged = { ...details, ...previous };
+  if (merged.candidates !== undefined) merged.candidates = Object.freeze([...merged.candidates]);
+  detailsByError.set(error, Object.freeze(merged));
+  return error;
+}

package/src/core/extensionRegistry.js

@@ -4,6 +4,32 @@ import { isPlainObject } from "./immutable.js";
 const ACTION_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const DEFINITION_KEYS = new Set(["name", "actions"]);
 const registeredExtensionNames = new Set();
+const extensionByAction = new Map();
+const builtinOpsByClass = new WeakMap();
+
+export function recordBuiltinActions(ProgramClass, additional = []) {
+  builtinOpsByClass.set(ProgramClass, new Set([
+    ...Object.getOwnPropertyNames(ProgramClass.prototype).flatMap(name => {
+      const metadata = getWrappedActionMetadata(ProgramClass.prototype[name]);
+      return metadata ? [metadata.op] : [];
+    }), ...additional
+  ]));
+}
+
+export function isBuiltinProgramClass(ProgramClass) {
+  return builtinOpsByClass.has(ProgramClass);
+}
+
+export function requiredTraceExtension(ProgramClass, op) {
+  if (op === "program" || builtinOpsByClass.get(ProgramClass)?.has(op)) return undefined;
+  const extension = extensionByAction.get(op);
+  if (extension !== undefined) return extension;
+  throw new TypeError(`Cannot persist unregistered action "${op}".`);
+}
+
+export function hasRegisteredExtension(name) {
+  return registeredExtensionNames.has(name);
+}
 
 function readDataProperty(object, key, owner) {
   const descriptor = Object.getOwnPropertyDescriptor(object, key);
@@ -101,4 +127,5 @@ export function registerProgramExtension(ProgramClass, definition) {
 
   Object.defineProperties(ProgramClass.prototype, descriptors);
   registeredExtensionNames.add(name);
+  for (const actionName of actionNames) extensionByAction.set(actionName, name);
 }

package/src/core/font.js

@@ -0,0 +1,18 @@
+export const DEFAULT_FONT_FAMILY = "sans-serif";
+
+export function normalizeRendererFontWeight(fontWeight) {
+  if (typeof fontWeight !== "number") return fontWeight;
+  return Math.min(900, Math.max(100, Math.round(fontWeight / 100) * 100));
+}
+
+export function textMetricKey({ text, fontFamily, fontSize, fontWeight }) {
+  return JSON.stringify([text, fontFamily, fontSize, fontWeight]);
+}
+
+export function textMetricFontWeight(value = "normal") {
+  if (typeof value === "number") return normalizeRendererFontWeight(value);
+  if (value === "normal") return 400;
+  if (value === "bold") return 700;
+  if (/^[1-9]00$/u.test(value)) return Number(value);
+  return undefined;
+}

package/src/core/identifiers.js

@@ -1,12 +1,13 @@
+import { annotateError } from "./diagnostics.js";
 export const USER_ID_SOURCE = "[A-Za-z0-9_-]+";
 
 const USER_ID_PATTERN = new RegExp(`^${USER_ID_SOURCE}$`);
 
 export function validateUserId(id, label = "ID") {
   if (typeof id !== "string" || !USER_ID_PATTERN.test(id)) {
-    throw new TypeError(
+    throw annotateError(new TypeError(
       `${label} must contain only letters, numbers, _ or - and must not be empty.`
-    );
+    ), { code: "invalid-value", optionPath: label });
   }
 
   return id;
@@ -20,9 +21,9 @@ export function resolveOptionalUserId(id, {
 }) {
   if (id !== undefined) return validateUserId(id, label);
   if (ambiguous) {
-    throw new Error(
+    throw annotateError(new Error(
       `${operation} requires an explicit ${label.toLowerCase()} because its default is ambiguous.`
-    );
+    ), { code: "ambiguous-resource", operation, optionPath: label });
   }
   return validateUserId(defaultId, label);
 }

package/src/core/immutable.js

@@ -22,11 +22,18 @@ export function isOwned(value) {
   return value !== null && typeof value === "object" && ownedValues.has(value);
 }
 
-export function cloneAndFreeze(value, ancestors = new WeakSet()) {
+export function cloneAndFreeze(value, ancestors = new WeakSet(), path = "state") {
+  if (typeof value === "function") {
+    throw new TypeError(`Cannot store a function at ${path} in a ChartProgram.`);
+  }
   if (value === null || typeof value !== "object") {
     return value;
   }
 
+  // Only library-owned values are recursively immutable; Object.freeze alone
+  // does not prove ownership of a caller's descendants.
+  if (isOwned(value)) return value;
+
   if (ancestors.has(value)) {
     throw new TypeError("Cannot store cyclic values in a ChartProgram.");
   }
@@ -36,12 +43,12 @@ export function cloneAndFreeze(value, ancestors = new WeakSet()) {
   let clone;
 
   if (Array.isArray(value)) {
-    clone = value.map(item => cloneAndFreeze(item, ancestors));
+    clone = value.map((item, index) => cloneAndFreeze(item, ancestors, `${path}[${index}]`));
   } else if (isPlainObject(value)) {
     clone = Object.fromEntries(
       Object.entries(value).map(([key, item]) => [
         key,
-        cloneAndFreeze(item, ancestors)
+        cloneAndFreeze(item, ancestors, `${path}.${key}`)
       ])
     );
   } else {

package/src/core/optionRequirements.js

@@ -0,0 +1,8 @@
+// The method's value-producing contract is shared by runtime validation and
+// authoring knowledge; editing can inherit these values from stored state.
+export const IMPUTE_REQUIRED_OPTIONS = Object.freeze({
+  constant: Object.freeze(["value"]),
+  forward: Object.freeze(["sortBy"]),
+  backward: Object.freeze(["sortBy"]),
+  linear: Object.freeze(["sortBy"])
+});