@sdeverywhere/check-core 0.1.13 → 0.1.14

package/dist/index.cjs

@@ -545,7 +545,7 @@ function predicateReport(predicatePlan, checkKey, result) {
         opValue = `${sym} ${predOp}`;
       } else {
         const dataRef = (_a = predicatePlan.dataRefs) == null ? void 0 : _a.get(op);
-        if (!dataRef) {
+        if (!dataRef || dataRef.refs.length === 0) {
           return;
         }
         const opDataRef = {
@@ -553,8 +553,9 @@ function predicateReport(predicatePlan, checkKey, result) {
           dataRef
         };
         opRef = opDataRef;
-        opValue = `${sym} '${dataRef.dataset.name}'`;
-        const refScenarioSpec = (_b = dataRef.scenario) == null ? void 0 : _b.spec;
+        const refDatasetNames = dataRef.refs.map((ref) => `'${ref.dataset.name}'`);
+        opValue = `${sym} ${refDatasetNames.join(" + ")}`;
+        const refScenarioSpec = (_b = dataRef.refs[0].scenario) == null ? void 0 : _b.spec;
         if (!refScenarioSpec) {
           return;
         }
@@ -1111,6 +1112,12 @@ var check_schema_default = {
       type: "number"
     },
     predicate_ref_data: {
+      oneOf: [
+        { $ref: "#/$defs/predicate_ref_data_single_dataset" },
+        { $ref: "#/$defs/predicate_ref_data_multiple_datasets" }
+      ]
+    },
+    predicate_ref_data_single_dataset: {
       type: "object",
       additionalProperties: false,
       properties: {
@@ -1119,6 +1126,27 @@ var check_schema_default = {
       },
       required: ["dataset"]
     },
+    predicate_ref_data_multiple_datasets: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        op: { $ref: "#/$defs/predicate_ref_data_datasets_op" },
+        datasets: {
+          type: "array",
+          items: { $ref: "#/$defs/predicate_ref_data_datasets_item" },
+          minItems: 1
+        },
+        scenario: { $ref: "#/$defs/predicate_ref_data_scenario" }
+      },
+      required: ["op", "datasets"]
+    },
+    predicate_ref_data_datasets_op: {
+      type: "string",
+      enum: ["sum"]
+    },
+    predicate_ref_data_datasets_item: {
+      oneOf: [{ type: "string" }, { $ref: "#/$defs/dataset_name" }]
+    },
     predicate_ref_data_dataset: {
       oneOf: [{ $ref: "#/$defs/dataset_name" }, { $ref: "#/$defs/predicate_ref_data_dataset_special" }]
     },
@@ -1971,6 +1999,17 @@ var CheckPlanner = class {
    * this will add a reference to the scenario/dataset pair so that the data can
    * be fetched in a later stage.
    *
+   * A predicate can also reference multiple datasets that are combined into a
+   * single dataset, for example:
+   * ```
+   *   approx:
+   *     op: sum
+   *     datasets:
+   *       - 'X'
+   *       - 'Y'
+   * ```
+   * in which case one reference is added for each of the datasets.
+   *
    * @param predicateSpec The predicate spec.
    * @param checkScenario The scenario in which the dataset is being checked.
    * @param checkDataset The dataset that is being checked.
@@ -1982,25 +2021,22 @@ var CheckPlanner = class {
       if (predOp === void 0 || typeof predOp === "number") {
         return;
       }
-      let refDataset;
-      if (typeof predOp.dataset === "string") {
+      const refDatasets = [];
+      if (predOp.datasets !== void 0) {
+        for (const datasetSpec of predOp.datasets) {
+          const refDatasetSpec = typeof datasetSpec === "string" ? { name: datasetSpec } : { name: datasetSpec.name, source: datasetSpec.source };
+          refDatasets.push(this.resolveRefDataset(refDatasetSpec));
+        }
+      } else if (typeof predOp.dataset === "string") {
         switch (predOp.dataset) {
           case "inherit":
-            refDataset = checkDataset;
+            refDatasets.push(checkDataset);
             break;
           default:
             (0, import_assert_never5.default)(predOp.dataset);
         }
       } else {
-        const refDatasetSpec = { name: predOp.dataset.name };
-        const matchedRefDatasets = expandDatasets(this.modelSpec, refDatasetSpec);
-        if (matchedRefDatasets.length === 1) {
-          refDataset = matchedRefDatasets[0];
-        } else {
-          refDataset = {
-            name: predOp.dataset.name
-          };
-        }
+        refDatasets.push(this.resolveRefDataset({ name: predOp.dataset.name }));
       }
       let refScenario;
       if (typeof predOp.scenario === "string") {
@@ -2023,22 +2059,28 @@ var CheckPlanner = class {
           };
         }
       }
-      let dataRefKey;
-      if (refScenario.spec && refDataset.datasetKey) {
-        dataRefKey = `${refScenario.spec.uid}::${refDataset.datasetKey}`;
-      }
-      const dataRef = {
-        key: dataRefKey,
-        dataset: refDataset,
-        scenario: refScenario
-      };
-      if (dataRefKey) {
-        this.dataRefs.set(dataRefKey, dataRef);
-      }
+      const refs = refDatasets.map((refDataset) => {
+        let dataRefKey;
+        if (refScenario.spec && refDataset.datasetKey) {
+          dataRefKey = `${refScenario.spec.uid}::${refDataset.datasetKey}`;
+        }
+        const ref = {
+          key: dataRefKey,
+          dataset: refDataset,
+          scenario: refScenario
+        };
+        if (dataRefKey) {
+          this.dataRefs.set(dataRefKey, ref);
+        }
+        return ref;
+      });
       if (dataRefs === void 0) {
         dataRefs = /* @__PURE__ */ new Map();
       }
-      dataRefs.set(op, dataRef);
+      dataRefs.set(op, {
+        op: predOp.op,
+        refs
+      });
     };
     addDataRef("gt");
     addDataRef("gte");
@@ -2048,6 +2090,23 @@ var CheckPlanner = class {
     addDataRef("approx");
     return dataRefs;
   }
+  /**
+   * Resolve the dataset that matches the given spec.  If the spec does not expand
+   * to exactly one dataset, this will return a `CheckDataset` with an undefined
+   * `datasetKey` so that the error can be reported later.
+   *
+   * @param refDatasetSpec The spec for the referenced dataset.
+   */
+  resolveRefDataset(refDatasetSpec) {
+    const matchedRefDatasets = expandDatasets(this.modelSpec, refDatasetSpec);
+    if (matchedRefDatasets.length === 1) {
+      return matchedRefDatasets[0];
+    } else {
+      return {
+        name: refDatasetSpec.name
+      };
+    }
+  }
 };
 
 // src/check/check-summary.ts
@@ -5397,14 +5456,15 @@ function scenarioPairUid(scenarioSpecL, scenarioSpecR, constantsL, constantsR, l
 }
 
 // src/check/check-runner.ts
+var import_assert_never13 = __toESM(require("assert-never"), 1);
 function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, skipChecks) {
   const modelSpec = checkConfig.bundle.modelSpec;
   const checkPlanner = new CheckPlanner(modelSpec);
   checkPlanner.addAllChecks(checkSpec, skipChecks);
   const checkPlan = checkPlanner.buildPlan();
   const refDatasets = /* @__PURE__ */ new Map();
-  for (const [dataRefKey, dataRef] of checkPlan.dataRefs.entries()) {
-    refDataPlanner.addRequest(void 0, dataRef.scenario.spec, dataRef.dataset.datasetKey, (datasets) => {
+  for (const [dataRefKey, ref] of checkPlan.dataRefs.entries()) {
+    refDataPlanner.addRequest(void 0, ref.scenario.spec, ref.dataset.datasetKey, (datasets) => {
       const dataset = datasets.datasetR;
       if (dataset) {
         refDatasets.set(dataRefKey, dataset);
@@ -5438,52 +5498,91 @@ function runCheck(checkTask, dataset, refDatasets) {
   if (checkTask.dataRefs) {
     opRefDatasets = /* @__PURE__ */ new Map();
     for (const [op, dataRef] of checkTask.dataRefs.entries()) {
-      const refDataset = refDatasets == null ? void 0 : refDatasets.get(dataRef.key);
-      if (refDataset === void 0) {
-        if (dataRef.dataset.datasetKey === void 0) {
-          return {
-            status: "error",
-            errorInfo: {
-              kind: "unknown-dataset",
-              name: dataRef.dataset.name
-            }
-          };
-        } else if (dataRef.scenario.spec === void 0) {
-          if (dataRef.scenario.error) {
-            return {
-              status: "error",
-              errorInfo: {
-                kind: dataRef.scenario.error.kind,
-                name: dataRef.scenario.error.name
-              }
-            };
-          } else {
-            let inputName;
-            if (dataRef.scenario.inputDescs.length > 0) {
-              inputName = dataRef.scenario.inputDescs[0].name;
-            } else {
-              inputName = "unknown";
-            }
-            return {
-              status: "error",
-              errorInfo: {
-                kind: "unknown-input",
-                name: inputName
-              }
-            };
-          }
-        } else {
-          return {
-            status: "error",
-            message: "unresolved data reference"
-          };
+      const resolvedDatasets = [];
+      for (const ref of dataRef.refs) {
+        const refDataset = refDatasets == null ? void 0 : refDatasets.get(ref.key);
+        if (refDataset === void 0) {
+          return errorResultForRefDataset(ref);
         }
+        resolvedDatasets.push(refDataset);
       }
-      opRefDatasets.set(op, refDataset);
+      opRefDatasets.set(op, combineRefDatasets(dataRef, resolvedDatasets));
     }
   }
   return checkTask.action.run(dataset, opRefDatasets);
 }
+function errorResultForRefDataset(ref) {
+  if (ref.dataset.datasetKey === void 0) {
+    return {
+      status: "error",
+      errorInfo: {
+        kind: "unknown-dataset",
+        name: ref.dataset.name
+      }
+    };
+  } else if (ref.scenario.spec === void 0) {
+    if (ref.scenario.error) {
+      return {
+        status: "error",
+        errorInfo: {
+          kind: ref.scenario.error.kind,
+          name: ref.scenario.error.name
+        }
+      };
+    } else {
+      let inputName;
+      if (ref.scenario.inputDescs.length > 0) {
+        inputName = ref.scenario.inputDescs[0].name;
+      } else {
+        inputName = "unknown";
+      }
+      return {
+        status: "error",
+        errorInfo: {
+          kind: "unknown-input",
+          name: inputName
+        }
+      };
+    }
+  } else {
+    return {
+      status: "error",
+      message: "unresolved data reference"
+    };
+  }
+}
+function combineRefDatasets(dataRef, datasets) {
+  if (dataRef.op === void 0) {
+    return datasets[0];
+  }
+  switch (dataRef.op) {
+    case "sum":
+      return sumDatasets(datasets);
+    default:
+      (0, import_assert_never13.default)(dataRef.op);
+  }
+}
+function sumDatasets(datasets) {
+  const firstDataset = datasets[0];
+  const otherDatasets = datasets.slice(1);
+  const summed = /* @__PURE__ */ new Map();
+  for (const [time, value] of firstDataset) {
+    let sum = value;
+    let complete = true;
+    for (const otherDataset of otherDatasets) {
+      const otherValue = otherDataset.get(time);
+      if (otherValue === void 0) {
+        complete = false;
+        break;
+      }
+      sum += otherValue;
+    }
+    if (complete) {
+      summed.set(time, sum);
+    }
+  }
+  return summed;
+}
 
 // src/comparison/run/comparison-runner.ts
 function runComparisons(comparisonConfig, dataPlanner, skipScenarios) {
@@ -5619,8 +5718,9 @@ var SuiteRunner = class {
     }
     const refDataPlan = refDataPlanner.buildPlan();
     const dataPlan = dataPlanner.buildPlan();
-    const dataRequests = [...refDataPlan.requests, ...dataPlan.requests];
-    const taskCount = dataRequests.length;
+    const refDataRequests = refDataPlan.requests;
+    const dataRequests = dataPlan.requests;
+    const taskCount = refDataRequests.length + dataRequests.length;
     if (taskCount === 0) {
       const checkReport = buildCheckReport2();
       let comparisonReport;
@@ -5658,23 +5758,42 @@ var SuiteRunner = class {
     };
     let tasksCompleted = 0;
     let dataTaskId = 1;
-    for (const dataRequest of dataRequests) {
-      const task = {
-        key: `suite-runner-${dataTaskId++}`,
-        kind: "suite-runner",
-        process: (bundleModels) => __async(this, null, function* () {
-          var _a2, _b2;
-          this.pendingTaskKeys.delete(task.key);
-          yield this.processRequest(dataRequest, bundleModels);
-          tasksCompleted++;
-          (_b2 = (_a2 = this.callbacks).onProgress) == null ? void 0 : _b2.call(_a2, tasksCompleted / taskCount);
-          if (tasksCompleted === taskCount) {
-            buildReport();
-          }
-        })
-      };
-      this.taskQueue.addTask(task);
-      this.pendingTaskKeys.add(task.key);
+    const scheduleRequests = (requests, onGroupComplete) => {
+      let groupTasksCompleted = 0;
+      for (const dataRequest of requests) {
+        const task = {
+          key: `suite-runner-${dataTaskId++}`,
+          kind: "suite-runner",
+          process: (bundleModels) => __async(this, null, function* () {
+            var _a2, _b2;
+            this.pendingTaskKeys.delete(task.key);
+            yield this.processRequest(dataRequest, bundleModels);
+            tasksCompleted++;
+            (_b2 = (_a2 = this.callbacks).onProgress) == null ? void 0 : _b2.call(_a2, tasksCompleted / taskCount);
+            groupTasksCompleted++;
+            if (groupTasksCompleted === requests.length) {
+              onGroupComplete();
+            }
+          })
+        };
+        this.taskQueue.addTask(task);
+        this.pendingTaskKeys.add(task.key);
+      }
+    };
+    const scheduleDataRequests = () => {
+      if (this.stopped) {
+        return;
+      }
+      if (dataRequests.length > 0) {
+        scheduleRequests(dataRequests, buildReport);
+      } else {
+        buildReport();
+      }
+    };
+    if (refDataRequests.length > 0) {
+      scheduleRequests(refDataRequests, scheduleDataRequests);
+    } else {
+      scheduleDataRequests();
     }
   }
   processRequest(request, bundleModels) {