@mat3ra/wode 2026.4.9-0 → 2026.5.29-0

package/dist/js/units/ReduceUnit.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { ReduceUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type ReduceUnitSchemaMixin } from "../generated/ReduceUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+type Schema = ReduceUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<ReduceUnitSchemaMixin>;
+export type ReduceUnitConfig = Partial<Omit<Schema, "type" | "flowchartId">> & Pick<Schema, "flowchartId">;
+declare const ReduceUnit_base: Base;
+declare class ReduceUnit extends ReduceUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: ReduceUnitConfig);
+}
+export default ReduceUnit;

package/dist/js/units/ReduceUnit.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const enums_1 = require("../enums");
+const ReduceUnitSchemaMixin_1 = require("../generated/ReduceUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+class ReduceUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/flowchart");
+    }
+    constructor(config) {
+        const schema = {
+            name: enums_1.UnitType.reduce,
+            mapFlowchartId: "",
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            ...config,
+            type: enums_1.UnitType.reduce,
+        };
+        super(schema);
+    }
+}
+(0, ReduceUnitSchemaMixin_1.reduceUnitSchemaMixin)(ReduceUnit.prototype);
+exports.default = ReduceUnit;

package/dist/js/units/SubworkflowUnit.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { SubworkflowUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type 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">;
+declare const SubworkflowUnit_base: Base;
+declare class SubworkflowUnit extends SubworkflowUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: SubworkflowUnitConfig);
+}
+export default SubworkflowUnit;

package/dist/js/units/SubworkflowUnit.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const enums_1 = require("../enums");
+const SubworkflowUnitSchemaMixin_1 = require("../generated/SubworkflowUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+class SubworkflowUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/subworkflow");
+    }
+    constructor(config) {
+        const schema = {
+            name: "New Subworkflow",
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            ...config,
+            type: enums_1.UnitType.subworkflow,
+        };
+        super(schema);
+    }
+}
+(0, SubworkflowUnitSchemaMixin_1.subworkflowUnitSchemaMixin)(SubworkflowUnit.prototype);
+exports.default = SubworkflowUnit;

package/dist/js/units/factory.d.ts

@@ -0,0 +1,31 @@
+import type { AssertionUnitSchema, AssignmentUnitSchema, ConditionUnitSchema, DataIOUnitSchema, ExecutionUnitSchema, MapUnitSchema, ReduceUnitSchema, SubworkflowUnitSchema, WorkflowUnitSchema } from "@mat3ra/esse/dist/js/types";
+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 declare 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 createInWorkflow(config: WorkflowUnitSchema): AnyWorkflowUnit;
+    static createInSubworkflow(config: ExcutionConfig | AssignmentConfig | ConditionConfig | IOConfig | AssertionConfig): AnySubworkflowUnit;
+}
+export {};

package/dist/js/units/factory.js

