@mat3ra/wode 2025.10.1-0

package/dist/workflows/workflow.js

@@ -0,0 +1,303 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Workflow = void 0;
+var _ide = require("@exabyte-io/ide.js");
+var _mode = require("@exabyte-io/mode.js");
+var _entity = require("@mat3ra/code/dist/js/entity");
+var _workflow = _interopRequireDefault(require("@mat3ra/esse/dist/js/schema/workflow.json"));
+var _utils = require("@mat3ra/utils");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _mixwith = require("mixwith");
+var _underscore = _interopRequireDefault(require("underscore"));
+var _underscore2 = _interopRequireDefault(require("underscore.string"));
+var _enums = require("../enums");
+var _subworkflow = require("../subworkflows/subworkflow");
+var _units = require("../units");
+var _factory = require("../units/factory");
+var _utils2 = require("../utils");
+var _default = _interopRequireDefault(require("./default"));
+var _relaxation = require("./relaxation");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable max-classes-per-file */
+const {
+  MODEL_NAMES
+} = _mode.tree;
+class BaseWorkflow extends (0, _mixwith.mix)(_entity.NamedDefaultableRepetitionContextAndRenderInMemoryEntity).with(_ide.ComputedEntityMixin, _relaxation.RelaxationLogicMixin) {}
+class Workflow extends BaseWorkflow {
+  constructor(config) {
+    if (!config._id) config._id = Workflow.generateWorkflowId(config.name);
+    super(config);
+    this._Subworkflow = _subworkflow.Subworkflow;
+    this._UnitFactory = _factory.UnitFactory;
+    this._Workflow = Workflow;
+    this._MapUnit = _units.MapUnit;
+    if (!config.skipInitialize) this.initialize();
+  }
+  initialize() {
+    const me = this;
+    this._subworkflows = this.prop("subworkflows").map(x => new me._Subworkflow(x));
+    this._units = this.prop("units").map(unit => me._UnitFactory.create(unit));
+    this._json.workflows = this._json.workflows || [];
+    this._workflows = this.prop("workflows").map(x => new me._Workflow(x));
+  }
+  static get defaultConfig() {
+    return _default.default;
+  }
+  static generateWorkflowId(...args) {
+    args[0] = `workflow-${args[0]}`;
+    if (this.usePredefinedIds) return _utils.Utils.uuid.getUUIDFromNamespace(...args);
+    return _utils.Utils.uuid.getUUID();
+  }
+  static fromSubworkflow(subworkflow, ClsConstructor = Workflow) {
+    const config = {
+      name: subworkflow.name,
+      subworkflows: [subworkflow.toJSON()],
+      units: (0, _utils2.setNextLinks)((0, _utils2.setUnitsHead)([subworkflow.getAsUnit().toJSON()])),
+      properties: subworkflow.properties
+    };
+    return new ClsConstructor(config);
+  }
+  static fromSubworkflows(name, ClsConstructor = Workflow, ...subworkflows) {
+    return new ClsConstructor(name, subworkflows, subworkflows.map(sw => sw.getAsUnit()));
+  }
+
+  /**
+   * @summary Adds subworkflow to current workflow.
+   * @param subworkflow {Subworkflow}
+   * @param head {Boolean}
+   */
+  addSubworkflow(subworkflow, head = false, index = -1) {
+    const subworkflowUnit = subworkflow.getAsUnit();
+    if (head) {
+      this.subworkflows.unshift(subworkflow);
+      this.addUnit(subworkflowUnit, head, index);
+    } else {
+      this.subworkflows.push(subworkflow);
+      this.addUnit(subworkflowUnit, head, index);
+    }
+  }
+  removeSubworkflow(id) {
+    const subworkflowUnit = this.units.find(u => u.id === id);
+    if (subworkflowUnit) this.removeUnit(subworkflowUnit.flowchartId);
+  }
+  subworkflowId(index) {
+    const sw = this.prop(`subworkflows[${index}]`);
+    return sw ? sw._id : null;
+  }
+  replaceSubworkflowAtIndex(index, newSubworkflow) {
+    this._subworkflows[index] = newSubworkflow;
+    this.setUnits((0, _utils2.setNextLinks)((0, _utils2.setUnitsHead)(this._units)));
+  }
+  get units() {
+    return this._units;
+  }
+  setUnits(arr) {
+    this._units = arr;
+  }
+
+  // returns a list of `app` Classes
+  get usedApplications() {
+    const swApplications = this.subworkflows.map(sw => sw.application);
+    const wfApplications = _lodash.default.flatten(this.workflows.map(w => w.usedApplications));
+    return _lodash.default.uniqBy(swApplications.concat(wfApplications), a => a.name);
+  }
+
+  // return application names
+  get usedApplicationNames() {
+    return this.usedApplications.map(a => a.name);
+  }
+  get usedApplicationVersions() {
+    return this.usedApplications.map(a => a.version);
+  }
+  get usedApplicationNamesWithVersions() {
+    return this.usedApplications.map(a => `${a.name} ${a.version}`);
+  }
+  get usedModels() {
+    return _lodash.default.uniq(this.subworkflows.map(sw => sw.model.type));
+  }
+  get humanReadableUsedModels() {
+    return this.usedModels.filter(m => m !== "unknown").map(m => MODEL_NAMES[m]);
+  }
+  toJSON(exclude = []) {
+    return _lodash.default.omit({
+      ...super.toJSON(),
+      units: this._units.map(x => x.toJSON()),
+      subworkflows: this._subworkflows.map(x => x.toJSON()),
+      workflows: this.workflows.map(x => x.toJSON()),
+      ...(this.compute ? {
+        compute: this.compute
+      } : {}) // {"compute": null } won't pass esse validation
+    }, exclude);
+  }
+  get isDefault() {
+    return this.prop("isDefault", false);
+  }
+  get isMultiMaterial() {
+    const fromSubworkflows = this.subworkflows.some(sw => sw.isMultiMaterial);
+    return this.prop("isMultiMaterial") || fromSubworkflows;
+  }
+  set isMultiMaterial(value) {
+    this.setProp("isMultiMaterial", value);
+  }
+  set isUsingDataset(value) {
+    this.setProp("isUsingDataset", value);
+  }
+  get isUsingDataset() {
+    return !!this.prop("isUsingDataset", false);
+  }
+  get properties() {
+    return _lodash.default.uniq(_lodash.default.flatten(this._subworkflows.map(x => x.properties)));
+  }
+  get humanReadableProperties() {
+    return this.properties.map(name => _underscore2.default.humanize(name));
+  }
+  get systemName() {
+    return _underscore2.default.slugify(`${this.usedApplicationNames.join(":")}-${this.name.toLowerCase()}`);
+  }
+  get defaultDescription() {
+    return `${this.usedModels.join(", ").toUpperCase()} workflow using ${this.usedApplicationNames.join(", ")}.`;
+  }
+  get exabyteId() {
+    return this.prop("exabyteId");
+  }
+  get hash() {
+    return this.prop("hash", "");
+  }
+  get isOutdated() {
+    return this.prop("isOutdated", false);
+  }
+  get history() {
+    return this.prop("history", []);
+  }
+  setMethodData(methodData) {
+    this.subworkflows.forEach(sw => {
+      const method = methodData.getMethodBySubworkflow(sw);
+      if (method) sw.model.setMethod(method);
+    });
+    this.workflows.forEach(wf => {
+      wf.subworkflows.forEach(sw => {
+        const method = methodData.getMethodBySubworkflow(sw);
+        if (method) sw.model.setMethod(method);
+      });
+    });
+  }
+
+  /**
+   * @param unit {Unit}
+   * @param head {Boolean}
+   * @param index {Number}
+   */
+  addUnit(unit, head = false, index = -1) {
+    const {
+      units
+    } = this;
+    if (units.length === 0) {
+      unit.head = true;
+      this.setUnits([unit]);
+    } else {
+      if (head) {
+        units.unshift(unit);
+      } else if (index >= 0) {
+        units.splice(index, 0, unit);
+      } else {
+        units.push(unit);
+      }
+      this.setUnits((0, _utils2.setNextLinks)((0, _utils2.setUnitsHead)(units)));
+    }
+  }
+  removeUnit(flowchartId) {
+    if (this.units.length < 2) return;
+    const unit = this.units.find(x => x.flowchartId === flowchartId);
+    const previousUnit = this.units.find(x => x.next === unit.flowchartId);
+    if (previousUnit) {
+      delete previousUnit.next;
+    }
+    this._subworkflows = this._subworkflows.filter(x => x.id !== unit.id);
+    this._units = (0, _utils2.setNextLinks)((0, _utils2.setUnitsHead)(this._units.filter(x => x.flowchartId !== flowchartId)));
+  }
+
+  /**
+   * @return Subworkflow[]
+   */
+  get subworkflows() {
+    return this._subworkflows;
+  }
+  get workflows() {
+    return this._workflows;
+  }
+
+  /*
+   * @param type {String|Object} Unit type, map or subworkflow
+   * @param head {Boolean}
+   * @param index {Number} Index at which the unit will be added. -1 by default (ignored).
+   */
+  addUnitType(type, head = false, index = -1) {
+    switch (type) {
+      case _enums.UNIT_TYPES.map:
+        // eslint-disable-next-line no-case-declarations
+        const workflowConfig = _default.default;
+        // eslint-disable-next-line no-case-declarations
+        const mapUnit = new this._MapUnit();
+        workflowConfig._id = this._Workflow.generateWorkflowId(workflowConfig.name);
+        this.prop("workflows").push(workflowConfig);
+        this._workflows = this.prop("workflows").map(x => new this._Workflow(x));
+        mapUnit.setWorkflowId(workflowConfig._id);
+        this.addUnit(mapUnit, head, index);
+        break;
+      case _enums.UNIT_TYPES.subworkflow:
+        this.addSubworkflow(this._Subworkflow.createDefault(), head, index);
+        break;
+      default:
+        console.log(`unit_type=${type} unrecognized, skipping.`);
+    }
+  }
+  addMapUnit(mapUnit, mapWorkflow) {
+    const mapWorkflowConfig = mapWorkflow.toJSON();
+    if (!mapWorkflowConfig._id) mapWorkflowConfig._id = this._Workflow.generateWorkflowId(mapWorkflowConfig.name);
+    mapUnit.setWorkflowId(mapWorkflowConfig._id);
+    this.addUnit(mapUnit);
+    this._json.workflows.push(mapWorkflowConfig);
+    const me = this;
+    this._workflows = this.prop("workflows").map(x => new me._Workflow(x));
+  }
+  findSubworkflowById(id) {
+    if (!id) return;
+    const workflows = this.workflows || [];
+    const subworkflows = this.subworkflows || [];
+    const subworkflow = subworkflows.find(sw => sw.id === id);
+    if (subworkflow) return subworkflow;
+    const workflow = workflows.find(w => w.findSubworkflowById(id));
+    if (workflow) return workflow.findSubworkflowById(id);
+    console.warn("attempted to find a non-existing subworkflow");
+  }
+  get allSubworkflows() {
+    const subworkflowsList = [];
+    this.subworkflows.forEach(sw => subworkflowsList.push(sw));
+    this.workflows.forEach(workflow => {
+      return Array.prototype.push.apply(subworkflowsList, workflow.allSubworkflows);
+    });
+    return subworkflowsList;
+  }
+
+  /**
+   * @summary Calculates hash of the workflow. Meaningful fields are units and subworkflows.
+   * units and subworkflows must be sorted topologically before hashing (already sorted).
+   */
+  calculateHash() {
+    const meaningfulFields = {
+      units: _underscore.default.map(this.units, u => u.calculateHash()).join(),
+      subworkflows: _underscore.default.map(this.subworkflows, sw => sw.calculateHash()).join(),
+      workflows: _underscore.default.map(this.workflows, w => w.calculateHash()).join()
+    };
+    return _utils.Utils.hash.calculateHashFromObject(meaningfulFields);
+  }
+}
+exports.Workflow = Workflow;
+_defineProperty(Workflow, "getDefaultComputeConfig", _ide.getDefaultComputeConfig);
+_defineProperty(Workflow, "jsonSchema", _workflow.default);
+_defineProperty(Workflow, "usePredefinedIds", false);

