ggaction 0.0.21 → 0.0.23

package/src/actions/data/edit.js

@@ -1,7 +1,10 @@
+import {resolveDatasetTransformInputs} from "./shared.js";
 import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
+import {orderedDatasetDependents} from "../../grammar/datasetDependencies.js";
+import {rebindTransformDatasetInputs} from "../../core/datasetReferences.js";
 import {
   findTransformPolicy,
   normalizeDatasetTransformEdit,
@@ -33,6 +36,8 @@ const CREATOR_BY_TYPE = Object.freeze({
   density: "createDensityData",
   ecdf: "createECDFData",
   filter: "filterData",
+  flatten: "createFlattenData",
+  lookup:"createLookupData",
   fold: "createFoldData",
   impute: "createImputedData",
   interval: "createIntervalData",
@@ -53,6 +58,8 @@ const REVISION_ROLE = Object.freeze({
   density: "DensityData",
   ecdf: "ECDFData",
   filter: "FilteredData",
+  flatten: "FlattenData",
+  lookup:"LookupData",
   fold: "FoldData",
   impute: "ImputedData",
   interval: "IntervalData",
@@ -168,30 +175,9 @@ export function normalizeDerivedDependentPolicy(value) {
 }
 
 function downstreamDatasets(program, root) {
-  const order = new Map(
-    program.semanticSpec.datasets.map((dataset, index) => [dataset.id, index])
-  );
-  const bySource = new Map();
-  for (const dataset of program.semanticSpec.datasets) {
-    if (dataset.source === undefined) continue;
-    const children = bySource.get(dataset.source) ?? [];
-    children.push(dataset);
-    bySource.set(dataset.source, children);
-  }
-  for (const children of bySource.values()) {
-    children.sort((left, right) => order.get(left.id) - order.get(right.id));
-  }
-
-  const result = [];
-  const visiting = new Set();
-  const visited = new Set();
-  function visit(id) {
-    if (visiting.has(id)) {
-      throw new Error(`Derived dataset dependency graph contains a cycle at "${id}".`);
-    }
-    if (visited.has(id)) return;
-    visiting.add(id);
-    for (const child of bySource.get(id) ?? []) {
+  // Statistical reference data is an owned cache; its mark lifecycle replays it.
+  const result=orderedDatasetDependents(program.semanticSpec.datasets,root,{skip:dataset=>dataset.transform?.[0]?.type==="statisticalReference"});
+  for(const child of result){
       if (child.transform?.length !== 1) {
         throw new Error(
           `Derived dataset "${child.id}" requires one replayable transform.`
@@ -204,16 +190,7 @@ function downstreamDatasets(program, root) {
           `"${child.transform[0].type ?? "unknown"}".`
         );
       }
-      // Statistical reference data is an owned cache. Its mark lifecycle
-      // reconnects and recomputes it after the visible source mark is rebound.
-      if (child.transform[0].type === "statisticalReference") continue;
-      result.push(child);
-      visit(child.id);
-    }
-    visiting.delete(id);
-    visited.add(id);
   }
-  visit(root);
   return result;
 }
 
@@ -260,6 +237,7 @@ function buildRevisionPlan(
       `Derived dataset "${resolved.owner}" cannot use one of its dependents as source.`
     );
   }
+  if(definition?.type==="lookup"&&[resolved.current,...downstream.map(d=>d.id)].includes(definition.lookup.data))throw new Error(`Derived dataset "${resolved.owner}" cannot use its own result or dependent as lookup data.`);
   const reserved = new Set(resolved.revision === undefined ? [] : [resolved.revision]);
   const revisions = [];
   const replacements = new Map();
@@ -273,7 +251,7 @@ function buildRevisionPlan(
       old: dataset.id,
       id,
       source,
-      transform,
+      transform:rebindTransformDatasetInputs(transform,replacements),
       family: ownerRecord?.family,
       owner: ownerRecord?.owner
     };
@@ -422,7 +400,7 @@ export const editDerivedData = /* @__PURE__ */ closedAction(
       args.target,
       args.definition.type
     );
-    const definition = requestedDatasetTransform(args.definition);
+    const definition = resolveDatasetTransformInputs(this,requestedDatasetTransform(args.definition));
     findTransformPolicy(definition.type).validate(definition);
     const previous = requestedDatasetTransform(resolved.dataset.transform[0]);
     if (sameRequested(definition, previous)) return this;
@@ -477,6 +455,12 @@ export const editComputedData = /* @__PURE__ */ focusedEditor(
 export const editFilteredData = /* @__PURE__ */ focusedEditor(
   "editFilteredData", "filter", ["field", "oneOf", "noneOf", "predicate", "range", "nulls"]
 );
+export const editFlattenData = /* @__PURE__ */ focusedEditor(
+  "editFlattenData", "flatten", ["fields", "as"]
+);
+export const editLookupData=/* @__PURE__ */focusedEditor(
+  "editLookupData","lookup",["field","lookup"]
+);
 export const editFoldData = /* @__PURE__ */ focusedEditor(
   "editFoldData", "fold", ["fields", "as"]
 );
@@ -492,7 +476,7 @@ export const editBinData = /* @__PURE__ */ focusedEditor(
 export const editTimeUnitData = /* @__PURE__ */ focusedEditor(
   "editTimeUnitData", "timeUnit", [
     "field", "unit", "as", "temporalUnit", "timeZone", "weekStartsOn",
-    "weekRule"
+    "weekRule", "missing"
   ]
 );
 export const editWindowData = /* @__PURE__ */ focusedEditor(
@@ -549,6 +533,8 @@ export const EDIT_DERIVED_DATA_ACTIONS = Object.freeze({
   editDerivedData,
   editComputedData,
   editFilteredData,
+  editFlattenData,
+  editLookupData,
   editFoldData,
   editSummaryData,
   editBinData,

package/src/actions/data/filter.js

@@ -1,376 +1 @@
-import { closedAction } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-
-import { withPreviewDatasetValues } from
-  "../primitives/semanticAction.js";
-import {
-  deriveFilteredRows,
-  normalizeFilterTransform
-} from "../../grammar/filter.js";
-import {
-  deriveMarkFilteredRows,
-  markFilterSelectors,
-  normalizeMarkFilterTransform
-} from "../../grammar/markFilter.js";
-import { resolveMarkFilterSelection } from "../../materialization/selection/filter.js";
-import { findSelectionPolicy } from
-  "../../materialization/selection/policies/index.js";
-import {
-  applyLayerDataRematerialization,
-  applyLayerEmptyDataView
-} from "../../materialization/dependencies.js";
-import {
-  hasDataset,
-  findDataset,
-  resolveDatasetReference,
-  requireLayer,
-  resolveEligibleLayer
-} from "../../selectors/index.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
-import {
-  assertFieldsAvailable,
-  deriveTransformSchema,
-  transformInputFields
-} from "../../grammar/datasetSchema.js";
-
-const OPTIONS = Object.freeze([
-  "id", "source", "field", "oneOf", "noneOf", "predicate", "range", "nulls"
-]);
-const MARK_SELECTOR_KEYS = Object.freeze([
-  "grain", "field", "channel", "property", "op", "value", "values",
-  "min", "max", "inclusive", "count", "groupBy", "ties"
-]);
-const MARK_OPTIONS = Object.freeze(["target", "mode", ...MARK_SELECTOR_KEYS]);
-const REMOVE_MARK_FILTER_OPTIONS = Object.freeze(["target"]);
-const EMPTY_MARK_OPTIONS = Object.freeze(["id"]);
-
-function retainedHistogramBoundaries(layer, items) {
-  if (layer.mark?.type !== "bar" || layer.encoding?.x?.bin === undefined) {
-    return undefined;
-  }
-  const boundaries = [...new Set(items.flatMap(item => [
-    item.channels.x,
-    item.channels.x2
-  ]).filter(Number.isFinite))].sort((left, right) => left - right);
-  return boundaries.length < 2 ? undefined : boundaries;
-}
-
-export const materializeFilteredData = /* @__PURE__ */ closedAction(
-  { op: "materializeFilteredData", description: "Materialize one filtered derived dataset." }, MATERIALIZE_OPTIONS,
-  function (args = {}) {
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "filter"
-    );
-    assertFieldsAvailable(source.schema, transformInputFields(transform), {
-      data: source.id,
-      operation: "materializeFilteredData"
-    });
-    const values = deriveFilteredRows(source.values, transform);
-    const schema = deriveTransformSchema(source.schema, transform, values, {
-      sourceId: source.id,
-      ownerId: id
-    });
-    return this.editSemantic({ property: `dataset[${id}].values`, value: values });
-  }
-);
-
-export const filterData = /* @__PURE__ */ closedAction(
-  { op: "filterData", description: "Create a named dataset from one field filter." }, OPTIONS,
-  function (args = {}) {
-    const id = validateUserId(args.id, "Filtered dataset id");
-    const requestedSource = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
-    const source = resolveDatasetReference(
-      this,
-      requestedSource,
-      "Filter source dataset"
-    ).id;
-    const transform = normalizeFilterTransform(args);
-    const next = this
-      .createDerivedData({
-        id,
-        source,
-        transform: [transform]
-      })
-      .materializeFilteredData({ id });
-    return this.actionStack.length === 1
-      ? next._withMaterializationConfig(
-          ["data", "filter", id],
-          { current: id }
-        )
-      : next;
-  }
-);
-
-export const materializeMarkFilteredData = /* @__PURE__ */ closedAction(
-  {
-    op: "materializeMarkFilteredData",
-    description: "Materialize member rows retained by one final-item mark selection."
-  }, MATERIALIZE_OPTIONS,
-  function (args = {}) {
-    const { id, dataset, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "markFilter"
-    );
-    const layer = requireLayer(this, transform.target);
-    if (layer?.data !== dataset.source) {
-      throw new Error(
-        `Mark filter target "${transform.target}" must still use source dataset "${dataset.source}".`
-      );
-    }
-    let preview = this;
-    let currentRows = source.values;
-    const selectors = markFilterSelectors(transform);
-    for (const [index, selector] of selectors.entries()) {
-      const resolved = resolveMarkFilterSelection(
-        preview,
-        transform.target,
-        selector
-      );
-      currentRows = deriveMarkFilteredRows(
-        currentRows,
-        resolved.items,
-        resolved.keys
-      );
-      if (index < selectors.length - 1) {
-        preview = withPreviewDatasetValues(preview, {
-          id,
-          values: currentRows,
-          target: transform.target
-        });
-        preview = currentRows.length === 0
-          ? applyLayerEmptyDataView(preview, transform.target)
-          : applyLayerDataRematerialization(preview, transform.target);
-        currentRows = findDataset(preview, id).values;
-      }
-    }
-    if (selectors.length > 1) {
-      preview = withPreviewDatasetValues(preview, {
-        id,
-        omitValues: true
-      });
-    }
-    let next = preview.editSemantic({
-      property: `dataset[${id}].values`,
-      value: currentRows
-    });
-    if (requireLayer(next, transform.target).data !== id) {
-      next = next.editSemantic({
-        property: `layer[${transform.target}].data`,
-        value: id
-      });
-    }
-    next = next._withMarkConfig(transform.target, {
-      ...next.markConfigs[transform.target],
-      markFilter: {
-        ...next.markConfigs[transform.target].markFilter,
-        empty: currentRows.length === 0
-      }
-    });
-    return currentRows.length === 0
-      ? next.materializeEmptyMark({ id: transform.target })
-      : applyLayerDataRematerialization(next, transform.target);
-  }
-);
-
-export const materializeEmptyMark = /* @__PURE__ */ closedAction(
-  {
-    op: "materializeEmptyMark",
-    description: "Clear one active empty-filter mark without changing its domains."
-  }, EMPTY_MARK_OPTIONS,
-  function (args = {}) {
-    const id = validateUserId(args.id, "Empty mark id");
-    const layer = requireLayer(this, id);
-    const owner = this.markConfigs[id]?.markFilter;
-    const dataset = findDataset(this, layer.data);
-    if (owner?.empty !== true || dataset?.values?.length !== 0) {
-      throw new Error(`Mark "${id}" does not own an active empty filter.`);
-    }
-    return applyLayerEmptyDataView(this, id);
-  }
-);
-
-function activeMarkFilter(program, layer) {
-  const configured = program.markConfigs[layer.id]?.markFilter;
-  const dataset = findDataset(program, layer.data);
-  const transform = dataset?.transform?.[0];
-  if (
-    dataset?.source === undefined ||
-    transform?.type !== "markFilter" ||
-    transform.target !== layer.id
-  ) {
-    return undefined;
-  }
-  return {
-    dataset: dataset.id,
-    source: dataset.source,
-    selectors: markFilterSelectors(transform),
-    ...(configured?.originalBin === undefined
-      ? {}
-      : { originalBin: configured.originalBin })
-  };
-}
-
-function withoutMarkFilterConfig(program, id) {
-  const config = program.markConfigs[id] ?? {};
-  const { markFilter: unused, ...remaining } = config;
-  void unused;
-  return program._withMarkConfig(id, remaining);
-}
-
-function restoreHistogramBin(program, layer, originalBin) {
-  let next = program;
-  const current = layer.encoding?.x?.bin ?? {};
-  for (const property of ["maxBins", "step", "boundaries"]) {
-    if (Object.hasOwn(originalBin, property)) {
-      next = next.editSemantic({
-        property: `layer[${layer.id}].encoding.x.bin.${property}`,
-        value: originalBin[property]
-      });
-    } else if (Object.hasOwn(current, property)) {
-      next = next.editSemantic({
-        property: `layer[${layer.id}].encoding.x.bin.${property}`,
-        remove: true
-      });
-    }
-  }
-  return next;
-}
-
-function removeActiveMarkFilter(program, layer, owner) {
-  let next = program.editSemantic({
-    property: `layer[${layer.id}].data`,
-    value: owner.source
-  });
-  if (owner.originalBin !== undefined) {
-    next = restoreHistogramBin(next, requireLayer(next, layer.id), owner.originalBin);
-  }
-  next = withoutMarkFilterConfig(next, layer.id)
-    .releaseDerivedData({ id: owner.dataset })
-    ._withContext({ currentData: owner.source });
-  return applyLayerDataRematerialization(next, layer.id);
-}
-
-function nextMarkFilterDatasetId(program, layerId) {
-  const base = `${layerId}FilteredData`;
-  if (!hasDataset(program, base)) return base;
-  let revision = 2;
-  while (hasDataset(program, `${base}${revision}`)) revision += 1;
-  return `${base}${revision}`;
-}
-
-function sameSelector(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
-export const removeMarkFilter = /* @__PURE__ */ closedAction(
-  {
-    op: "removeMarkFilter",
-    description: "Remove one active final-item filter and restore its source."
-  }, REMOVE_MARK_FILTER_OPTIONS,
-  function (args = {}) {
-    const target = args.target === undefined
-      ? undefined
-      : validateUserId(args.target, "Mark filter target id");
-    const layer = resolveEligibleLayer(this, {
-      target,
-      label: "mark filter",
-      predicate: candidate => activeMarkFilter(this, candidate) !== undefined
-    });
-    return removeActiveMarkFilter(this, layer, activeMarkFilter(this, layer));
-  }
-);
-
-export const filterMarks = /* @__PURE__ */ closedAction(
-  {
-    op: "filterMarks",
-    description: "Retain selected final mark items through immutable derived data."
-  }, MARK_OPTIONS,
-  function (args = {}) {
-    if (args.mode !== undefined && !["replace", "compose"].includes(args.mode)) {
-      throw new Error(`Unknown mark filter mode "${args.mode}".`);
-    }
-    const target = args.target === undefined
-      ? undefined
-      : validateUserId(args.target, "Filter mark target id");
-    const layer = resolveEligibleLayer(this, {
-      target,
-      label: "filter mark",
-      predicate: candidate =>
-        candidate.data !== undefined &&
-        findSelectionPolicy(candidate.mark?.type) !== undefined
-    });
-    if (this.markConfigs[layer.id]?.itemFilterable === false) {
-      throw new Error(
-        `filterMarks does not support composite mark "${layer.id}"; filter its source dataset first.`
-      );
-    }
-    const owner = activeMarkFilter(this, layer);
-    const selector = Object.fromEntries(
-      MARK_SELECTOR_KEYS.flatMap(key =>
-        Object.hasOwn(args, key) ? [[key, args[key]]] : []
-      )
-    );
-    const resolved = resolveMarkFilterSelection(this, layer.id, selector);
-    const previousSelector = owner?.selectors.at(-1);
-    if (previousSelector !== undefined && sameSelector(previousSelector, resolved.selector)) {
-      return this;
-    }
-    if (owner !== undefined && args.mode === undefined) {
-      throw new Error(
-        "Repeated filterMarks requires mode \"replace\" or \"compose\"."
-      );
-    }
-    const selectors = owner === undefined || args.mode === "replace"
-      ? [resolved.selector]
-      : [...owner.selectors, resolved.selector];
-    let next = owner === undefined
-      ? this
-      : removeActiveMarkFilter(this, layer, owner);
-    const baseLayer = requireLayer(next, layer.id);
-    const first = resolveMarkFilterSelection(next, layer.id, selectors[0]);
-    const transform = normalizeMarkFilterTransform(layer.id, selectors);
-    const boundaries = retainedHistogramBoundaries(baseLayer, first.items);
-    const originalBin = baseLayer.mark?.type === "bar" &&
-      baseLayer.encoding?.x?.bin !== undefined
-      ? baseLayer.encoding.x.bin
-      : undefined;
-    const derivedId = nextMarkFilterDatasetId(next, layer.id);
-    next = next
-      .createDerivedData({
-        id: derivedId,
-        source: baseLayer.data,
-        transform: [transform]
-      });
-    if (boundaries !== undefined) {
-      for (const property of ["maxBins", "step"]) {
-        if (Object.hasOwn(baseLayer.encoding.x.bin, property)) {
-          next = next.editSemantic({
-            property: `layer[${baseLayer.id}].encoding.x.bin.${property}`,
-            remove: true
-          });
-        }
-      }
-      next = next.editSemantic({
-        property: `layer[${baseLayer.id}].encoding.x.bin.boundaries`,
-        value: boundaries
-      });
-    }
-    next = next._withMarkConfig(baseLayer.id, {
-      ...next.markConfigs[baseLayer.id],
-      markFilter: {
-        dataset: derivedId,
-        source: baseLayer.data,
-        selectors,
-        empty: false,
-        ...(originalBin === undefined ? {} : { originalBin })
-      }
-    });
-    return next.materializeMarkFilteredData({ id: derivedId });
-  }
-);
+import{findRaincloudParent as b}from"../../selectors/raincloud.js";import{filterRaincloud as T,materializeRaincloudFilter as B,removeRaincloudFilter as A}from"./raincloudFilter.js";import{closedAction as m}from"../../core/action.js";import{validateUserId as p}from"../../core/identifiers.js";import{withPreviewDatasetValues as z}from"../primitives/semanticAction.js";import{deriveFilteredRows as P,normalizeFilterTransform as L}from"../../grammar/filter.js";import{deriveMarkFilteredRows as N,markFilterSelectors as E,normalizeMarkFilterTransform as K}from"../../grammar/markFilter.js";import{resolveMarkFilterSelection as M}from"../../materialization/selection/filter.js";import{synchronizeBoxFilter as y}from"../boxPlots/components.js";import{findSelectionPolicy as q}from"../../materialization/selection/policies/index.js";import{applyLayerDataRematerialization as w,applyLayerEmptyDataView as $}from"../../materialization/dependencies.js";import{hasDataset as R,findDataset as O,resolveDatasetReference as V,requireLayer as h,resolveEligibleLayer as C}from"../../selectors/index.js";import{MATERIALIZE_OPTIONS as I,requireDerivedDataset as _}from"./shared.js";import{assertFieldsAvailable as H,deriveTransformSchema as J,transformInputFields as U}from"../../grammar/datasetSchema.js";const Y=Object.freeze(["id","source","field","oneOf","noneOf","predicate","range","nulls"]),x=Object.freeze(["grain","field","channel","property","op","value","values","min","max","inclusive","count","groupBy","ties"]),Z=Object.freeze(["target","mode",...x]),G=Object.freeze(["target"]),Q=Object.freeze(["id"]);function W(i,t){if(i.mark?.type!=="bar"||i.encoding?.x?.bin===void 0)return;const n=[...new Set(t.flatMap(e=>[e.channels.x,e.channels.x2]).filter(Number.isFinite))].sort((e,r)=>e-r);return n.length<2?void 0:n}const ke=m({op:"materializeFilteredData",description:"Materialize one filtered derived dataset."},I,function(i={}){const{id:t,source:n,transform:e}=_(this,i.id,"filter");H(n.schema,U(e),{data:n.id,operation:"materializeFilteredData"});const r=P(n.values,e),d=J(n.schema,e,r,{sourceId:n.id,ownerId:t});return this.editSemantic({property:`dataset[${t}].values`,value:r})}),ve=m({op:"filterData",description:"Create a named dataset from one field filter."},Y,function(i={}){const t=p(i.id,"Filtered dataset id"),n=p(i.source??this.context.currentData,"Source dataset id"),e=V(this,n,"Filter source dataset").id,r=L(i),d=this.createDerivedData({id:t,source:e,transform:[r]}).materializeFilteredData({id:t});return this.actionStack.length===1?d._withMaterializationConfig(["data","filter",t],{current:t}):d}),Fe=m({op:"materializeMarkFilteredData",description:"Materialize member rows retained by one final-item mark selection."},I,function(i={}){const{id:t,dataset:n,source:e,transform:r}=_(this,i.id,"markFilter"),d=b(this,r.target);if(d!==void 0)return B(this,{id:t,source:e,transform:r},d);const f=h(this,r.target);if(f?.data!==n.source)throw new Error(`Mark filter target "${r.target}" must still use source dataset "${n.source}".`);let s=this,c=e.values;const o=E(r);for(const[g,k]of o.entries()){const u=M(s,r.target,k);c=N(c,u.items,u.keys,f),g<o.length-1&&(s=z(s,{id:t,values:c,target:r.target}),s=y(s,r.target,t),s=c.length===0?$(s,r.target):w(s,r.target),c=O(s,t).values)}o.length>1&&(s=z(s,{id:t,omitValues:!0}));let a=s.editSemantic({property:`dataset[${t}].values`,value:c});return h(a,r.target).data!==t&&(a=a.editSemantic({property:`layer[${r.target}].data`,value:t})),a=a._withMarkConfig(r.target,{...a.markConfigs[r.target],markFilter:{...a.markConfigs[r.target].markFilter,empty:c.length===0}}),a=y(a,r.target,t),c.length===0?a.materializeEmptyMark({id:r.target}):w(a,r.target)}),be=m({op:"materializeEmptyMark",description:"Clear one active empty-filter mark without changing its domains."},Q,function(i={}){const t=p(i.id,"Empty mark id"),n=h(this,t),e=this.markConfigs[t]?.markFilter,r=O(this,n.data);if(e?.empty!==!0||r?.values?.length!==0)throw new Error(`Mark "${t}" does not own an active empty filter.`);return $(this,t)});function D(i,t){const n=i.markConfigs[t.id]?.markFilter,e=O(i,t.data),r=e?.transform?.[0];if(!(e?.source===void 0||r?.type!=="markFilter"||r.target!==t.id))return{dataset:e.id,source:e.source,selectors:E(r),...n?.originalBin===void 0?{}:{originalBin:n.originalBin}}}function X(i,t){const n=i.markConfigs[t]??{},{markFilter:e,...r}=n;return i._withMarkConfig(t,r)}function ee(i,t,n){let e=i;const r=t.encoding?.x?.bin??{};for(const d of["maxBins","step","boundaries"])Object.hasOwn(n,d)?e=e.editSemantic({property:`layer[${t.id}].encoding.x.bin.${d}`,value:n[d]}):Object.hasOwn(r,d)&&(e=e.editSemantic({property:`layer[${t.id}].encoding.x.bin.${d}`,remove:!0}));return e}function j(i,t,n){let e=y(i,t.id).editSemantic({property:`layer[${t.id}].data`,value:n.source});return n.originalBin!==void 0&&(e=ee(e,h(e,t.id),n.originalBin)),e=X(e,t.id).releaseDerivedData({id:n.dataset})._withContext({currentData:n.source}),w(e,t.id)}function te(i,t){const n=`${t}FilteredData`;if(!R(i,n))return n;let e=2;for(;R(i,`${n}${e}`);)e+=1;return`${n}${e}`}function re(i,t){return JSON.stringify(i)===JSON.stringify(t)}const Me=m({op:"removeMarkFilter",description:"Remove one active final-item filter and restore its source."},G,function(i={}){const t=i.target===void 0?void 0:p(i.target,"Mark filter target id"),n=b(this,t);if(n!==void 0)return A(this,n);const e=C(this,{target:t,label:"mark filter",predicate:r=>D(this,r)!==void 0});return j(this,e,D(this,e))}),ye=m({op:"filterMarks",description:"Retain selected final mark items through immutable derived data."},Z,function(i={}){if(i.mode!==void 0&&!["replace","compose"].includes(i.mode))throw new Error(`Unknown mark filter mode "${i.mode}".`);const t=i.target===void 0?void 0:p(i.target,"Filter mark target id"),n=b(this,t);if(n!==void 0){const l=Object.fromEntries(x.flatMap(F=>Object.hasOwn(i,F)?[[F,i[F]]]:[]));return T(this,i,n,l)}const e=C(this,{target:t,label:"filter mark",predicate:l=>l.data!==void 0&&q(l.mark?.type)!==void 0});if(this.markConfigs[e.id]?.itemFilterable===!1)throw new Error(`filterMarks does not support composite mark "${e.id}"; filter its source dataset first.`);const r=D(this,e),d=Object.fromEntries(x.flatMap(l=>Object.hasOwn(i,l)?[[l,i[l]]]:[])),f=M(this,e.id,d),s=r?.selectors.at(-1);if(s!==void 0&&re(s,f.selector))return this;if(r!==void 0&&i.mode===void 0)throw new Error('Repeated filterMarks requires mode "replace" or "compose".');const c=r===void 0||i.mode==="replace"?[f.selector]:[...r.selectors,f.selector];let o=r===void 0?this:j(this,e,r);const a=h(o,e.id),g=M(o,e.id,c[0]),k=K(e.id,c),u=W(a,g.items),S=a.mark?.type==="bar"&&a.encoding?.x?.bin!==void 0?a.encoding.x.bin:void 0,v=te(o,e.id);if(o=o.createDerivedData({id:v,source:a.data,transform:[k]}),u!==void 0){for(const l of["maxBins","step"])Object.hasOwn(a.encoding.x.bin,l)&&(o=o.editSemantic({property:`layer[${a.id}].encoding.x.bin.${l}`,remove:!0}));o=o.editSemantic({property:`layer[${a.id}].encoding.x.bin.boundaries`,value:u})}return o=o._withMarkConfig(a.id,{...o.markConfigs[a.id],markFilter:{dataset:v,source:a.data,selectors:c,empty:!1,...S===void 0?{}:{originalBin:S}}}),o.materializeMarkFilteredData({id:v})});export{ve as filterData,ye as filterMarks,be as materializeEmptyMark,ke as materializeFilteredData,Fe as materializeMarkFilteredData,Me as removeMarkFilter};

package/src/actions/data/flatten.js

@@ -0,0 +1,19 @@
+import { deriveFlattenRows, normalizeFlattenTransform } from "../../grammar/flatten.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "source", "fields", "as"]);
+export const materializeFlattenData = /* @__PURE__ */ derivedMaterializer(
+  "materializeFlattenData",
+  "Materialize aligned array elements as immutable rows.",
+  "flatten",
+  deriveFlattenRows
+);
+export const createFlattenData = /* @__PURE__ */ derivedCreator(
+  "createFlattenData",
+  "Expand parallel array fields in source-row and array-index order.",
+  OPTIONS,
+  "Flatten dataset id",
+  "Flatten source dataset id",
+  normalizeFlattenTransform,
+  "materializeFlattenData"
+);

package/src/actions/data/index.js

@@ -41,6 +41,8 @@ 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 { createFlattenData, materializeFlattenData } from "./flatten.js";
+import {createLookupData,materializeLookupData} from "./lookup.js";
 import { createComputedData, materializeComputedData } from "./computed.js";
 import {
   createNormalizedData,
@@ -89,6 +91,10 @@ export function registerDataActions(ProgramClass) {
     materializeSummaryData,
     createBinData,
     materializeBinData,
+    createFlattenData,
+    materializeFlattenData,
+    createLookupData,
+    materializeLookupData,
     createFoldData,
     materializeFoldData,
     createComputedData,

package/src/actions/data/lookup.js

@@ -0,0 +1,50 @@
+import { closedAction } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { deriveLookupRows, normalizeLookupTransform } from "../../grammar/lookup.js";
+import {
+  deriveTransformSchema, datasetSchemaContext, validateRowsAgainstSchema
+} from "../../grammar/datasetSchema.js";
+import { orderedDatasetAncestors } from "../../grammar/datasetDependencies.js";
+import { resolveDatasetReference, requireDataset } from "../../selectors/datasets.js";
+import {
+  requireDerivedDataset, MATERIALIZE_OPTIONS, resolveDatasetTransformInputs
+} from "./shared.js";
+
+function lookupResult(program, source, transform, id) {
+  if (!Array.isArray(source.values)) throw new Error(`Source dataset "${source.id}" has no values.`);
+  const right = requireDataset(program, transform.lookup.data);
+  if (!Array.isArray(right.values)) throw new Error(`Lookup dataset "${right.id}" has no values.`);
+  const context = datasetSchemaContext(source, transform, id, reference => requireDataset(program, reference));
+  const schema = deriveTransformSchema(source.schema, transform, undefined, context);
+  const values = deriveLookupRows(source.values, right.values, transform);
+  validateRowsAgainstSchema(values, schema, `Lookup dataset "${id}"`);
+  return values;
+}
+
+export const materializeLookupData = /* @__PURE__ */ closedAction(
+  { op: "materializeLookupData", description: "Materialize one typed named-dataset lookup." },
+  MATERIALIZE_OPTIONS,
+  function(args = {}) {
+    const { id, source, transform } = requireDerivedDataset(this, args.id, "lookup");
+    orderedDatasetAncestors(this.semanticSpec.datasets, id);
+    const values = lookupResult(this, source, transform, id);
+    return this.editSemantic({ property: `dataset[${id}].values`, value: values });
+  }
+);
+
+export const createLookupData = /* @__PURE__ */ closedAction(
+  { op: "createLookupData", description: "Copy fields from one named dataset without changing primary rows." },
+  ["id", "source", "field", "lookup"],
+  function(args = {}) {
+    const id = validateUserId(args.id, "Lookup dataset id");
+    const source = resolveDatasetReference(this,
+      validateUserId(args.source ?? this.context.currentData, "Lookup source dataset id"),
+      "Lookup source dataset");
+    const transform = resolveDatasetTransformInputs(this, normalizeLookupTransform(args));
+    lookupResult(this, source, transform, id);
+    const standalone = this.actionStack.length === 1;
+    const next = this.createDerivedData({ id, source: source.id, transform: [transform] })
+      .materializeLookupData({ id });
+    return standalone ? next._withMaterializationConfig(["data", "lookup", id], { current: id }) : next;
+  }
+);

package/src/actions/data/raincloudFilter.js

@@ -0,0 +1,56 @@
+import { findDataset, hasDataset } from "../../selectors/datasets.js";
+import { findRaincloudParent } from "../../selectors/raincloud.js";
+import { normalizeMarkSelector, selectMarkItemKeys } from "../../grammar/markSelection.js";
+import { deriveMarkFilteredRows, normalizeMarkFilterTransform } from "../../grammar/markFilter.js";
+
+export function deriveRaincloudFilteredRows(values, selectors) {
+  let rows = values;
+  for (const selector of selectors) {
+    if (selector.field === undefined || selector.grain !== "item") {
+      throw new Error("Raincloud parent filters require an item-grain observation field selector; use a child target for rendered channels or properties.");
+    }
+    const items = rows.map((row, index) => ({ key: String(index), fields: row,
+      channels: {}, properties: {}, members: [row] }));
+    rows = deriveMarkFilteredRows(rows, items, selectMarkItemKeys(items, selector));
+  }
+  return rows;
+}
+
+export function materializeRaincloudFilter(program, { id, source, transform }, owner) {
+  const values = deriveRaincloudFilteredRows(source.values, transform.selectors);
+  let next = program.editSemantic({ property: `dataset[${id}].values`, value: values });
+  next = next.editRaincloudPlot({ target: owner.id, data: id });
+  const revised = findRaincloudParent(next, owner.id);
+  return next._withMarkConfig(revised.ownerId, {
+    ...next.markConfigs[revised.ownerId], raincloudPlot: { ...revised,
+      sourceFilter: { dataset: id, source: source.id, selectors: transform.selectors } }
+  });
+}
+
+export function filterRaincloud(program, args, owner, selectorOptions) {
+  const selector = normalizeMarkSelector(selectorOptions);
+  const previous = owner.sourceFilter;
+  if (previous !== undefined && JSON.stringify(previous.selectors.at(-1)) === JSON.stringify(selector)) return program;
+  if (previous !== undefined && args.mode === undefined) {
+    throw new Error('Repeated filterMarks requires mode "replace" or "compose".');
+  }
+  const selectors = previous === undefined || args.mode === "replace"
+    ? [selector] : [...previous.selectors, selector];
+  const source = previous?.source ?? owner.source;
+  // Validate against observations before changing any owner or resource.
+  deriveRaincloudFilteredRows(findDataset(program, source).values, selectors);
+  const base = `${owner.id}FilteredData`;
+  let id = base;
+  for (let revision = 2; hasDataset(program, id); revision += 1) id = `${base}${revision}`;
+  let next = program.createDerivedData({ id, source,
+    transform: [normalizeMarkFilterTransform(owner.id, selectors)] })
+    .materializeMarkFilteredData({ id });
+  if (previous !== undefined) next = next.releaseDerivedData({ id: previous.dataset });
+  return next;
+}
+
+export function removeRaincloudFilter(program, owner) {
+  if (owner.sourceFilter === undefined) throw new Error(`Raincloud plot "${owner.id}" has no active mark filter.`);
+  return program.editRaincloudPlot({ target: owner.id, data: owner.sourceFilter.source })
+    .releaseDerivedData({ id: owner.sourceFilter.dataset });
+}