@sdeverywhere/check-core 0.1.4 → 0.1.5

package/dist/index.cjs

@@ -3132,6 +3132,7 @@ var import_assert_never11 = require("assert-never");
 // src/bundle/model-inputs.ts
 var ModelInputs = class {
   constructor(modelSpec) {
+    this.modelSpec = modelSpec;
     /** All inputs keyed by lookup name (lowercase variable name or alias). */
     this.inputsByLookupName = /* @__PURE__ */ new Map();
     /** All input ID aliases. */
@@ -3178,6 +3179,14 @@ var ModelInputs = class {
   getInputVarForName(name) {
     return this.inputsByLookupName.get(name.toLowerCase());
   }
+  /**
+   * Return the `InputVar` that matches the requested variable ID.
+   *
+   * @param varId The variable identifier to match.
+   */
+  getInputVarForVarId(varId) {
+    return this.modelSpec.inputVars.get(varId);
+  }
 };
 
 // src/comparison/config/resolve/comparison-scenario-specs.ts
@@ -3399,6 +3408,19 @@ function resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genK
         )
       ];
     }
+    case "scenario-with-setting-group": {
+      return [
+        resolveScenarioForSettingGroup(
+          modelInputsL,
+          modelInputsR,
+          genKey(),
+          scenarioSpec.id,
+          scenarioSpec.title,
+          scenarioSpec.subtitle,
+          scenarioSpec.settingGroupId
+        )
+      ];
+    }
     default:
       (0, import_assert_never11.assertNever)(scenarioSpec);
   }
@@ -3528,6 +3550,113 @@ function resolveScenarioForDistinctInputSpecs(modelInputsL, modelInputsR, key, i
     specR
   };
 }
+function resolveScenarioForSettingGroup(modelInputsL, modelInputsR, key, id, title, subtitle, settingGroupId) {
+  var _a, _b;
+  function inputVarNameForVarId(modelInputs, varId) {
+    const inputVar = modelInputs.getInputVarForVarId(varId);
+    if (inputVar !== void 0) {
+      return inputVar.varName;
+    } else {
+      return varId;
+    }
+  }
+  function inputPositionForPosition(position) {
+    switch (position) {
+      case "at-minimum":
+        return "min";
+      case "at-maximum":
+        return "max";
+      case "at-default":
+        return "default";
+      default:
+        throw new Error(`Unknown input position: ${position}`);
+    }
+  }
+  function inputSpecForSetting(modelInputs, inputSetting) {
+    switch (inputSetting.kind) {
+      case "position":
+        return {
+          kind: "input-at-position",
+          inputName: inputVarNameForVarId(modelInputs, inputSetting.inputVarId),
+          position: inputPositionForPosition(inputSetting.position)
+        };
+      case "value":
+        return {
+          kind: "input-at-value",
+          inputName: inputVarNameForVarId(modelInputs, inputSetting.inputVarId),
+          value: inputSetting.value
+        };
+      default:
+        throw new Error(`Unknown input setting kind: ${inputSetting}`);
+    }
+  }
+  function inputSpecsForSettingGroup(modelInputs, inputSettings) {
+    return inputSettings.map((inputSetting) => inputSpecForSetting(modelInputs, inputSetting));
+  }
+  const inputSettingsL = ((_a = modelInputsL.modelSpec.inputSettingGroups) == null ? void 0 : _a.get(settingGroupId)) || [];
+  const inputSettingsR = ((_b = modelInputsR.modelSpec.inputSettingGroups) == null ? void 0 : _b.get(settingGroupId)) || [];
+  const inputsL = inputSpecsForSettingGroup(modelInputsL, inputSettingsL);
+  const inputsR = inputSpecsForSettingGroup(modelInputsR, inputSettingsR);
+  const scenario = resolveScenarioForDistinctInputSpecs(
+    modelInputsL,
+    modelInputsR,
+    key,
+    id,
+    title,
+    subtitle,
+    inputsL,
+    inputsR
+  );
+  function scenarioString(scenario2) {
+    if (scenario2.kind === "input-settings") {
+      const settings = scenario2.settings.map((setting) => {
+        switch (setting.kind) {
+          case "position":
+            return `${setting.inputVarId}=${setting.position}`;
+          case "value":
+            return `${setting.inputVarId}=${setting.value}`;
+          default:
+            throw new Error(`Unexpected input setting kind: ${setting}`);
+        }
+      });
+      return settings.sort().join("__");
+    } else {
+      throw new Error(`Unexpected scenario spec kind: ${scenario2.kind}`);
+    }
+  }
+  function scenariosAreEqual(scenarioL, scenarioR) {
+    return scenarioString(scenarioL) === scenarioString(scenarioR);
+  }
+  function errorState(inputSettings) {
+    if (inputSettings.length === 0) {
+      return { error: { kind: "unknown-input-setting-group" } };
+    } else {
+      return {};
+    }
+  }
+  if (inputSettingsL.length === 0 || inputSettingsR.length === 0) {
+    if (scenario.settings.kind === "input-settings") {
+      const errorSetting = {
+        requestedName: settingGroupId,
+        stateL: errorState(inputSettingsL),
+        stateR: errorState(inputSettingsR)
+      };
+      scenario.settings.inputs.unshift(errorSetting);
+    }
+    if (inputSettingsL.length === 0) {
+      scenario.specL = void 0;
+    }
+    if (inputSettingsR.length === 0) {
+      scenario.specR = void 0;
+    }
+  }
+  if (scenario.settings.kind === "input-settings") {
+    if (scenario.specL && scenario.specR && !scenariosAreEqual(scenario.specL, scenario.specR)) {
+      scenario.settings.settingsDiffer = true;
+    }
+  }
+  return scenario;
+}
 function resolveInputForName(modelInputsL, modelInputsR, inputName, at) {
   return {
     requestedName: inputName,