package/package.json

@@ -0,0 +1,94 @@
+{
+    "name": "@mat3ra/wode",
+    "version": "2025.10.1-0",
+    "description": "WOrkflow DEfinitions",
+    "scripts": {
+        "test": "nyc --reporter=text mocha --recursive --bail --require @babel/register/lib --require tests/setup.js tests",
+        "lint": "eslint src tests && prettier --write src tests",
+        "lint:fix": "eslint --fix --cache src tests && prettier --write src tests",
+        "transpile": "babel --out-dir dist src",
+        "postinstall": "npm run transpile",
+        "prettier": "prettier --check src tests",
+        "prepare": "husky install || exit 0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Exabyte-io/wode.git"
+    },
+    "main": "dist/index.js",
+    "files": [
+        "/assets",
+        "/dist",
+        "/src",
+        ".babelrc",
+        "build_workflows.js"
+    ],
+    "author": "Exabyte Inc.",
+    "bugs": {
+        "url": "https://github.com/Exabyte-io/wode/issues"
+    },
+    "license": "Apache-2.0",
+    "homepage": "https://github.com/Exabyte-io/wode",
+    "dependencies": {
+        "@babel/cli": "7.16.0",
+        "@babel/core": "7.16.0",
+        "@babel/eslint-parser": "7.16.3",
+        "@babel/plugin-proposal-class-properties": "7.16.0",
+        "@babel/preset-env": "7.16.4",
+        "@babel/preset-react": "7.16.7",
+        "@babel/register": "^7.16.0",
+        "@babel/runtime-corejs3": "7.16.8",
+        "@exabyte-io/periodic-table.js": "2022.6.8-0",
+        "crypto-js": "^4.2.0",
+        "js-yaml": "^4.1.0",
+        "lodash": "^4.17.21",
+        "mixwith": "^0.1.1",
+        "underscore": "^1.13.3",
+        "underscore.string": "^3.3.4",
+        "v20": "^0.1.0"
+    },
+    "devDependencies": {
+        "@exabyte-io/ade.js": "2025.9.20-0",
+        "@exabyte-io/eslint-config": "2025.5.13-0",
+        "@exabyte-io/ide.js": "2024.3.26-0",
+        "@exabyte-io/mode.js": "2024.4.28-0",
+        "@mat3ra/utils": "2025.9.20-0",
+        "@mat3ra/code": "2025.7.15-0",
+        "@mat3ra/esse": "2025.7.15-0",
+        "@mat3ra/made": "2025.7.15-0",
+        "@mat3ra/standata": "2025.10.1-0",
+        "chai": "^4.3.4",
+        "eslint": "7.32.0",
+        "eslint-config-airbnb": "19.0.2",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-import-resolver-exports": "^1.0.0-beta.2",
+        "eslint-plugin-import": "2.25.3",
+        "eslint-plugin-jsdoc": "37.1.0",
+        "eslint-plugin-jsx-a11y": "6.5.1",
+        "eslint-plugin-prettier": "^4.2.1",
+        "eslint-plugin-react": "7.30.0",
+        "eslint-plugin-simple-import-sort": "7.0.0",
+        "husky": "^7.0.4",
+        "lint-staged": "^12.1.2",
+        "mocha": "^9.1.3",
+        "nyc": "^15.1.0",
+        "prettier": "^2.7.1"
+    },
+    "peerDependencies": {
+        "@exabyte-io/ade.js": "*",
+        "@exabyte-io/ide.js": "*",
+        "@exabyte-io/mode.js": "*",
+        "@mat3ra/standata": "*",
+        "@mat3ra/utils": "*",
+        "@mat3ra/code": "*",
+        "@mat3ra/esse": "*",
+        "@mat3ra/made": "*"
+    },
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "lint-staged": {
+        "*.js": "eslint --cache --fix",
+        "*.{js,css}": "prettier --write"
+    }
+}

