src/controller/parameters.js

import { downloadBlob } from "../view/download.js";
/**
 * Reads a parameter JSON file and returns the parsed content.
 * Restores composition parameters (theta) from a previously exported JSON file.
 * @param {File|Blob} file - Source containing serialized parameters (theta) as JSON text.
 * @return {Promise<Object>} Parsed parameter object (theta).
 * @throws {Error} If the file cannot be read or the content is not valid JSON.
 */
export function importParameters(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = (e) => {
      try {
        resolve(JSON.parse(e.target.result));
      } catch {
        reject(new Error("Could not parse the JSON file."));
      }
    };
    reader.onerror = () => reject(new Error("Could not read the file."));
    reader.readAsText(file);
  });
}
/**
 * Exports the composition parameters (theta) as a JSON file download.
 * @param {Object} parameters - Top-level parameters (theta) to serialize as JSON.
 */
export function exportParameters(parameters) {
  const blob = new Blob([JSON.stringify(parameters, null, 2)], {
    type: "application/json",
  });
  downloadBlob(blob, "parameters.json");
}
/**
 * Builds the initial composition parameters (theta) for a list of steps by calling schema() on each.
 * @param {Step[]} steps - Step instances.
 * @return {Promise<{steps: Step[], schemas: Object<string, Object[]>, parameters: Object}>}
 *  Step instances unchanged plus a schemas-by-step.id map and the parameters object.
 */
export async function buildParameters(steps) {
  const schemas = {};
  const parameters = {};
  for (const step of steps) {
    const schema = await step.schema();
    schemas[step.id] = schema;
    parameters[step.id] = {};
    const filled = parameters[step.id];
    for (const param of schema) {
      if (param.type === "checkboxes") {
        for (const cb of param.items) {
          filled[cb.name] = cb.default;
        }
      } else if (param.type !== "nested") {
        filled[param.name] = param.default;
      } else {
        const count = resolveNestedCount(param, schema, parameters);
        filled[param.name] = Array.from({ length: count }, (_, i) =>
          buildNestedItem(param, i),
        );
      }
    }
  }
  return { steps, schemas, parameters };
}
/** @private Resolves the count for a nested-parameter array (defaults length, counter ref, or fallback 1). */
function resolveNestedCount(param, schema, parameters) {
  if (param.defaults?.length) {
    return param.defaults.length;
  }
  if (param.counter.includes(".")) {
    const [stepId, paramName] = param.counter.split(".");
    return parameters[stepId]?.[paramName] || 1;
  }
  return schema.find((p) => p.name === param.counter)?.max || 1;
}
/** @private Builds one nested-array item: merges perItem overrides over template defaults. */
function buildNestedItem(param, i) {
  const perItem = param.defaults?.[i];
  const item = perItem ? { ...perItem } : {};
  for (const sub of param.template) {
    const fields = sub.type === "checkboxes" ? sub.items : [sub];
    for (const f of fields) {
      item[f.name] = perItem?.[f.name] ?? f.default;
    }
  }
  return item;
}