@mat3ra/wode 2026.4.9-0 → 2026.5.29-0

package/src/js/units/processing.js

@@ -1,39 +0,0 @@
-import { UNIT_TYPES } from "../enums";
-import { BaseUnit } from "./base";
-
-export class ProcessingUnit extends BaseUnit {
-    constructor(config) {
-        super({ ...ProcessingUnit.getProcessingConfig(), ...config });
-    }
-
-    static getProcessingConfig() {
-        return {
-            name: UNIT_TYPES.processing,
-            type: 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");
-    }
-}

package/src/js/units/reduce.js

@@ -1,17 +0,0 @@
-import { UNIT_TYPES } from "../enums";
-import { BaseUnit } from "./base";
-
-export class ReduceUnit extends BaseUnit {
-    constructor(unitName, mapUnit, input) {
-        super({ ...ReduceUnit.getReduceConfig(unitName, mapUnit, input) });
-    }
-
-    static getReduceConfig(unitName, mapUnit, input) {
-        return {
-            type: UNIT_TYPES.reduce,
-            name: unitName,
-            mapFlowchartId: mapUnit,
-            input,
-        };
-    }
-}

package/src/js/units/subworkflow.js

@@ -1,15 +0,0 @@
-import { UNIT_TYPES } from "../enums";
-import { BaseUnit } from "./base";
-
-export class SubworkflowUnit extends BaseUnit {
-    constructor(config) {
-        super({ ...SubworkflowUnit.getSubworkflowConfig(), ...config });
-    }
-
-    static getSubworkflowConfig() {
-        return {
-            name: "New Subworkflow",
-            type: UNIT_TYPES.subworkflow,
-        };
-    }
-}

package/src/js/utils.js

@@ -1,73 +0,0 @@
-import lodash from "lodash";
-
-/**
- * @summary set the head of an array of units
- * @param units
- * @returns {Unit[]}
- */
-export function setUnitsHead(units) {
-    if (units.length > 0) {
-        units[0].head = true;
-        lodash.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[]}
- */
-export 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
- */
-export 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!)
- */
-export 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/src/js/workflows/create.js

@@ -1,227 +0,0 @@
-import { createSubworkflow } from "../subworkflows/create";
-import { UnitFactory } from "../units";
-import { defaultMapConfig } from "../units/map";
-import { applyConfig, findUnit } from "../utils";
-import { Workflow } from "./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 = UnitFactory }) {
-    let { input: defaultInput } = defaultMapConfig;
-    if (config.input) {
-        defaultInput = { ...defaultInput, ...config.input };
-    }
-    const unit = unitFactoryCls.create({ ...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 = findUnit({ subworkflowData, index, type });
-        console.log(`  patching ${type} unit ${index} of subworkflow ${subworkflowData.name}`);
-        unit.config = 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, cache, ...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 createSubworkflow({
-        subworkflowData,
-        cache,
-        ...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 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,
-    cache = [],
-    ...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,
-                    cache,
-                    ...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,
-    ...swArgs
-}) {
-    const cache = [];
-    const { name } = workflowData;
-    console.log(`wode: creating ${appName} workflow ${name}`);
-    const wf = createWorkflowUnits({
-        appName,
-        workflowData,
-        workflowSubworkflowMapByApplication,
-        workflowCls,
-        cache,
-        ...swArgs,
-    });
-    wf.setName(name);
-    wf.applicationName = appName;
-    return wf;
-}
-
-export { createWorkflow };

package/src/js/workflows/index.js

@@ -1,98 +0,0 @@
-import { allApplications } from "@mat3ra/ade";
-import JSONSchemasInterface from "@mat3ra/esse/dist/js/esse/JSONSchemasInterface";
-import schemas from "@mat3ra/esse/dist/js/schemas.json";
-
-// Import Template here to apply context provider patch
-// eslint-disable-next-line no-unused-vars
-import { Template } from "../patch";
-import { createWorkflow } from "./create";
-import { Workflow } from "./workflow";
-
-// Running this to set schemas for validation, removing the redundant data from application-flavors tree: `flavors`
-JSONSchemasInterface.setSchemas(schemas);
-
-/*
-    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,
-    workflowSubworkflowMapByApplication,
-    ...swArgs
-}) {
-    let apps = appName !== null ? [appName] : allApplications;
-    const allApplicationsFromWorkflowData = Object.keys(
-        workflowSubworkflowMapByApplication.workflows,
-    );
-    // output warning if allApplications and allApplicationsFromWorkflowData do not match
-    if (appName === null) {
-        if (apps && 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(
-                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,
-    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;
-}
-
-export { Workflow, createWorkflows, createWorkflowConfigs, createWorkflow };

package/src/js/workflows/relaxation.js

@@ -1,42 +0,0 @@
-import { SubworkflowStandata } from "@mat3ra/standata";
-
-export const RelaxationLogicMixin = (superclass) =>
-    class extends superclass {
-        get relaxationSubworkflow() {
-            const appName = this.subworkflows[0]?.application?.name;
-            if (!appName) return undefined;
-            const subworkflowStandata = new SubworkflowStandata();
-            const relaxationSubworkflow =
-                subworkflowStandata.getRelaxationSubworkflowByApplication(appName);
-            if (!relaxationSubworkflow) return undefined;
-            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);
-                }
-            }
-        }
-    };