@mat3ra/wode 2025.10.1-0

package/dist/units/processing.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProcessingUnit = void 0;
+var _enums = require("../enums");
+var _base = require("./base");
+class ProcessingUnit extends _base.BaseUnit {
+  constructor(config) {
+    super({
+      ...ProcessingUnit.getProcessingConfig(),
+      ...config
+    });
+  }
+  static getProcessingConfig() {
+    return {
+      name: _enums.UNIT_TYPES.processing,
+      type: _enums.UNIT_TYPES.processing
+    };
+  }
+  setOperation(op) {
+    this.setProp("operation", op);
+  }
+  setOperationType(type) {
+    this.setProp("operationType", type);
+  }
+  setInput(input) {
+    this.setProp("input", input);
+  }
+  get operation() {
+    return this.prop("operation");
+  }
+  get operationType() {
+    return this.prop("operationType");
+  }
+  get input() {
+    return this.prop("input");
+  }
+}
+exports.ProcessingUnit = ProcessingUnit;

package/dist/units/reduce.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReduceUnit = void 0;
+var _enums = require("../enums");
+var _base = require("./base");
+class ReduceUnit extends _base.BaseUnit {
+  constructor(unitName, mapUnit, input) {
+    super({
+      ...ReduceUnit.getReduceConfig(unitName, mapUnit, input)
+    });
+  }
+  static getReduceConfig(unitName, mapUnit, input) {
+    return {
+      type: _enums.UNIT_TYPES.reduce,
+      name: unitName,
+      mapFlowchartId: mapUnit,
+      input
+    };
+  }
+}
+exports.ReduceUnit = ReduceUnit;

package/dist/units/subworkflow.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SubworkflowUnit = void 0;
+var _enums = require("../enums");
+var _base = require("./base");
+class SubworkflowUnit extends _base.BaseUnit {
+  constructor(config) {
+    super({
+      ...SubworkflowUnit.getSubworkflowConfig(),
+      ...config
+    });
+  }
+  static getSubworkflowConfig() {
+    return {
+      name: "New Subworkflow",
+      type: _enums.UNIT_TYPES.subworkflow
+    };
+  }
+}
+exports.SubworkflowUnit = SubworkflowUnit;

package/dist/utils.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyConfig = applyConfig;
+exports.findUnit = findUnit;
+exports.setNextLinks = setNextLinks;
+exports.setUnitsHead = setUnitsHead;
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @summary set the head of an array of units
+ * @param units
+ * @returns {Unit[]}
+ */
+function setUnitsHead(units) {
+  if (units.length > 0) {
+    units[0].head = true;
+    _lodash.default.tail(units).map(x => x.head = false);
+  }
+  return units;
+}
+
+// TODO: fix setNextLinks on unit removal and convergence logic.
+/**
+ * @summary Re-establishes the linked `next => flowchartId` logic in an array of units
+ * @params units {Unit[]}
+ * @returns units {Unit[]}
+ */
+function setNextLinks(units) {
+  const flowchartIds = units.map(u => u.flowchartId);
+  for (let i = 0; i < units.length - 1; i++) {
+    if (!units[i].next) {
+      // newly added units don't have next set yet => set it
+      units[i].next = units[i + 1].flowchartId;
+      if (i > 0) units[i - 1].next = units[i].flowchartId;
+    } else if (!flowchartIds.includes(units[i].next)) {
+      // newly removed units may create broken next links => fix it
+      units[i].next = units[i + 1].flowchartId;
+    }
+  }
+  return units;
+}
+
+/**
+ * @summary Apply configuration data to an object
+ * @param obj {*} object / class containing methods or attributes to be set
+ * @param config { functions: {}, attributes: {} } functions to call and attributes to set
+ * @param callBuild {boolean} if true; call build between applying functions and attributes
+ * @returns {*} updated object
+ */
+function applyConfig({
+  obj,
+  config = {},
+  callBuild = false
+}) {
+  const {
+    functions = {},
+    attributes = {}
+  } = config;
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [func, args] of Object.entries(functions)) {
+    // eslint-disable-next-line no-nested-ternary
+    if (obj[func]) {
+      if (args) obj[func](args);else obj[func]();
+    }
+  }
+  const modified = callBuild ? obj.build() : obj;
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [key, values] of Object.entries(attributes)) {
+    modified[key] = values;
+  }
+  return modified;
+}
+
+/**
+ * @summary Safely extract unit object from subworkflow data
+ * @param subworkflowData {Object} subworkflow data
+ * @param index {number} index of subworkflow unit
+ * @param type {string} type of subworkflow unit
+ * @returns {Object|null} subworkflow unit object (not a unit class instance!)
+ */
+function findUnit({
+  subworkflowData,
+  index,
+  type
+}) {
+  const unit = subworkflowData.units[index];
+  if (unit.type !== type) throw new Error("findUnit() error: unit type does not match!");
+  return unit;
+}