@@ -1,53 +1,71 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnitFactory = void 0;
-var _enums = require("../enums");
-var _assertion = require("./assertion");
-var _assignment = require("./assignment");
-var _base = require("./base");
-var _condition = require("./condition");
-var _execution = require("./execution");
-var _io = require("./io");
-var _map = require("./map");
-var _processing = require("./processing");
-var _subworkflow = require("./subworkflow");
-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); }
+const enums_1 = require("../enums");
+const AssertionUnit_1 = __importDefault(require("./AssertionUnit"));
+const AssignmentUnit_1 = __importDefault(require("./AssignmentUnit"));
+const ConditionUnit_1 = __importDefault(require("./ConditionUnit"));
+const ExecutionUnit_1 = __importDefault(require("./ExecutionUnit"));
+const IOUnit_1 = __importDefault(require("./IOUnit"));
+const MapUnit_1 = __importDefault(require("./MapUnit"));
+const ReduceUnit_1 = __importDefault(require("./ReduceUnit"));
+const SubworkflowUnit_1 = __importDefault(require("./SubworkflowUnit"));
 class UnitFactory {
-  static create(config) {
-    switch (config.type) {
-      case _enums.UNIT_TYPES.execution:
-        return new this.ExecutionUnit(config);
-      case _enums.UNIT_TYPES.assignment:
-        return new this.AssignmentUnit(config);
-      case _enums.UNIT_TYPES.condition:
-        return new this.ConditionUnit(config);
-      case _enums.UNIT_TYPES.io:
-        return new this.IOUnit(config);
-      case _enums.UNIT_TYPES.processing:
-        return new this.ProcessingUnit(config);
-      case _enums.UNIT_TYPES.map:
-        return new this.MapUnit(config);
-      case _enums.UNIT_TYPES.subworkflow:
-        return new this.SubworkflowUnit(config);
-      case _enums.UNIT_TYPES.assertion:
-        return new this.AssertionUnit(config);
-      default:
-        return new this.BaseUnit(config);
+    static createDefaultSubworkflowUnit(type, application) {
+        if (type === "execution") {
+            if (application === undefined) {
+                throw new Error("UnitFactory.createDefaultSubworkflowUnit: application is required when type is execution");
+            }
+            return new ExecutionUnit_1.default({
+                type: enums_1.UnitType.execution,
+                application,
+            });
+        }
+        switch (type) {
+            case "assignment":
+                return new AssignmentUnit_1.default({ type: enums_1.UnitType.assignment });
+            case "condition":
+                return new ConditionUnit_1.default({ type: enums_1.UnitType.condition });
+            case "io":
+                return new IOUnit_1.default({ type: enums_1.UnitType.io });
+            case "assertion":
+                return new AssertionUnit_1.default({ type: enums_1.UnitType.assertion });
+            default: {
+                const unreachable = type;
+                throw new Error(`Unexpected unit type: ${String(unreachable)}`);
+            }
+        }
+    }
+    static createInWorkflow(config) {
+        switch (config.type) {
+            case enums_1.UnitType.map:
+                return new MapUnit_1.default(config);
+            case enums_1.UnitType.subworkflow:
+                return new SubworkflowUnit_1.default(config);
+            case enums_1.UnitType.reduce:
+                return new ReduceUnit_1.default(config);
+            default:
+                throw new Error(`Unknown unit type: ${config.type}`);
+        }
+    }
+    static createInSubworkflow(config) {
+        switch (config.type) {
+            case enums_1.UnitType.execution:
+                return new ExecutionUnit_1.default(config);
+            case enums_1.UnitType.assignment:
+                return new AssignmentUnit_1.default(config);
+            case enums_1.UnitType.condition:
+                return new ConditionUnit_1.default(config);
+            case enums_1.UnitType.io:
+                return new IOUnit_1.default(config);
+            case enums_1.UnitType.assertion:
+                return new AssertionUnit_1.default(config);
+            default:
+                throw new Error(`Unknown unit type: ${config.type}`);
+        }
     }
-  }
 }
 exports.UnitFactory = UnitFactory;
-_defineProperty(UnitFactory, "AssertionUnit", _assertion.AssertionUnit);
-_defineProperty(UnitFactory, "AssignmentUnit", _assignment.AssignmentUnit);
-_defineProperty(UnitFactory, "BaseUnit", _base.BaseUnit);
-_defineProperty(UnitFactory, "ConditionUnit", _condition.ConditionUnit);
-_defineProperty(UnitFactory, "ExecutionUnit", _execution.ExecutionUnit);
-_defineProperty(UnitFactory, "IOUnit", _io.IOUnit);
-_defineProperty(UnitFactory, "MapUnit", _map.MapUnit);
-_defineProperty(UnitFactory, "ProcessingUnit", _processing.ProcessingUnit);
-_defineProperty(UnitFactory, "SubworkflowUnit", _subworkflow.SubworkflowUnit);

package/dist/js/units/index.d.ts

@@ -0,0 +1,14 @@
+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/dist/js/units/index.js

@@ -1,82 +1,26 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "AssertionUnit", {
-  enumerable: true,
-  get: function () {
-    return _assertion.AssertionUnit;
-  }
-});
-Object.defineProperty(exports, "AssignmentUnit", {
-  enumerable: true,
-  get: function () {
-    return _assignment.AssignmentUnit;
-  }
-});
-Object.defineProperty(exports, "BaseUnit", {
-  enumerable: true,
-  get: function () {
-    return _base.BaseUnit;
-  }
-});
-Object.defineProperty(exports, "ConditionUnit", {
-  enumerable: true,
-  get: function () {
-    return _condition.ConditionUnit;
-  }
-});
-Object.defineProperty(exports, "ExecutionUnit", {
-  enumerable: true,
-  get: function () {
-    return _execution.ExecutionUnit;
-  }
-});
-Object.defineProperty(exports, "IOUnit", {
-  enumerable: true,
-  get: function () {
-    return _io.IOUnit;
-  }
-});
-Object.defineProperty(exports, "MapUnit", {
-  enumerable: true,
-  get: function () {
-    return _map.MapUnit;
-  }
-});
-Object.defineProperty(exports, "ProcessingUnit", {
-  enumerable: true,
-  get: function () {
-    return _processing.ProcessingUnit;
-  }
-});
-Object.defineProperty(exports, "ReduceUnit", {
-  enumerable: true,
-  get: function () {
-    return _reduce.ReduceUnit;
-  }
-});
-Object.defineProperty(exports, "SubworkflowUnit", {
-  enumerable: true,
-  get: function () {
-    return _subworkflow.SubworkflowUnit;
-  }
-});
-Object.defineProperty(exports, "UnitFactory", {
-  enumerable: true,
-  get: function () {
-    return _factory.UnitFactory;
-  }
-});
-var _assertion = require("./assertion");
-var _assignment = require("./assignment");
-var _base = require("./base");
-var _condition = require("./condition");
-var _execution = require("./execution");
-var _factory = require("./factory");
-var _io = require("./io");
-var _map = require("./map");
-var _processing = require("./processing");
-var _reduce = require("./reduce");
-var _subworkflow = require("./subworkflow");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitFactory = exports.SubworkflowUnit = exports.ReduceUnit = exports.MapUnit = exports.IOUnit = exports.ExecutionUnit = exports.ConditionUnit = exports.AssignmentUnit = exports.AssertionUnit = exports.BaseUnit = void 0;
+const AssertionUnit_1 = __importDefault(require("./AssertionUnit"));
+exports.AssertionUnit = AssertionUnit_1.default;
+const AssignmentUnit_1 = __importDefault(require("./AssignmentUnit"));
+exports.AssignmentUnit = AssignmentUnit_1.default;
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+exports.BaseUnit = BaseUnit_1.default;
+const ConditionUnit_1 = __importDefault(require("./ConditionUnit"));
+exports.ConditionUnit = ConditionUnit_1.default;
+const ExecutionUnit_1 = __importDefault(require("./ExecutionUnit"));
+exports.ExecutionUnit = ExecutionUnit_1.default;
+const factory_1 = require("./factory");
+Object.defineProperty(exports, "UnitFactory", { enumerable: true, get: function () { return factory_1.UnitFactory; } });
+const IOUnit_1 = __importDefault(require("./IOUnit"));
+exports.IOUnit = IOUnit_1.default;
+const MapUnit_1 = __importDefault(require("./MapUnit"));
+exports.MapUnit = MapUnit_1.default;
+const ReduceUnit_1 = __importDefault(require("./ReduceUnit"));
+exports.ReduceUnit = ReduceUnit_1.default;
+const SubworkflowUnit_1 = __importDefault(require("./SubworkflowUnit"));
+exports.SubworkflowUnit = SubworkflowUnit_1.default;