package/src/context/context.js

@@ -0,0 +1,47 @@
+import { BoundaryConditionsFormDataProvider } from "./providers/BoundaryConditionsFormDataProvider";
+import QENEBContextProvider from "./providers/by_application/espresso/QENEBContextProvider";
+import QEPWXContextProvider from "./providers/by_application/espresso/QEPWXContextProvider";
+import NWChemTotalEnergyContextProvider from "./providers/by_application/nwchem/NWChemTotalEnergyContextProvider";
+import VASPContextProvider from "./providers/by_application/vasp/VASPContextProvider";
+import VASPNEBContextProvider from "./providers/by_application/vasp/VASPNEBContextProvider";
+import { CollinearMagnetizationContextProvider } from "./providers/CollinearMagnetizationContextProvider";
+import { HubbardContextProviderLegacy } from "./providers/HubbardContextProviderLegacy";
+import { HubbardJContextProvider } from "./providers/HubbardJContextProvider";
+import { HubbardUContextProvider } from "./providers/HubbardUContextProvider";
+import { HubbardVContextProvider } from "./providers/HubbardVContextProvider";
+import { IonDynamicsContextProvider } from "./providers/IonDynamicsContextProvider";
+import { MLSettingsContextProvider } from "./providers/MLSettingsContextProvider";
+import { MLTrainTestSplitContextProvider } from "./providers/MLTrainTestSplitContextProvider";
+import { NEBFormDataProvider } from "./providers/NEBFormDataProvider";
+import { NonCollinearMagnetizationContextProvider } from "./providers/NonCollinearMagnetizationContextProvider";
+import { PlanewaveCutoffsContextProvider } from "./providers/PlanewaveCutoffsContextProvider";
+import { PointsGridFormDataProvider } from "./providers/PointsGridFormDataProvider";
+import {
+    ExplicitPointsPath2PIBAFormDataProvider,
+    ExplicitPointsPathFormDataProvider,
+    PointsPathFormDataProvider,
+} from "./providers/PointsPathFormDataProvider";
+
+export default {
+    BoundaryConditionsFormDataProvider,
+    MLSettingsContextProvider,
+    MLTrainTestSplitContextProvider,
+    NEBFormDataProvider,
+    PlanewaveCutoffsContextProvider,
+    PointsGridFormDataProvider,
+    PointsPathFormDataProvider,
+    ExplicitPointsPathFormDataProvider,
+    ExplicitPointsPath2PIBAFormDataProvider,
+    HubbardJContextProvider,
+    HubbardUContextProvider,
+    HubbardVContextProvider,
+    HubbardContextProviderLegacy,
+    IonDynamicsContextProvider,
+    CollinearMagnetizationContextProvider,
+    NonCollinearMagnetizationContextProvider,
+    VASPContextProvider,
+    VASPNEBContextProvider,
+    QEPWXContextProvider,
+    QENEBContextProvider,
+    NWChemTotalEnergyContextProvider,
+};