package/dist/workflows/create.js

@@ -0,0 +1,312 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWorkflow = createWorkflow;
+var _create = require("../subworkflows/create");
+var _units = require("../units");
+var _map = require("../units/map");
+var _utils = require("../utils");
+var _workflow = require("./workflow");
+/**
+ * @summary Helper for creating Map units for complex workflows
+ * @param config {Object} map unit configuration
+ * @param unitFactoryCls {*} class factory for map unit
+ * @returns {*} map unit
+ */
+function createMapUnit({
+  config,
+  unitFactoryCls = _units.UnitFactory
+}) {
+  let {
+    input: defaultInput
+  } = _map.defaultMapConfig;
+  if (config.input) {
+    defaultInput = {
+      ...defaultInput,
+      ...config.input
+    };
+  }
+  const unit = unitFactoryCls.create({
+    ..._map.defaultMapConfig,
+    input: defaultInput
+  });
+  return unit;
+}
+
+/**
+ * @summary Update subworkflow units with patch configuration defined in the workflow config
+ * @param subworkflowData {Object} subworkflow data
+ * @param unitConfigs {Array<Object>} array of patch configs for subworkflow units
+ * @returns subworkflowData {Object} subworkflowData with patches applied to units
+ */
+function updateUnitConfigs({
+  subworkflowData,
+  unitConfigs
+}) {
+  unitConfigs.forEach(config => {
+    const {
+      index,
+      type,
+      config: unitConfig
+    } = config; // unitConfig should contain 'attributes' key
+    const unit = (0, _utils.findUnit)({
+      subworkflowData,
+      index,
+      type
+    });
+    console.log(`  patching ${type} unit ${index} of subworkflow ${subworkflowData.name}`);
+    unit.config = (0, _utils.applyConfig)({
+      obj: unit.config,
+      config: unitConfig
+    });
+    return null;
+  });
+  return subworkflowData;
+}
+
+/**
+ * @summary Use subworkflow.createSubworkflow to create a Subworkflow unit
+ * @param appName {String} application name
+ * @param unitData {*} object containing subworkflow configuration data
+ * @param workflowData {*} object containing all workflow configuration data
+ * @param swArgs {*} subworkflow classes
+ * @returns {*} subworkflow object
+ */
+function createSubworkflowUnit({
+  appName,
+  unitData,
+  workflowData,
+  ...swArgs
+}) {
+  const {
+    name: unitName,
+    unitConfigs,
+    config
+  } = unitData;
+  const {
+    subworkflows
+  } = workflowData;
+  const {
+    [appName]: dataByApp
+  } = subworkflows;
+  let {
+    [unitName]: subworkflowData
+  } = dataByApp;
+  subworkflowData.config = {
+    ...subworkflowData.config,
+    ...config
+  };
+  if (unitConfigs) subworkflowData = updateUnitConfigs({
+    subworkflowData,
+    unitConfigs
+  });
+  return (0, _create.createSubworkflow)({
+    subworkflowData,
+    ...swArgs
+  });
+}
+
+/**
+ * @summary Create the first workflow object specified in a workflow configuration
+ * @param workflow {*|null} the workflow (if already initialized, no-op)
+ * @param unit {*} workflow unit object
+ * @param type {String} value in ["workflow", "subworkflow"]
+ * @param workflowCls {*} workflow class
+ * @returns {Workflow|*} workflow object
+ */
+function createWorkflowHead({
+  workflow,
+  unit,
+  type,
+  workflowCls
+}) {
+  if (workflow) return workflow;
+  let wf;
+  switch (type) {
+    case "workflow":
+      wf = unit;
+      break;
+    case "subworkflow":
+      wf = workflowCls.fromSubworkflow(unit);
+      break;
+    default:
+      throw new Error(`workflow type=${type} not understood.`);
+  }
+  return wf;
+}
+
+/**
+ * @summary Combine workflow units together
+ * @param workflow {*} the workflow object
+ * @param unit {*} workflow/subworkflow object
+ * @param config {*} additional configuration for e.g. map units
+ * @param type {String} value in ["workflow", "subworkflow"]
+ * @param unitFactoryCls {*} unit factory class for e.g. map units
+ * @returns {*} modified workflow
+ */
+function composeWorkflow({
+  workflow,
+  unit,
+  config,
+  type,
+  unitFactoryCls
+}) {
+  /* eslint-disable no-case-declarations */
+  switch (type) {
+    case "workflow":
+      const {
+        mapUnit: isMapUnit,
+        ...mapUnitConfig
+      } = config;
+      if (isMapUnit) {
+        const mapUnit = createMapUnit({
+          config: mapUnitConfig,
+          unitFactoryCls
+        });
+        workflow.addMapUnit(mapUnit, unit);
+      } else {
+        console.log("adding workflows directly to workflows is not supported.");
+      }
+      break;
+    case "subworkflow":
+      workflow.addSubworkflow(unit);
+      break;
+    default:
+      throw new Error(`workflow type=${type} not understood.`);
+  }
+  /* eslint-enable no-case-declarations */
+  return workflow;
+}
+
+/**
+ * @summary Convert a flattened array of workflow units to a properly constructed workflow
+ * @param wfUnits {Array} array of workflow units
+ * @param workflowCls {*} workflow class
+ * @param unitFactoryCls {*} unit factory class
+ * @returns {*} constructed workflow
+ */
+function createFromWorkflowUnits({
+  wfUnits,
+  workflowCls,
+  unitFactoryCls
+}) {
+  let workflow, unit, config, type;
+  wfUnits.map(wfUnit => {
+    ({
+      unit,
+      config,
+      type
+    } = wfUnit);
+    if (!workflow) {
+      workflow = createWorkflowHead({
+        workflow,
+        unit,
+        type,
+        workflowCls
+      });
+    } else {
+      workflow = composeWorkflow({
+        workflow,
+        unit,
+        config,
+        type,
+        unitFactoryCls
+      });
+    }
+    return null;
+  });
+  return (0, _utils.applyConfig)({
+    obj: workflow,
+    config
+  });
+}
+
+/**
+ * @summary Creates a flattened array of workflow units from nested workflow/subworkflow
+ * configuration data comprising a simple or complex workflow
+ * @param appName
+ * @param units
+ * @param swArgs
+ * @returns {*[]}
+ */
+function createWorkflowUnits({
+  appName,
+  workflowData,
+  workflowSubworkflowMapByApplication,
+  workflowCls,
+  ...swArgs
+}) {
+  const wfUnits = [];
+  const {
+    units
+  } = workflowData;
+  let unit, config;
+  units.map(unitData => {
+    const {
+      type
+    } = unitData;
+    switch (type) {
+      case "workflow":
+        ({
+          config
+        } = unitData);
+        unit = createWorkflowUnits({
+          appName,
+          workflowData: unitData,
+          workflowSubworkflowMapByApplication,
+          workflowCls,
+          ...swArgs
+        });
+        break;
+      case "subworkflow":
+        ({
+          config
+        } = workflowData);
+        unit = createSubworkflowUnit({
+          appName,
+          unitData,
+          workflowData: workflowSubworkflowMapByApplication,
+          ...swArgs
+        });
+        break;
+      default:
+        break;
+    }
+    wfUnits.push({
+      config,
+      unit,
+      type
+    });
+    return null;
+  });
+  return createFromWorkflowUnits({
+    wfUnits,
+    workflowCls,
+    subworkflowCls: swArgs.subworkflowCls,
+    unitFactoryCls: swArgs.unitFactoryCls
+  });
+}
+function createWorkflow({
+  appName,
+  workflowData,
+  workflowSubworkflowMapByApplication,
+  workflowCls = _workflow.Workflow,
+  ...swArgs
+}) {
+  const {
+    name
+  } = workflowData;
+  console.log(`wode: creating ${appName} workflow ${name}`);
+  const wf = createWorkflowUnits({
+    appName,
+    workflowData,
+    workflowSubworkflowMapByApplication,
+    workflowCls,
+    ...swArgs
+  });
+  wf.setName(name);
+  wf.applicationName = appName;
+  return wf;
+}

