@mat3ra/wode 2026.4.9-0 → 2026.5.29-0

package/src/js/units/SubworkflowUnit.ts

@@ -0,0 +1,44 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { SubworkflowUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import { UnitType } from "../enums";
+import {
+    type SubworkflowUnitSchemaMixin,
+    subworkflowUnitSchemaMixin,
+} from "../generated/SubworkflowUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+
+type Schema = SubworkflowUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<SubworkflowUnitSchemaMixin>;
+
+export type SubworkflowUnitConfig = Partial<Omit<Schema, "flowchartId">> &
+    Pick<Schema, "flowchartId">;
+
+class SubworkflowUnit extends (BaseUnit as Base) implements Schema {
+    declare toJSON: () => Schema & AnyObject;
+
+    declare _json: Schema & AnyObject;
+
+    static get jsonSchema() {
+        return JSONSchemasInterface.getSchemaById("workflow/unit/subworkflow");
+    }
+
+    constructor(config: SubworkflowUnitConfig) {
+        const schema: Schema = {
+            name: "New Subworkflow",
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            ...config,
+            type: UnitType.subworkflow,
+        };
+        super(schema);
+    }
+}
+
+subworkflowUnitSchemaMixin(SubworkflowUnit.prototype);
+
+export default SubworkflowUnit;

package/src/js/units/factory.ts

@@ -0,0 +1,131 @@
+import type {
+    AssertionUnitSchema,
+    AssignmentUnitSchema,
+    ConditionUnitSchema,
+    DataIOUnitSchema,
+    ExecutionUnitSchema,
+    MapUnitSchema,
+    ReduceUnitSchema,
+    SubworkflowUnitSchema,
+    WorkflowUnitSchema,
+} from "@mat3ra/esse/dist/js/types";
+
+import { UnitType } from "../enums";
+import AssertionUnit, { type AssertionUnitConfig } from "./AssertionUnit";
+import AssignmentUnit, { type AssignmentUnitConfig } from "./AssignmentUnit";
+import ConditionUnit, { type ConditionUnitConfig } from "./ConditionUnit";
+import ExecutionUnit, { type ExecutionUnitConfig } from "./ExecutionUnit";
+import IOUnit, { type IOUnitConfig } from "./IOUnit";
+import MapUnit from "./MapUnit";
+import ReduceUnit from "./ReduceUnit";
+import SubworkflowUnit from "./SubworkflowUnit";
+
+export type AnyWorkflowUnit = MapUnit | SubworkflowUnit | ReduceUnit;
+
+export type AnyWorkflowUnitSchema = MapUnitSchema | SubworkflowUnitSchema | ReduceUnitSchema;
+
+export type AnySubworkflowUnit =
+    | ExecutionUnit
+    | AssignmentUnit
+    | ConditionUnit
+    | IOUnit
+    | AssertionUnit;
+
+export type AnySubworkflowUnitSchema =
+    | ExecutionUnitSchema
+    | AssertionUnitSchema
+    | AssignmentUnitSchema
+    | ConditionUnitSchema
+    | DataIOUnitSchema;
+
+type ExcutionConfig = ExecutionUnitConfig & Pick<ExecutionUnitSchema, "type">;
+type AssignmentConfig = AssignmentUnitConfig & Pick<AssignmentUnitSchema, "type">;
+type ConditionConfig = ConditionUnitConfig & Pick<ConditionUnitSchema, "type">;
+type IOConfig = IOUnitConfig & Pick<DataIOUnitSchema, "type">;
+type AssertionConfig = AssertionUnitConfig & Pick<AssertionUnitSchema, "type">;
+
+/** Subworkflow unit kinds supported by {@link UnitFactory.createDefaultSubworkflowUnit}. */
+export type DefaultSubworkflowUnitType =
+    | "execution"
+    | "assignment"
+    | "condition"
+    | "io"
+    | "assertion";
+
+export class UnitFactory {
+    /**
+     * Create a new subworkflow unit with fresh `flowchartId` and constructor defaults.
+     * For execution units, pass the subworkflow (or parent) `application` JSON.
+     */
+    static createDefaultSubworkflowUnit(
+        type: "execution",
+        application: ExecutionUnitSchema["application"],
+    ): AnySubworkflowUnit;
+
+    static createDefaultSubworkflowUnit(
+        type: "assignment" | "condition" | "io" | "assertion",
+    ): AnySubworkflowUnit;
+
+    static createDefaultSubworkflowUnit(
+        type: DefaultSubworkflowUnitType,
+        application?: ExecutionUnitSchema["application"],
+    ): AnySubworkflowUnit {
+        if (type === "execution") {
+            if (application === undefined) {
+                throw new Error(
+                    "UnitFactory.createDefaultSubworkflowUnit: application is required when type is execution",
+                );
+            }
+            return new ExecutionUnit({
+                type: UnitType.execution,
+                application,
+            });
+        }
+        switch (type) {
+            case "assignment":
+                return new AssignmentUnit({ type: UnitType.assignment });
+            case "condition":
+                return new ConditionUnit({ type: UnitType.condition });
+            case "io":
+                return new IOUnit({ type: UnitType.io });
+            case "assertion":
+                return new AssertionUnit({ type: UnitType.assertion });
+            default: {
+                const unreachable: never = type;
+                throw new Error(`Unexpected unit type: ${String(unreachable)}`);
+            }
+        }
+    }
+
+    static createInWorkflow(config: WorkflowUnitSchema): AnyWorkflowUnit {
+        switch (config.type) {
+            case UnitType.map:
+                return new MapUnit(config);
+            case UnitType.subworkflow:
+                return new SubworkflowUnit(config);
+            case UnitType.reduce:
+                return new ReduceUnit(config);
+            default:
+                throw new Error(`Unknown unit type: ${config.type}`);
+        }
+    }
+
+    static createInSubworkflow(
+        config: ExcutionConfig | AssignmentConfig | ConditionConfig | IOConfig | AssertionConfig,
+    ): AnySubworkflowUnit {
+        switch (config.type) {
+            case UnitType.execution:
+                return new ExecutionUnit(config);
+            case UnitType.assignment:
+                return new AssignmentUnit(config);
+            case UnitType.condition:
+                return new ConditionUnit(config);
+            case UnitType.io:
+                return new IOUnit(config);
+            case UnitType.assertion:
+                return new AssertionUnit(config);
+            default:
+                throw new Error(`Unknown unit type: ${config.type}`);
+        }
+    }
+}

package/src/js/units/index.ts

@@ -0,0 +1,27 @@
+import AssertionUnit from "./AssertionUnit";
+import AssignmentUnit from "./AssignmentUnit";
+import BaseUnit from "./BaseUnit";
+import ConditionUnit from "./ConditionUnit";
+import ExecutionUnit from "./ExecutionUnit";
+import { UnitFactory } from "./factory";
+import IOUnit from "./IOUnit";
+import MapUnit from "./MapUnit";
+import ReduceUnit from "./ReduceUnit";
+import SubworkflowUnit from "./SubworkflowUnit";
+
+export type { ReduceUnitConfig } from "./ReduceUnit";
+export type { SubworkflowUnitConfig } from "./SubworkflowUnit";
+export {
+    BaseUnit,
+    AssertionUnit,
+    AssignmentUnit,
+    ConditionUnit,
+    ExecutionUnit,
+    IOUnit,
+    MapUnit,
+    ReduceUnit,
+    SubworkflowUnit,
+    UnitFactory,
+};
+
+export type { DefaultSubworkflowUnitType } from "./factory";

package/src/js/units/mixins/RuntimeItemsUILogicMixin.ts

@@ -0,0 +1,81 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { RuntimeItems } from "@mat3ra/code/dist/js/entity/mixins/RuntimeItemsMixin";
+import type { NameResultSchema } from "@mat3ra/code/dist/js/utils/object";
+import type { RuntimeItemsSchema } from "@mat3ra/esse/dist/js/types";
+
+type ItemKey = "results" | "monitors" | "preProcessors" | "postProcessors";
+
+export type RuntimeItemsUILogic = {
+    _initRuntimeItems(config?: Partial<RuntimeItemsSchema>): void;
+    toggleRuntimeItem(key: ItemKey, data: NameResultSchema, isAdding: boolean): void;
+    toggleResult(data: NameResultSchema, isAdding: boolean): void;
+    toggleMonitor(data: NameResultSchema, isAdding: boolean): void;
+    togglePreProcessor(data: NameResultSchema, isAdding: boolean): void;
+    togglePostProcessor(data: NameResultSchema, isAdding: boolean): void;
+    getResultByName(name: string): NameResultSchema | undefined;
+    get resultNames(): string[];
+    get monitorNames(): string[];
+    get postProcessorNames(): string[];
+    get preProcessorNames(): string[];
+};
+
+type RuntimeItemsUILogicPrivate = {
+    toggleRuntimeItem(key: ItemKey, data: NameResultSchema, isAdding: boolean): void;
+};
+
+interface RuntimeItemsUILogicMixinBase extends InMemoryEntity, RuntimeItems {
+    defaultResults: NameResultSchema[];
+    defaultMonitors: NameResultSchema[];
+    defaultPreProcessors: NameResultSchema[];
+    defaultPostProcessors: NameResultSchema[];
+}
+
+// @ts-expect-error
+const propertiesMixin: RuntimeItemsUILogicMixinBase &
+    RuntimeItemsUILogic &
+    RuntimeItemsUILogicPrivate = {
+    _initRuntimeItems(config) {
+        this.results = config?.results || this.defaultResults;
+        this.monitors = config?.monitors || this.defaultMonitors;
+        this.preProcessors = config?.preProcessors || this.defaultPreProcessors;
+        this.postProcessors = config?.postProcessors || this.defaultPostProcessors;
+    },
+    toggleRuntimeItem(key: ItemKey, data: NameResultSchema, isAdding: boolean) {
+        if (isAdding) {
+            this[key] = [...this[key], data];
+        } else {
+            this[key] = this[key].filter((x) => x.name !== data.name);
+        }
+    },
+    toggleResult(data: NameResultSchema, isAdding: boolean) {
+        this.toggleRuntimeItem("results", data, isAdding);
+    },
+    toggleMonitor(data: NameResultSchema, isAdding: boolean) {
+        this.toggleRuntimeItem("monitors", data, isAdding);
+    },
+    togglePreProcessor(data: NameResultSchema, isAdding: boolean) {
+        this.toggleRuntimeItem("preProcessors", data, isAdding);
+    },
+    togglePostProcessor(data: NameResultSchema, isAdding: boolean) {
+        this.toggleRuntimeItem("postProcessors", data, isAdding);
+    },
+    get resultNames() {
+        return this.results.map((r) => r.name);
+    },
+    get monitorNames() {
+        return this.monitors.map((r) => r?.name);
+    },
+    get postProcessorNames() {
+        return this.postProcessors.map((r) => r.name);
+    },
+    get preProcessorNames() {
+        return this.preProcessors.map((r) => r.name);
+    },
+    getResultByName(name: string) {
+        return this.results.find((r) => r.name === name);
+    },
+};
+
+export function runtimeItemsUILogicMixin<T extends RuntimeItemsUILogicMixinBase>(item: T) {
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(propertiesMixin));
+}