package/dist/js/units/mixins/RuntimeItemsUILogicMixin.d.ts

@@ -0,0 +1,26 @@
+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[];
+};
+interface RuntimeItemsUILogicMixinBase extends InMemoryEntity, RuntimeItems {
+    defaultResults: NameResultSchema[];
+    defaultMonitors: NameResultSchema[];
+    defaultPreProcessors: NameResultSchema[];
+    defaultPostProcessors: NameResultSchema[];
+}
+export declare function runtimeItemsUILogicMixin<T extends RuntimeItemsUILogicMixinBase>(item: T): void;
+export {};

package/dist/js/units/mixins/RuntimeItemsUILogicMixin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeItemsUILogicMixin = runtimeItemsUILogicMixin;
+// @ts-expect-error
+const propertiesMixin = {
+    _initRuntimeItems(config) {
+        this.results = (config === null || config === void 0 ? void 0 : config.results) || this.defaultResults;
+        this.monitors = (config === null || config === void 0 ? void 0 : config.monitors) || this.defaultMonitors;
+        this.preProcessors = (config === null || config === void 0 ? void 0 : config.preProcessors) || this.defaultPreProcessors;
+        this.postProcessors = (config === null || config === void 0 ? void 0 : config.postProcessors) || this.defaultPostProcessors;
+    },
+    toggleRuntimeItem(key, data, isAdding) {
+        if (isAdding) {
+            this[key] = [...this[key], data];
+        }
+        else {
+            this[key] = this[key].filter((x) => x.name !== data.name);
+        }
+    },
+    toggleResult(data, isAdding) {
+        this.toggleRuntimeItem("results", data, isAdding);
+    },
+    toggleMonitor(data, isAdding) {
+        this.toggleRuntimeItem("monitors", data, isAdding);
+    },
+    togglePreProcessor(data, isAdding) {
+        this.toggleRuntimeItem("preProcessors", data, isAdding);
+    },
+    togglePostProcessor(data, isAdding) {
+        this.toggleRuntimeItem("postProcessors", data, isAdding);
+    },
+    get resultNames() {
+        return this.results.map((r) => r.name);
+    },
+    get monitorNames() {
+        return this.monitors.map((r) => r === null || r === void 0 ? void 0 : r.name);
+    },
+    get postProcessorNames() {
+        return this.postProcessors.map((r) => r.name);
+    },
+    get preProcessorNames() {
+        return this.preProcessors.map((r) => r.name);
+    },
+    getResultByName(name) {
+        return this.results.find((r) => r.name === name);
+    },
+};
+function runtimeItemsUILogicMixin(item) {
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(propertiesMixin));
+}