package/dist/workflows/default.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  name: "New Workflow",
+  properties: [],
+  subworkflows: [{
+    _id: "c6e9dbbee8929de01f4e76ee",
+    application: {
+      name: "espresso",
+      summary: "Quantum Espresso",
+      version: "6.3"
+    },
+    model: {
+      method: {
+        subtype: "us",
+        type: "pseudopotential"
+      },
+      subtype: "gga",
+      type: "dft"
+    },
+    name: "New Subworkflow",
+    properties: [],
+    units: []
+  }],
+  workflows: [],
+  units: [{
+    _id: "c6e9dbbee8929de01f4e76ee",
+    flowchartId: "da2c090ede4dc2fa6e66647f",
+    head: true,
+    monitors: [],
+    postProcessors: [],
+    preProcessors: [],
+    results: [],
+    type: "subworkflow",
+    name: "New Subworkflow"
+  }]
+};

package/dist/workflows/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Workflow", {
+  enumerable: true,
+  get: function () {
+    return _workflow.Workflow;
+  }
+});
+exports.createWorkflowConfigs = createWorkflowConfigs;
+exports.createWorkflows = createWorkflows;
+var _ade = require("@exabyte-io/ade.js");
+var _JSONSchemasInterface = _interopRequireDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+var _schemas = _interopRequireDefault(require("@mat3ra/esse/dist/js/schemas.json"));
+var _standata = require("@mat3ra/standata");
+var _patch = require("../patch");
+var _create = require("./create");
+var _workflow = require("./workflow");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Import Template here to apply context provider patch
+// eslint-disable-next-line no-unused-vars
+
+// Running this to set schemas for validation, removing the redundant data from application-flavors tree: `flavors`
+_JSONSchemasInterface.default.setSchemas(_schemas.default);
+
+/*
+    Workflow construction follows these rules:
+        1. Workflow is constructed as a collection of subworkflows defined in JSON
+        2. A "units" key should contain at least one object referencing the workflow itself
+        3. Additional workflows are added in order specified in the same "units" array
+        4. map units are added along with their workflows according to data in "units"
+        5. top-level subworkflows are added directly in the order also specified by "units"
+ */
+function createWorkflows({
+  appName = null,
+  workflowCls = _workflow.Workflow,
+  workflowSubworkflowMapByApplication = _standata.workflowSubforkflowMapByApplication,
+  ...swArgs
+}) {
+  let apps = appName !== null ? [appName] : _ade.allApplications;
+  const allApplicationsFromWorkflowData = Object.keys(workflowSubworkflowMapByApplication.workflows);
+  // output warning if allApplications and allApplicationsFromWorkflowData do not match
+  if (appName === null) {
+    if (apps.sort().join(",") !== allApplicationsFromWorkflowData.sort().join(",")) {
+      // eslint-disable-next-line no-console
+      console.warn(`Warning: allApplications and allApplicationsFromWorkflowData do not match: 
+                ${apps.sort().join(",")} !== ${allApplicationsFromWorkflowData.sort().join(",")}`);
+      console.warn("Using allApplicationsFromWorkflowData");
+    }
+    apps = allApplicationsFromWorkflowData;
+  }
+  const wfs = [];
+  const {
+    workflows
+  } = workflowSubworkflowMapByApplication;
+  apps.map(name => {
+    const {
+      [name]: dataByApp
+    } = workflows;
+    Object.values(dataByApp).map(workflowDataForApp => {
+      wfs.push((0, _create.createWorkflow)({
+        appName: name,
+        workflowData: workflowDataForApp,
+        workflowSubworkflowMapByApplication,
+        workflowCls,
+        ...swArgs
+      }));
+      return null;
+    });
+    return null;
+  });
+  return wfs;
+}
+
+/**
+ * @summary Create workflow configurations for all applications
+ * @param applications {Array<String>} array of application names
+ * @param workflowCls {*} workflow class to instantiate
+ * @param workflowSubworkflowMapByApplication {Object} object containing all workflow/subworkflow map by application
+ * @param swArgs {Object} other classes for instantiation
+ * @returns {Array<Object>} array of workflow configurations
+ */
+function createWorkflowConfigs({
+  applications,
+  workflowCls = _workflow.Workflow,
+  workflowSubworkflowMapByApplication,
+  ...swArgs
+}) {
+  const configs = [];
+  applications.forEach(app => {
+    const workflows = createWorkflows({
+      appName: app,
+      workflowCls,
+      workflowSubworkflowMapByApplication,
+      ...swArgs
+    });
+    workflows.forEach(wf => {
+      configs.push({
+        application: app,
+        name: wf.prop("name"),
+        config: wf.toJSON()
+      });
+    });
+  });
+  return configs;
+}