package/src/js/utils/baseUnits.ts

@@ -0,0 +1,11 @@
+import type { WorkflowBaseUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import { UnitStatus } from "../enums";
+
+export function resetStatus<T extends WorkflowBaseUnitSchema>(unit: T) {
+    return {
+        ...unit,
+        status: UnitStatus.idle,
+        statusTrack: [],
+    };
+}

package/src/js/utils/index.ts

@@ -0,0 +1,3 @@
+export * as units from "./units";
+export * as workflow from "./workflow";
+export * as baseUnits from "./baseUnits";

package/src/js/utils/units.ts

@@ -0,0 +1,23 @@
+import type { SubworkflowSchema, WorkflowUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import { UnitType } from "../enums";
+import { UnitFactory } from "../units/factory";
+
+type SubworkflowUnitSchema = SubworkflowSchema["units"][number];
+
+function isWorkflowLevelUnit(
+    unit: WorkflowUnitSchema | SubworkflowUnitSchema,
+): unit is WorkflowUnitSchema {
+    return (
+        unit.type === UnitType.map ||
+        unit.type === UnitType.reduce ||
+        unit.type === UnitType.subworkflow
+    );
+}
+
+export function calculateHash(unit: WorkflowUnitSchema | SubworkflowUnitSchema): string {
+    if (isWorkflowLevelUnit(unit)) {
+        return UnitFactory.createInWorkflow(unit).calculateHash();
+    }
+    return UnitFactory.createInSubworkflow(unit).calculateHash();
+}

package/src/js/utils/workflow.ts

@@ -0,0 +1,69 @@
+import type { ApplicationSchema, WorkflowSchema } from "@mat3ra/esse/dist/js/types";
+import { MODEL_NAMES } from "@mat3ra/mode/dist/js/tree";
+import s from "underscore.string";
+
+import { resetStatus } from "./baseUnits";
+
+export function getUsedApplications(workflow: WorkflowSchema): ApplicationSchema[] {
+    const swApplications = workflow.subworkflows.map((sw) => sw.application);
+    const nestedWorkflows = workflow.workflows as WorkflowSchema[];
+    const wfApplications = nestedWorkflows.map(getUsedApplications).flat();
+
+    return [...swApplications, ...wfApplications].reduce<ApplicationSchema[]>((acc, app) => {
+        if (!acc.some((a) => a.name === app.name)) {
+            acc.push(app);
+        }
+        return acc;
+    }, []);
+}
+
+export function getSystemName(workflow: WorkflowSchema): string {
+    const applicationNames = getUsedApplications(workflow).map((a) => a.name);
+    return s.slugify(`${applicationNames.join(":")}-${workflow.name}`);
+}
+
+export function getUsedModels(workflow: WorkflowSchema) {
+    return workflow.subworkflows.map((sw) => sw.model.type);
+}
+
+export function getDefaultDescription(workflow: WorkflowSchema): string {
+    const applicationNames = getUsedApplications(workflow).map((a) => a.name);
+
+    return `${getUsedModels(workflow)
+        .join(", ")
+        .toUpperCase()} workflow using ${applicationNames.join(", ")}.`;
+}
+
+export function getProperties(workflow: WorkflowSchema) {
+    return [...new Set(workflow.subworkflows.map((sw) => sw.properties || []).flat())];
+}
+
+export function getHumanReadableProperties(workflow: WorkflowSchema) {
+    return getProperties(workflow).map((name) =>
+        name
+            .split("_")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+            .join(" "),
+    );
+}
+
+export function getHumanReadableUsedModels(workflow: WorkflowSchema) {
+    return getUsedModels(workflow)
+        .filter((m) => m !== "unknown")
+        .map((m) => MODEL_NAMES[m]);
+}
+
+export function resetUnitsStatuses(workflow: WorkflowSchema): WorkflowSchema {
+    return {
+        ...workflow,
+        subworkflows: workflow.subworkflows.map((subworkflow) => {
+            return {
+                ...subworkflow,
+                units: subworkflow.units.map(resetStatus),
+            };
+        }),
+        workflows: workflow.workflows?.map((wf) =>
+            resetUnitsStatuses(wf as WorkflowSchema),
+        ) as WorkflowSchema[],
+    };
+}

package/src/js/workflows/{default.js → default.ts}

@@ -1,4 +1,6 @@
-export default {
+import type { WorkflowSchema } from "@mat3ra/esse/dist/js/types";
+
+const defaultWorkflowConfig: WorkflowSchema = {
     name: "New Workflow",
     properties: [],
     subworkflows: [
@@ -6,7 +8,9 @@ export default {
             _id: "c6e9dbbee8929de01f4e76ee",
             application: {
                 name: "espresso",
+                shortName: "espresso",
                 summary: "Quantum Espresso",
+                build: "6.3",
                 version: "6.3",
             },
             model: {
@@ -16,6 +20,7 @@ export default {
                 },
                 subtype: "gga",
                 type: "dft",
+                functional: "other",
             },
             name: "New Subworkflow",
             properties: [],
@@ -37,3 +42,5 @@ export default {
         },
     ],
 };
+
+export default defaultWorkflowConfig;

package/build_workflows.js

@@ -1,65 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const yaml = require("js-yaml");
-
-const allApplications = [
-    "espresso",
-    "jupyterLab",
-    "nwchem",
-    "python",
-    "python/ml",
-    "shell",
-    "vasp",
-    "deepmd",
-];
-
-const allWorkflows = { workflows: {}, subworkflows: {} };
-
-const JSONstringifyOrder = (obj, space) => {
-    const allKeys = new Set();
-    // eslint-disable-next-line no-sequences
-    JSON.stringify(obj, (key, value) => (allKeys.add(key), value));
-    return JSON.stringify(obj, Array.from(allKeys).sort(), space);
-};
-
-const loadFile = (name, dir, file, type) => {
-    const entryPath = path.resolve(dir, file);
-    if (!fs.statSync(entryPath).isFile()) {
-        console.log(`Skipping ${entryPath} as it is not a file.`);
-        return;
-    }
-    const obj = fs.readFileSync(path.resolve(dir, file), "utf8");
-    const key = file.split(".")[0];
-    allWorkflows[type][name][key] = yaml.load(obj);
-};
-
-allApplications.forEach((name) => {
-    allWorkflows.workflows[name] = {};
-    allWorkflows.subworkflows[name] = {};
-    const wfDir = path.resolve(__dirname, "assets", "workflows", name);
-    const swDir = path.resolve(__dirname, "assets", "subworkflows", name);
-    try {
-        const wfFiles = fs.readdirSync(wfDir);
-        const swFiles = fs.readdirSync(swDir);
-        console.log(
-            `Building ${name}: ${wfFiles.length} workflow(s) and ${swFiles.length} subworkflow(s)`,
-        );
-        wfFiles.forEach((file) => loadFile(name, wfDir, file, "workflows"));
-        swFiles.forEach((file) => loadFile(name, swDir, file, "subworkflows"));
-    } catch (e) {
-        console.log(e);
-    }
-});
-
-const write_path = "workflows.js";
-// write to src for unit test coverage simplicity
-fs.writeFileSync(
-    `./src/workflows/${write_path}`,
-    "module.exports = {workflowData: " + JSONstringifyOrder(allWorkflows) + "}",
-    "utf8",
-);
-fs.writeFileSync(
-    `./dist/workflows/${write_path}`,
-    "module.exports = {workflowData: " + JSONstringifyOrder(allWorkflows) + "}",
-    "utf8",
-);

package/dist/js/context/context.js

@@ -1,49 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _BoundaryConditionsFormDataProvider = require("./providers/BoundaryConditionsFormDataProvider");
-var _QENEBContextProvider = _interopRequireDefault(require("./providers/by_application/espresso/QENEBContextProvider"));
-var _QEPWXContextProvider = _interopRequireDefault(require("./providers/by_application/espresso/QEPWXContextProvider"));
-var _NWChemTotalEnergyContextProvider = _interopRequireDefault(require("./providers/by_application/nwchem/NWChemTotalEnergyContextProvider"));
-var _VASPContextProvider = _interopRequireDefault(require("./providers/by_application/vasp/VASPContextProvider"));
-var _VASPNEBContextProvider = _interopRequireDefault(require("./providers/by_application/vasp/VASPNEBContextProvider"));
-var _CollinearMagnetizationContextProvider = require("./providers/CollinearMagnetizationContextProvider");
-var _HubbardContextProviderLegacy = require("./providers/HubbardContextProviderLegacy");
-var _HubbardJContextProvider = require("./providers/HubbardJContextProvider");
-var _HubbardUContextProvider = require("./providers/HubbardUContextProvider");
-var _HubbardVContextProvider = require("./providers/HubbardVContextProvider");
-var _IonDynamicsContextProvider = require("./providers/IonDynamicsContextProvider");
-var _MLSettingsContextProvider = require("./providers/MLSettingsContextProvider");
-var _MLTrainTestSplitContextProvider = require("./providers/MLTrainTestSplitContextProvider");
-var _NEBFormDataProvider = require("./providers/NEBFormDataProvider");
-var _NonCollinearMagnetizationContextProvider = require("./providers/NonCollinearMagnetizationContextProvider");
-var _PlanewaveCutoffsContextProvider = require("./providers/PlanewaveCutoffsContextProvider");
-var _PointsGridFormDataProvider = require("./providers/PointsGridFormDataProvider");
-var _PointsPathFormDataProvider = require("./providers/PointsPathFormDataProvider");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-var _default = exports.default = {
-  BoundaryConditionsFormDataProvider: _BoundaryConditionsFormDataProvider.BoundaryConditionsFormDataProvider,
-  MLSettingsContextProvider: _MLSettingsContextProvider.MLSettingsContextProvider,
-  MLTrainTestSplitContextProvider: _MLTrainTestSplitContextProvider.MLTrainTestSplitContextProvider,
-  NEBFormDataProvider: _NEBFormDataProvider.NEBFormDataProvider,
-  PlanewaveCutoffsContextProvider: _PlanewaveCutoffsContextProvider.PlanewaveCutoffsContextProvider,
-  PointsGridFormDataProvider: _PointsGridFormDataProvider.PointsGridFormDataProvider,
-  PointsPathFormDataProvider: _PointsPathFormDataProvider.PointsPathFormDataProvider,
-  ExplicitPointsPathFormDataProvider: _PointsPathFormDataProvider.ExplicitPointsPathFormDataProvider,
-  ExplicitPointsPath2PIBAFormDataProvider: _PointsPathFormDataProvider.ExplicitPointsPath2PIBAFormDataProvider,
-  HubbardJContextProvider: _HubbardJContextProvider.HubbardJContextProvider,
-  HubbardUContextProvider: _HubbardUContextProvider.HubbardUContextProvider,
-  HubbardVContextProvider: _HubbardVContextProvider.HubbardVContextProvider,
-  HubbardContextProviderLegacy: _HubbardContextProviderLegacy.HubbardContextProviderLegacy,
-  IonDynamicsContextProvider: _IonDynamicsContextProvider.IonDynamicsContextProvider,
-  CollinearMagnetizationContextProvider: _CollinearMagnetizationContextProvider.CollinearMagnetizationContextProvider,
-  NonCollinearMagnetizationContextProvider: _NonCollinearMagnetizationContextProvider.NonCollinearMagnetizationContextProvider,
-  VASPContextProvider: _VASPContextProvider.default,
-  VASPNEBContextProvider: _VASPNEBContextProvider.default,
-  QEPWXContextProvider: _QEPWXContextProvider.default,
-  QENEBContextProvider: _QENEBContextProvider.default,
-  NWChemTotalEnergyContextProvider: _NWChemTotalEnergyContextProvider.default
-};

package/dist/js/context/mixins/JobContextMixin.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.jobContextMixin = jobContextMixin;
-const defaultJob = {
-  workflow: {
-    subworkflows: [],
-    units: []
-  },
-  status: "pre-submission",
-  compute: {
-    queue: "D",
-    nodes: 1,
-    ppn: 1,
-    timeLimit: "3600"
-  },
-  _project: {
-    _id: ""
-  }
-};
-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/dist/js/context/mixins/MethodDataContextMixin.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.methodDataContextMixin = methodDataContextMixin;
-var _cryptoJs = _interopRequireDefault(require("crypto-js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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.default.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/dist/js/context/mixins/WorkflowContextMixin.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.workflowContextMixin = workflowContextMixin;
-const defaultWorkflow = {
-  subworkflows: [],
-  units: [],
-  hasRelaxation: false
-};
-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));
-}