ggaction 0.0.13 → 0.0.16

package/src/actions/data/gradientProfile.js

@@ -9,7 +9,7 @@ const OPTIONS = Object.freeze([
   "kernel", "normalization", "center", "as"
 ]);
 
-export const materializeGradientProfileData = derivedMaterializer(
+export const materializeGradientProfileData = /* @__PURE__ */ derivedMaterializer(
   "materializeGradientProfileData",
   "Materialize one categorical density-profile dataset.",
   "gradientProfile",
@@ -24,7 +24,7 @@ export const materializeGradientProfileData = derivedMaterializer(
   }]
 );
 
-export const createGradientProfileData = derivedCreator(
+export const createGradientProfileData = /* @__PURE__ */ derivedCreator(
   "createGradientProfileData",
   "Create one immutable categorical density-profile dataset.",
   OPTIONS,

package/src/actions/data/horizon.js

@@ -26,7 +26,7 @@ function requestedTransform(args) {
   });
 }
 
-export const materializeHorizonData = derivedMaterializer(
+export const materializeHorizonData = /* @__PURE__ */ derivedMaterializer(
   "materializeHorizonData",
   "Materialize one immutable Horizon band dataset.",
   "horizon",
@@ -34,7 +34,7 @@ export const materializeHorizonData = derivedMaterializer(
   result => [{ ...result.transform, resolved: result.resolved }]
 );
 
-export const createHorizonData = derivedCreator(
+export const createHorizonData = /* @__PURE__ */ derivedCreator(
   "createHorizonData",
   "Create one immutable Horizon band dataset.",
   OPTIONS,

package/src/actions/data/impute.js

@@ -0,0 +1,26 @@
+import {
+  deriveImputedRows,
+  normalizeImputeTransform
+} from "../../grammar/impute.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
+]);
+
+export const materializeImputedData = /* @__PURE__ */ derivedMaterializer(
+  "materializeImputedData",
+  "Materialize one immutable missing-value dataset.",
+  "impute",
+  deriveImputedRows
+);
+
+export const createImputedData = /* @__PURE__ */ derivedCreator(
+  "createImputedData",
+  "Replace explicit missing cells within independent groups.",
+  OPTIONS,
+  "Imputed dataset id",
+  "Imputed source dataset id",
+  normalizeImputeTransform,
+  "materializeImputedData"
+);

package/src/actions/data/index.js

@@ -35,60 +35,75 @@ import {
   materializeBin2DData
 } from "./bin2d.js";
 import { createData } from "./create.js";
+import { reviseData } from "./revise.js";
 import { createWindowData, materializeWindowData } from "./window.js";
 import { createSummaryData, materializeSummaryData } from "./summary.js";
 import { createBinData, materializeBinData } from "./bin.js";
 import { createFoldData, materializeFoldData } from "./fold.js";
 import { createComputedData, materializeComputedData } from "./computed.js";
+import {
+  createNormalizedData,
+  materializeNormalizedData
+} from "./normalize.js";
+import { createCompleteData, materializeCompleteData } from "./complete.js";
+import { createImputedData, materializeImputedData } from "./impute.js";
 import { createStackData, materializeStackData } from "./stack.js";
+import { EDIT_DERIVED_DATA_ACTIONS } from "./edit.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
-  ProgramClass.prototype.createData = createData;
-  ProgramClass.prototype.createDerivedData = createDerivedData;
-  ProgramClass.prototype.bindMarkData = bindMarkData;
-  ProgramClass.prototype.releaseDerivedData = releaseDerivedData;
-  ProgramClass.prototype.rebindLayerData = rebindLayerData;
-  ProgramClass.prototype.createDensityData = createDensityData;
-  ProgramClass.prototype.createCategoricalDensityData =
-    createCategoricalDensityData;
-  ProgramClass.prototype.materializeFilteredData = materializeFilteredData;
-  ProgramClass.prototype.materializeMarkFilteredData = materializeMarkFilteredData;
-  ProgramClass.prototype.filterData = filterData;
-  ProgramClass.prototype.filterMarks = filterMarks;
-  ProgramClass.prototype.materializeEmptyMark = materializeEmptyMark;
-  ProgramClass.prototype.removeMarkFilter = removeMarkFilter;
-  ProgramClass.prototype.materializeRegressionData = materializeRegressionData;
-  ProgramClass.prototype.materializeDensityData = materializeDensityData;
-  ProgramClass.prototype.createGradientProfileData = createGradientProfileData;
-  ProgramClass.prototype.materializeGradientProfileData =
-    materializeGradientProfileData;
-  ProgramClass.prototype.createRegressionData = createRegressionData;
-  ProgramClass.prototype.materializeIntervalData = materializeIntervalData;
-  ProgramClass.prototype.createIntervalData = createIntervalData;
-  ProgramClass.prototype.createECDFData = createECDFData;
-  ProgramClass.prototype.materializeECDFData = materializeECDFData;
-  ProgramClass.prototype.createHorizonData = createHorizonData;
-  ProgramClass.prototype.materializeHorizonData = materializeHorizonData;
-  ProgramClass.prototype.createWindowData = createWindowData;
-  ProgramClass.prototype.materializeWindowData = materializeWindowData;
-  ProgramClass.prototype.createSummaryData = createSummaryData;
-  ProgramClass.prototype.materializeSummaryData = materializeSummaryData;
-  ProgramClass.prototype.createBinData = createBinData;
-  ProgramClass.prototype.materializeBinData = materializeBinData;
-  ProgramClass.prototype.createFoldData = createFoldData;
-  ProgramClass.prototype.materializeFoldData = materializeFoldData;
-  ProgramClass.prototype.createComputedData = createComputedData;
-  ProgramClass.prototype.materializeComputedData = materializeComputedData;
-  ProgramClass.prototype.createStackData = createStackData;
-  ProgramClass.prototype.materializeStackData = materializeStackData;
-  ProgramClass.prototype.createTimeUnitData = createTimeUnitData;
-  ProgramClass.prototype.materializeTimeUnitData = materializeTimeUnitData;
-  ProgramClass.prototype.createBin2DData = createBin2DData;
-  ProgramClass.prototype.editBin2DData = editBin2DData;
-  ProgramClass.prototype.materializeBin2DData = materializeBin2DData;
-  ProgramClass.prototype.createBoxSummaryData = createBoxSummaryData;
-  ProgramClass.prototype.createBoxOutlierData = createBoxOutlierData;
-  ProgramClass.prototype.materializeBoxSummaryData = materializeBoxSummaryData;
-  ProgramClass.prototype.materializeBoxOutlierData = materializeBoxOutlierData;
+  Object.assign(ProgramClass.prototype, EDIT_DERIVED_DATA_ACTIONS, {
+    createData,
+    reviseData,
+    createDerivedData,
+    bindMarkData,
+    releaseDerivedData,
+    rebindLayerData,
+    createDensityData,
+    createCategoricalDensityData,
+    materializeFilteredData,
+    materializeMarkFilteredData,
+    filterData,
+    filterMarks,
+    materializeEmptyMark,
+    removeMarkFilter,
+    materializeRegressionData,
+    materializeDensityData,
+    createGradientProfileData,
+    materializeGradientProfileData,
+    createRegressionData,
+    materializeIntervalData,
+    createIntervalData,
+    createECDFData,
+    materializeECDFData,
+    createHorizonData,
+    materializeHorizonData,
+    createWindowData,
+    materializeWindowData,
+    createSummaryData,
+    materializeSummaryData,
+    createBinData,
+    materializeBinData,
+    createFoldData,
+    materializeFoldData,
+    createComputedData,
+    materializeComputedData,
+    createNormalizedData,
+    materializeNormalizedData,
+    createCompleteData,
+    materializeCompleteData,
+    createImputedData,
+    materializeImputedData,
+    createStackData,
+    materializeStackData,
+    createTimeUnitData,
+    materializeTimeUnitData,
+    createBin2DData,
+    editBin2DData,
+    materializeBin2DData,
+    createBoxSummaryData,
+    createBoxOutlierData,
+    materializeBoxSummaryData,
+    materializeBoxOutlierData
+  });
 }

package/src/actions/data/interval.js

@@ -16,14 +16,14 @@ const OPTIONS = Object.freeze([
   "as"
 ]);
 
-export const materializeIntervalData = derivedMaterializer(
+export const materializeIntervalData = /* @__PURE__ */ derivedMaterializer(
   "materializeIntervalData",
   "Materialize one grouped interval-summary dataset.",
   "interval",
   deriveInterval
 );
 
-export const createIntervalData = derivedCreator(
+export const createIntervalData = /* @__PURE__ */ derivedCreator(
   "createIntervalData",
   "Create immutable grouped interval-summary values.",
   OPTIONS,

package/src/actions/data/intervalEdit.js

@@ -138,13 +138,7 @@ export function planIntervalRoleData(program, {
   };
 }
 
-export function planIntervalEdit(program, {
-  owner,
-  data,
-  consumers,
-  statistics,
-  operation
-}) {
+export function validateIntervalStatistics(statistics, operation) {
   if (!isPlainObject(statistics)) {
     throw new TypeError(`${operation} statistics must be a plain object.`);
   }
@@ -154,16 +148,9 @@ export function planIntervalEdit(program, {
       `${operation} statistics requires center, extent, method, or level.`
     );
   }
-  const previous = findDataset(program, data);
-  const transform = previous?.transform?.length === 1
-    ? previous.transform[0]
-    : undefined;
-  if (transform?.type !== "interval") {
-    throw new Error(
-      `${operation} statistics requires a statistical interval owner; ` +
-      "explicit interval fields cannot be converted by edit."
-    );
-  }
+}
+
+export function mergeIntervalStatistics(transform, statistics) {
   const center = Object.hasOwn(statistics, "center")
     ? statistics.center
     : transform.center;
@@ -181,7 +168,28 @@ export function planIntervalEdit(program, {
   } else if (extent === "ci" && transform.extent === "ci") {
     raw.level = transform.level;
   }
-  const parameters = normalizeIntervalParameters(raw);
+  return normalizeIntervalParameters(raw);
+}
+
+export function planIntervalEdit(program, {
+  owner,
+  data,
+  consumers,
+  statistics,
+  operation
+}) {
+  validateIntervalStatistics(statistics, operation);
+  const previous = findDataset(program, data);
+  const transform = previous?.transform?.length === 1
+    ? previous.transform[0]
+    : undefined;
+  if (transform?.type !== "interval") {
+    throw new Error(
+      `${operation} statistics requires a statistical interval owner; ` +
+      "explicit interval fields cannot be converted by edit."
+    );
+  }
+  const parameters = mergeIntervalStatistics(transform, statistics);
   const current = {
     center: transform.center,
     extent: transform.extent,

package/src/actions/data/normalize.js

@@ -0,0 +1,27 @@
+import {
+  deriveNormalizedRows,
+  normalizeNormalizeTransform
+} from "../../grammar/normalize.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "field", "as", "groupBy", "method",
+  "variance", "zeroDenominator", "baseline", "sortBy"
+]);
+
+export const materializeNormalizedData = /* @__PURE__ */ derivedMaterializer(
+  "materializeNormalizedData",
+  "Materialize one immutable grouped normalization dataset.",
+  "normalize",
+  deriveNormalizedRows
+);
+
+export const createNormalizedData = /* @__PURE__ */ derivedCreator(
+  "createNormalizedData",
+  "Create a row-preserving grouped normalization dataset.",
+  OPTIONS,
+  "Normalized dataset id",
+  "Normalized source dataset id",
+  normalizeNormalizeTransform,
+  "materializeNormalizedData"
+);

package/src/actions/data/regression.js

@@ -1,10 +1,11 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import {
   deriveRegression,
-  normalizeRegressionParameters
+  normalizeRegressionTransform
 } from "../../grammar/regression/index.js";
+import { resolveDatasetReference } from "../../selectors/datasets.js";
 import { derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
@@ -12,7 +13,7 @@ const OPTIONS = Object.freeze([
   "confidenceMethod", "level", "confidence", "interval"
 ]);
 
-export const materializeRegressionData = derivedMaterializer(
+export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
   "materializeRegressionData",
   "Materialize one regression derived dataset.",
   "regression",
@@ -30,35 +31,28 @@ export const materializeRegressionData = derivedMaterializer(
     })
 );
 
-export const createRegressionData = action(
-  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." },
+export const createRegressionData = /* @__PURE__ */ closedAction(
+  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createRegressionData");
-    const parameters = normalizeRegressionParameters(args);
     const id = validateUserId(args.id, "Regression dataset id");
-    const source = validateUserId(
+    const requestedSource = validateUserId(
       args.source ?? this.context.currentData,
       "Source dataset id"
     );
-    const transform = {
-      type: "regression",
-      method: parameters.method,
-      x: args.x,
-      y: args.y,
-      ...(args.groupBy === undefined ? {} : { groupBy: args.groupBy }),
-      ...(parameters.method === "polynomial"
-        ? { degree: parameters.degree }
-        : {}),
-      ...(parameters.method === "loess"
-        ? { span: parameters.span }
-        : {
-            confidenceMethod: parameters.confidenceMethod,
-            level: parameters.level,
-            interval: parameters.interval
-          })
-    };
-    return this
+    const source = resolveDatasetReference(
+      this,
+      requestedSource,
+      "Regression source dataset"
+    ).id;
+    const transform = normalizeRegressionTransform(args);
+    const next = this
       .createDerivedData({ id, source, transform: [transform] })
       .materializeRegressionData({ id });
+    return this.actionStack.length === 1
+      ? next._withMaterializationConfig(
+          ["data", "regression", id],
+          { current: id }
+        )
+      : next;
   }
 );

package/src/actions/data/revise.js

@@ -0,0 +1,48 @@
+import { closedAction } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+
+import { requireDataset } from "../../selectors/datasets.js";
+import { requireLayer } from "../../selectors/layers.js";
+import { applyRevisionPlan, buildSourceRevisionPlan } from "./edit.js";
+import { resolveStoredSelection } from "../../materialization/selection/state.js";
+import { withGuideLayoutTransaction } from "../../materialization/guides/layout.js";
+
+let reviseFacet;
+
+export function registerFacetDataRevision(handler) {
+  reviseFacet = handler;
+}
+
+export function reviseUnitData(program, { source, id, values }) {
+  const plan = buildSourceRevisionPlan(program, source, id);
+  const created = program.createData({ id, values });
+  const next = withGuideLayoutTransaction(created, candidate =>
+    applyRevisionPlan(candidate, undefined, plan, { retain: new Set([source]) }));
+  for (const [selection, config] of Object.entries(next.materializationConfigs.selections ?? {})) {
+    if (plan.replacements.has(requireLayer(program, config.target).data)) {
+      resolveStoredSelection(next, selection);
+    }
+  }
+  return { program: next, plan };
+}
+
+export const reviseData = /* @__PURE__ */ closedAction(
+  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values"],
+  function (args = {}) {
+    const source = validateUserId(args.source, "Source dataset id");
+    const id = validateUserId(args.id, "Revision dataset id");
+    if (this.compositionSpec !== undefined && this.compositionSpec.type !== "facet") {
+      throw new Error("Revise an explicit child, then use replaceCompositionChild for concat.");
+    }
+    const original = requireDataset(this, source);
+    if (original.source !== undefined || !Array.isArray(original.values)) {
+      throw new Error(`Source "${source}" must be a materialized original dataset.`);
+    }
+    const apply = this.compositionSpec === undefined
+      ? program => reviseUnitData(program, { source, id, values: args.values }).program
+      : program => reviseFacet(program, { source, id, values: args.values });
+    // The entire dependent materialization must succeed before returning a revision.
+    apply(this);
+    return apply(this);
+  }
+);

package/src/actions/data/revisionBindings.js

@@ -0,0 +1,125 @@
+import { collectDataOwnerReferences, collectMarkConfigReferences } from "../../core/resourceReferences.js";
+import { datasetTransformOutputRoles } from "../../grammar/transforms.js";
+import { requireLayer } from "../../selectors/layers.js";
+
+
+export function outputFieldChanges(previous, next) {
+  const before = datasetTransformOutputRoles(previous);
+  const after = datasetTransformOutputRoles(next);
+  const family = previous.type === "bin2d" ? "2D bin " : "";
+  const counts = new Map();
+  const retainedFields = new Set(Object.values(after));
+  for (const field of Object.values(before)) {
+    counts.set(field, (counts.get(field) ?? 0) + 1);
+  }
+  return new Map(Object.entries(before).flatMap(([role, field]) => {
+    if (field === after[role] || retainedFields.has(field)) return [];
+    if (counts.get(field) !== 1) {
+      throw new Error(
+        `Cannot rebind ambiguous derived output field "${field}".`
+      );
+    }
+    return [[field, { role, next: after[role], family }]];
+  }));
+}
+
+function changedConsumerField(field, changes) {
+  const change = changes.get(field);
+  if (change === undefined) return field;
+  if (change.next === undefined) {
+    throw new Error(
+      `Cannot remove referenced ${change.family}${change.role} output field "${field}".`
+    );
+  }
+  return change.next;
+}
+
+export function rebindLayerOutputFields(program, id, changes) {
+  const layer = requireLayer(program, id);
+  let next = program;
+  const changed = field => changedConsumerField(field, changes);
+  const editField = (property, field) => {
+    if (field === undefined) return;
+    const value = changed(field);
+    if (value !== field) next = next.editSemantic({ property, value });
+  };
+  for (const [channel, encoding] of Object.entries(layer.encoding ?? {})) {
+    editField(`layer[${id}].encoding.${channel}.field`, encoding?.field);
+    const summary = encoding?.categoryOrder?.by;
+    if (summary?.field !== undefined) {
+      const field = changed(summary.field);
+      if (field !== summary.field) {
+        next = next.editSemantic({
+          property: `layer[${id}].encoding.${channel}.categoryOrder`,
+          value: { ...encoding.categoryOrder, by: { ...summary, field } }
+        });
+      }
+    }
+  }
+  editField(
+    `layer[${id}].encoding.theta.weight`,
+    layer.encoding?.theta?.weight
+  );
+
+  const parallel = layer.encoding?.parallel;
+  if (parallel?.dimensions !== undefined) {
+    const dimensions = parallel.dimensions.map(dimension => ({
+      ...dimension,
+      field: changed(dimension.field)
+    }));
+    if (dimensions.some((dimension, index) =>
+      dimension.field !== parallel.dimensions[index].field
+    )) {
+      next = next.editSemantic({
+        property: `layer[${id}].encoding.parallel.dimensions`,
+        value: dimensions
+      });
+    }
+  }
+  editField(`layer[${id}].encoding.parallel.key`, parallel?.key);
+
+  for (const [selectionId, config] of Object.entries(
+    program.materializationConfigs.selections ?? {}
+  )) {
+    if (config.target !== id) continue;
+    const selector = { ...config.selector };
+    if (selector.field !== undefined) selector.field = changed(selector.field);
+    if (selector.groupBy !== undefined) {
+      selector.groupBy = selector.groupBy.map(changed);
+    }
+    if (JSON.stringify(selector) !== JSON.stringify(config.selector)) {
+      next = next._withSelectionConfig(selectionId, { ...config, selector });
+    }
+  }
+
+  const jitter = program.materializationConfigs.jitters?.[id];
+  const key = jitter?.key === undefined ? undefined : changed(jitter.key);
+  if (key !== undefined && key !== jitter.key) {
+    next = next._withMaterializationConfig(
+      ["jitters", id],
+      { ...jitter, key }
+    );
+  }
+  return next;
+}
+
+function replaceAtPath(value, [key, ...rest], replacement) {
+  const result = Array.isArray(value) ? [...value] : { ...value };
+  Object.defineProperty(result, key, { value: rest.length === 0
+    ? replacement : replaceAtPath(value[key], rest, replacement),
+    enumerable: true, configurable: true, writable: true });
+  return result;
+}
+
+export function rebindMaterializationDataReferences(program, replacements) {
+  if (replacements.size === 0) return program;
+  let next = program;
+  for (const ref of [...collectMarkConfigReferences(program), ...collectDataOwnerReferences(program)]) {
+    if (ref.kind !== "data" || !replacements.has(ref.id)) continue;
+    const path = ref.ownerKind === "markConfig" ? ["marks", ref.ownerId, ...ref.path] : ref.path;
+    const [root, ...rest] = path;
+    next = next._withMaterializationConfig([root],
+      replaceAtPath(next.materializationConfigs[root], rest, replacements.get(ref.id)));
+  }
+  return next;
+}

package/src/actions/data/shared.js

@@ -1,7 +1,10 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
-import { findDataset } from "../../selectors/datasets.js";
+import {
+  findDataset,
+  resolveDatasetReference
+} from "../../selectors/datasets.js";
 
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
@@ -61,12 +64,25 @@ export function derivedCreator(
   return action({ op, description }, function (args = {}) {
     validateKeys(args, options, op);
     const id = validateUserId(args.id, idLabel);
-    const source = validateUserId(
+    const requestedSource = validateUserId(
       requireSource ? args.source : args.source ?? this.context.currentData,
       sourceLabel
     );
-    return this
-      .createDerivedData({ id, source, transform: [transform(args, id)] })
+    const source = resolveDatasetReference(
+      this,
+      requestedSource,
+      sourceLabel
+    ).id;
+    const standalone = this.actionStack.length === 1;
+    const requestedTransform = transform(args, id);
+    const next = this
+      .createDerivedData({ id, source, transform: [requestedTransform] })
       [materialize]({ id });
+    return standalone
+      ? next._withMaterializationConfig(
+          ["data", requestedTransform.type, id],
+          { current: id }
+        )
+      : next;
   });
 }

package/src/actions/data/stack.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "category", "group", "value", "mode", "as"
 ]);
 
-export const materializeStackData = derivedMaterializer(
+export const materializeStackData = /* @__PURE__ */ derivedMaterializer(
   "materializeStackData",
   "Materialize one immutable category/series stack dataset.",
   "stack",
   deriveStackRows
 );
 
-export const createStackData = derivedCreator(
+export const createStackData = /* @__PURE__ */ derivedCreator(
   "createStackData",
   "Create reusable start, end, value, and share stack rows.",
   OPTIONS,

package/src/actions/data/summary.js

@@ -5,17 +5,17 @@ import {
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "groupBy", "aggregates", "members"
+  "id", "source", "groupBy", "aggregates", "members", "weight"
 ]);
 
-export const materializeSummaryData = derivedMaterializer(
+export const materializeSummaryData = /* @__PURE__ */ derivedMaterializer(
   "materializeSummaryData",
   "Materialize one immutable grouped summary dataset.",
   "summary",
   deriveSummaryRows
 );
 
-export const createSummaryData = derivedCreator(
+export const createSummaryData = /* @__PURE__ */ derivedCreator(
   "createSummaryData",
   "Create reusable grouped aggregate values and provenance.",
   OPTIONS,

package/src/actions/data/timeUnit.js

@@ -4,16 +4,19 @@ import {
 } from "../../grammar/timeUnit.js";
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
-const OPTIONS = Object.freeze(["id", "source", "field", "unit", "as", "temporalUnit"]);
+const OPTIONS = Object.freeze([
+  "id", "source", "field", "unit", "as", "temporalUnit", "timeZone",
+  "weekStartsOn", "weekRule"
+]);
 
-export const materializeTimeUnitData = derivedMaterializer(
+export const materializeTimeUnitData = /* @__PURE__ */ derivedMaterializer(
   "materializeTimeUnitData",
   "Materialize one immutable UTC time-unit dataset.",
   "timeUnit",
   deriveTimeUnitRows
 );
 
-export const createTimeUnitData = derivedCreator(
+export const createTimeUnitData = /* @__PURE__ */ derivedCreator(
   "createTimeUnitData",
   "Create immutable UTC calendar bucket values.",
   OPTIONS,