package/dist/js/utils/baseUnits.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowBaseUnitSchema } from "@mat3ra/esse/dist/js/types";
+export declare function resetStatus<T extends WorkflowBaseUnitSchema>(unit: T): never;

package/dist/js/utils/baseUnits.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetStatus = resetStatus;
+const enums_1 = require("../enums");
+function resetStatus(unit) {
+    return {
+        ...unit,
+        status: enums_1.UnitStatus.idle,
+        statusTrack: [],
+    };
+}

package/dist/js/utils/index.d.ts

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

package/dist/js/utils/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseUnits = exports.workflow = exports.units = void 0;
+exports.units = __importStar(require("./units"));
+exports.workflow = __importStar(require("./workflow"));
+exports.baseUnits = __importStar(require("./baseUnits"));

package/dist/js/utils/subworkflow.d.ts

@@ -0,0 +1,2 @@
+import type { SubworkflowSchema } from "@mat3ra/esse/dist/js/types";
+export declare function calculateHash(config: SubworkflowSchema): string;

package/dist/js/utils/subworkflow.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHash = calculateHash;
+const mode_1 = require("@mat3ra/mode");
+const utils_1 = require("@mat3ra/utils");
+const units_1 = require("./units");
+function calculateModelHash(config) {
+    const modelInstance = mode_1.ModelFactory.create({
+        ...config.model,
+        application: config.application,
+    });
+    const { model } = config;
+    if (modelInstance.Method.omitInHashCalculation) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { data: _data, ...method } = model.method;
+        return utils_1.Utils.hash.calculateHashFromObject({
+            ...model,
+            method,
+        });
+    }
+    return utils_1.Utils.hash.calculateHashFromObject(model);
+}
+function calculateHash(config) {
+    return utils_1.Utils.hash.calculateHashFromObject({
+        application: config.application,
+        model: calculateModelHash(config),
+        units: config.units.map(units_1.calculateHash).join(),
+    });
+}