package/src/context/mixins/ApplicationContextMixin.js

@@ -0,0 +1,19 @@
+import { globalSettings } from "../providers/settings";
+
+export function applicationContextMixin(item) {
+    const properties = {
+        _application: undefined,
+
+        initApplicationContextMixin() {
+            this._application =
+                (this.config.context && this.config.context.application) ||
+                globalSettings.Application.createDefault();
+        },
+
+        get application() {
+            return this._application;
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/JobContextMixin.js

@@ -0,0 +1,36 @@
+const defaultJob = {
+    workflow: {
+        subworkflows: [],
+        units: [],
+    },
+    status: "pre-submission",
+    compute: {
+        queue: "D",
+        nodes: 1,
+        ppn: 1,
+        timeLimit: "3600",
+    },
+    _project: {
+        _id: "",
+    },
+};
+
+export function jobContextMixin(item) {
+    const properties = {
+        isEdited: false,
+
+        _job: defaultJob,
+
+        get job() {
+            return this._job;
+        },
+
+        initJobContextMixin() {
+            const { config } = this;
+            this._job = (config.context && config.context.job) || defaultJob;
+            this.isEdited = false; // we always get the `defaultData` (recalculated from scratch, not persistent)
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/MaterialContextMixin.js

@@ -0,0 +1,41 @@
+import { globalSettings } from "../providers/settings";
+
+export function materialContextMixin(item) {
+    const properties = {
+        _material: undefined,
+
+        updateMaterialHash() {
+            if (this.isEditedIsSetToFalseOnMaterialUpdate) this.isEdited = false;
+            this.extraData = { materialHash: this.material.hash };
+        },
+
+        // Workaround: Material.createDefault() used to initiate workflow reducer and hence here too
+        //  does not have an id. Here we catch when such material is used and avoid resetting isEdited
+        get isMaterialCreatedDefault() {
+            return !this.material.id;
+        },
+
+        get isMaterialUpdated() {
+            return Boolean(this.extraData && this.extraData.materialHash !== this.material.hash);
+        },
+
+        get material() {
+            if (!this._material) {
+                throw new Error("Material is not set");
+            }
+            return this._material;
+        },
+
+        initMaterialContextMixin() {
+            this._material = this.config.context && this.config.context.material;
+
+            if (!this._material) {
+                this._material = globalSettings.Material.createDefault();
+            }
+
+            this.updateMaterialHash();
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/MaterialsContextMixin.js

@@ -0,0 +1,18 @@
+import { globalSettings } from "../providers/settings";
+
+export function materialsContextMixin(item) {
+    const properties = {
+        get materials() {
+            return this._materials;
+        },
+        initMaterialsContextMixin() {
+            const materials = this.config.context?.materials;
+            this._materials =
+                materials && materials.length
+                    ? materials
+                    : [globalSettings.Material.createDefault()];
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/MaterialsSetContextMixin.js

@@ -0,0 +1,24 @@
+import { compareEntitiesInOrderedSetForSorting } from "@mat3ra/code/dist/js/entity/set/ordered/utils";
+
+export function materialsSetContextMixin(item) {
+    const properties = {
+        _materialsSet: undefined,
+
+        get materialsSet() {
+            return this._materialsSet;
+        },
+
+        initMaterialsSetContextMixin() {
+            this._materialsSet = this.config.context?.materialsSet;
+        },
+
+        sortMaterialsByIndexInSet(materials = []) {
+            // DO NOT SORT IN PLACE AS IT CHANGES THE ORDER IN `this.materials` AND HAS SIDE EFFECTS (MaterialViewer).
+            return materials.concat().sort((a, b) => {
+                return compareEntitiesInOrderedSetForSorting(a, b, this.materialsSet._id, false);
+            });
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/MethodDataContextMixin.js

@@ -0,0 +1,48 @@
+import CryptoJS from "crypto-js";
+
+export function methodDataContextMixin(item) {
+    const properties = {
+        _methodData: undefined,
+
+        isEdited: false,
+
+        methodDataHash: undefined,
+
+        extraData: undefined,
+
+        initMethodDataContextMixin() {
+            this._methodData = (this.config.context && this.config.context.methodData) || {};
+            this.isEdited = Boolean(this.config.isEdited);
+        },
+
+        /* @summary Replace the logic in constructor with this in order to enable passing `methodDataHash` between
+         *          subsequent initializations of the derived class. Not used at present and kept for the record.
+         */
+        _initMethodDataHash() {
+            this.methodDataHash = CryptoJS.MD5(JSON.stringify(this.methodData)).toString();
+            this.extraData = { methodDataHash: this.methodDataHash };
+            if (!this._methodData) {
+                this._methodData = {};
+                this.isEdited = false;
+                // Commented out to reduce effect on performance. Uncomment for debugging purposes.
+                // TODO: remove on next refactoring or convert to log
+                // console.warn("MethodDataContextMixin: methodData is undefined or null");
+            } else if (this.isMethodDataUpdated) {
+                this.isEdited = false;
+            } else {
+                // eslint-disable-next-line no-undef
+                this.isEdited = config.isEdited;
+            }
+        },
+
+        get methodData() {
+            return this._methodData;
+        },
+
+        get isMethodDataUpdated() {
+            return Boolean(this.extraData && this.extraData.methodDataHash !== this.methodDataHash);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/context/mixins/WorkflowContextMixin.js

@@ -0,0 +1,25 @@
+const defaultWorkflow = {
+    subworkflows: [],
+    units: [],
+    hasRelaxation: false,
+};
+
+export function workflowContextMixin(item) {
+    const properties = {
+        isEdited: false,
+
+        _workflow: defaultWorkflow,
+
+        get workflow() {
+            return this._workflow;
+        },
+
+        initWorkflowContextMixin() {
+            const { config } = this; // as WorkflowConfig;
+            this._workflow = (config.context && config.context.workflow) || defaultWorkflow;
+            this.isEdited = false; // we always get the `defaultData` (recalculated from scratch, not persistent)
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}