package/dist/workflows/relaxation.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RelaxationLogicMixin = void 0;
+var _standata = require("@mat3ra/standata");
+const RelaxationLogicMixin = superclass => class extends superclass {
+  get relaxationSubworkflow() {
+    const appName = this.subworkflows[0]?.application?.name;
+    if (!appName) return undefined;
+    const subworkflowStandata = new _standata.SubworkflowStandata();
+    const relaxationSubworkflow = subworkflowStandata.getRelaxationSubworkflowByApplication(appName);
+    return new this._Subworkflow(relaxationSubworkflow);
+  }
+  isRelaxationSubworkflow(subworkflow) {
+    const {
+      relaxationSubworkflow
+    } = this;
+    return relaxationSubworkflow?.systemName !== undefined && relaxationSubworkflow.systemName === subworkflow.systemName;
+  }
+  get hasRelaxation() {
+    return this.subworkflows.some(subworkflow => this.isRelaxationSubworkflow(subworkflow));
+  }
+  toggleRelaxation() {
+    if (this.hasRelaxation) {
+      const relaxSubworkflow = this.subworkflows.find(sw => this.isRelaxationSubworkflow(sw));
+      this.removeSubworkflow(relaxSubworkflow.id);
+    } else {
+      const vcRelax = this.relaxationSubworkflow;
+      if (vcRelax) {
+        this.addSubworkflow(vcRelax, true);
+      }
+    }
+  }
+};
+exports.RelaxationLogicMixin = RelaxationLogicMixin;