package/dist/js/utils/underscoreStringSlugify.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Same behavior as `underscore.string` slugify (v3.3.x): cleanDiacritics, replace
+ * non-word chars except whitespace and hyphen, lowercase, dasherize, trim hyphens.
+ * @see https://github.com/esamattis/underscore.string/blob/master/slugify.js
+ */
+export declare function underscoreStringSlugify(value: unknown): string;

package/dist/js/utils/underscoreStringSlugify.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Same behavior as `underscore.string` slugify (v3.3.x): cleanDiacritics, replace
+ * non-word chars except whitespace and hyphen, lowercase, dasherize, trim hyphens.
+ * @see https://github.com/esamattis/underscore.string/blob/master/slugify.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.underscoreStringSlugify = underscoreStringSlugify;
+function cleanDiacritics(str) {
+    let from = "ąàáäâãåæăćčĉęèéëêĝĥìíïîĵłľńňòóöőôõðøśșşšŝťțţŭùúüűûñÿýçżźž";
+    let to = "aaaaaaaaaccceeeeeghiiiijllnnoooooooossssstttuuuuuunyyczzz";
+    from += from.toUpperCase();
+    to += to.toUpperCase();
+    const toChars = to.split("");
+    from += "ß";
+    toChars.push("ss");
+    return str.replace(/./g, (ch) => {
+        const i = from.indexOf(ch);
+        return i === -1 ? ch : toChars[i];
+    });
+}
+function dasherize(str) {
+    return str
+        .trim()
+        .replace(/([A-Z])/g, "-$1")
+        .replace(/[-_\s]+/g, "-")
+        .toLowerCase();
+}
+function underscoreStringSlugify(value) {
+    const str = value == null ? "" : String(value);
+    return dasherize(cleanDiacritics(str).replace(/[^\w\s-]/g, "-").toLowerCase()).replace(/^-+|-+$/g, "");
+}

package/dist/js/utils/units.d.ts

@@ -0,0 +1,4 @@
+import type { SubworkflowSchema, WorkflowUnitSchema } from "@mat3ra/esse/dist/js/types";
+type SubworkflowUnitSchema = SubworkflowSchema["units"][number];
+export declare function calculateHash(unit: WorkflowUnitSchema | SubworkflowUnitSchema): string;
+export {};

package/dist/js/utils/units.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHash = calculateHash;
+const enums_1 = require("../enums");
+const factory_1 = require("../units/factory");
+function isWorkflowLevelUnit(unit) {
+    return (unit.type === enums_1.UnitType.map ||
+        unit.type === enums_1.UnitType.reduce ||
+        unit.type === enums_1.UnitType.subworkflow);
+}
+function calculateHash(unit) {
+    if (isWorkflowLevelUnit(unit)) {
+        return factory_1.UnitFactory.createInWorkflow(unit).calculateHash();
+    }
+    return factory_1.UnitFactory.createInSubworkflow(unit).calculateHash();
+}

package/dist/js/utils/workflow.d.ts

@@ -0,0 +1,9 @@
+import type { ApplicationSchema, WorkflowSchema } from "@mat3ra/esse/dist/js/types";
+export declare function getUsedApplications(workflow: WorkflowSchema): ApplicationSchema[];
+export declare function getSystemName(workflow: WorkflowSchema): string;
+export declare function getUsedModels(workflow: WorkflowSchema): ("dft" | "ml" | "unknown")[];
+export declare function getDefaultDescription(workflow: WorkflowSchema): string;
+export declare function getProperties(workflow: WorkflowSchema): string[];
+export declare function getHumanReadableProperties(workflow: WorkflowSchema): string[];
+export declare function getHumanReadableUsedModels(workflow: WorkflowSchema): string[];
+export declare function resetUnitsStatuses(workflow: WorkflowSchema): WorkflowSchema;