@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/dist/js/convergence/ConvergenceParameter.d.ts

@@ -0,0 +1,26 @@
+interface ConvergenceParameterProps {
+    initialValue: number | [number, number, number];
+}
+export type ConvergenceParameterConfig = ConvergenceParameterProps & {
+    increment?: string | number;
+};
+export type UnitContext = {
+    data: {
+        dimensions: [string, string, string];
+        shifts: [0, 0, 0];
+    };
+    isUsingJinjaVariables: true;
+};
+export default abstract class ConvergenceParameter {
+    abstract readonly name: "N_k" | "N_k_nonuniform";
+    abstract readonly finalValue: string;
+    abstract readonly increment: string;
+    abstract readonly unitContext: UnitContext;
+    readonly initialValue: string;
+    constructor({ initialValue }: ConvergenceParameterProps);
+    useVariablesFromUnitContext(_flowchartId: string): {
+        scope: string;
+        name: string;
+    }[];
+}
+export {};

package/dist/js/convergence/ConvergenceParameter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ConvergenceParameter {
+    constructor({ initialValue }) {
+        this.initialValue =
+            typeof initialValue === "string" ? initialValue : JSON.stringify(initialValue);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+    useVariablesFromUnitContext(_flowchartId) {
+        return [];
+    }
+}
+exports.default = ConvergenceParameter;

package/dist/js/convergence/NonUniformKGridConvergence.d.ts

@@ -0,0 +1,12 @@
+import ConvergenceParameter, { type ConvergenceParameterConfig, type UnitContext } from "./ConvergenceParameter";
+export default class NonUniformKGridConvergence extends ConvergenceParameter {
+    readonly increment: string;
+    readonly name: "N_k_nonuniform";
+    readonly finalValue: "N_k_nonuniform";
+    readonly unitContext: UnitContext;
+    constructor({ initialValue, increment }: ConvergenceParameterConfig);
+    useVariablesFromUnitContext(flowchartId: string): {
+        scope: string;
+        name: string;
+    }[];
+}

package/dist/js/convergence/NonUniformKGridConvergence.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConvergenceParameter_1 = __importDefault(require("./ConvergenceParameter"));
+class NonUniformKGridConvergence extends ConvergenceParameter_1.default {
+    constructor({ initialValue, increment }) {
+        super({ initialValue });
+        this.name = "N_k_nonuniform";
+        this.finalValue = "N_k_nonuniform";
+        this.unitContext = {
+            data: {
+                dimensions: [`{{${this.name}[0]}}`, `{{${this.name}[1]}}`, `{{${this.name}[2]}}`],
+                shifts: [0, 0, 0],
+            },
+            isUsingJinjaVariables: true,
+        };
+        this.increment = `[${this.initialValue}[i] + math.floor(iteration * ${increment || ""} * float(context['kgrid']['reciprocalVectorRatios'][i])) for i in range(3)]`;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    useVariablesFromUnitContext(flowchartId) {
+        return [
+            {
+                scope: flowchartId,
+                name: "context",
+            },
+        ];
+    }
+}
+exports.default = NonUniformKGridConvergence;

package/dist/js/convergence/UniformKGridConvergence.d.ts

@@ -0,0 +1,8 @@
+import ConvergenceParameter, { type ConvergenceParameterConfig, type UnitContext } from "./ConvergenceParameter";
+export default class UniformKGridConvergence extends ConvergenceParameter {
+    readonly increment: string;
+    readonly name: "N_k";
+    readonly finalValue: "N_k + 0";
+    readonly unitContext: UnitContext;
+    constructor({ initialValue, increment }: ConvergenceParameterConfig);
+}

package/dist/js/convergence/UniformKGridConvergence.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConvergenceParameter_1 = __importDefault(require("./ConvergenceParameter"));
+class UniformKGridConvergence extends ConvergenceParameter_1.default {
+    constructor({ initialValue, increment }) {
+        super({ initialValue });
+        this.name = "N_k";
+        this.finalValue = `${this.name} + 0`;
+        this.unitContext = {
+            data: {
+                dimensions: [`{{${this.name}}}`, `{{${this.name}}}`, `{{${this.name}}}`],
+                shifts: [0, 0, 0],
+            },
+            isUsingJinjaVariables: true,
+        };
+        this.increment = `${this.name} + ${increment || ""}`;
+    }
+}
+exports.default = UniformKGridConvergence;

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

@@ -0,0 +1,8 @@
+import { type ConvergenceParameterConfig } from "./ConvergenceParameter";
+import NonUniformKGridConvergence from "./NonUniformKGridConvergence";
+import UniformKGridConvergence from "./UniformKGridConvergence";
+type FactoryParams = ConvergenceParameterConfig & {
+    name: "N_k" | "N_k_nonuniform";
+};
+export declare function createConvergenceParameter({ name, ...params }: FactoryParams): NonUniformKGridConvergence | UniformKGridConvergence;
+export {};

package/dist/js/convergence/factory.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConvergenceParameter = createConvergenceParameter;
+const NonUniformKGridConvergence_1 = __importDefault(require("./NonUniformKGridConvergence"));
+const UniformKGridConvergence_1 = __importDefault(require("./UniformKGridConvergence"));
+function createConvergenceParameter({ name, ...params }) {
+    switch (name) {
+        case "N_k":
+            return new UniformKGridConvergence_1.default(params);
+        case "N_k_nonuniform":
+            return new NonUniformKGridConvergence_1.default(params);
+        default:
+            throw new Error(`Invalid convergence parameter name: ${name}`);
+    }
+}

package/dist/js/enums.d.ts

@@ -0,0 +1,62 @@
+export declare const UNIT_TYPES: {
+    readonly convergence: "convergence";
+    readonly exit: "exit";
+    readonly execution: "execution";
+    readonly map: "map";
+    readonly reduce: "reduce";
+    readonly assignment: "assignment";
+    readonly condition: "condition";
+    readonly subworkflow: "subworkflow";
+    readonly io: "io";
+    readonly assertion: "assertion";
+};
+export declare enum UnitType {
+    convergence = "convergence",
+    exit = "exit",
+    execution = "execution",
+    map = "map",
+    reduce = "reduce",
+    assignment = "assignment",
+    condition = "condition",
+    subworkflow = "subworkflow",
+    io = "io",
+    assertion = "assertion"
+}
+export declare enum UnitTag {
+    hasConvergenceParam = "hasConvergenceParam",
+    hasConvergenceResult = "hasConvergenceResult"
+}
+export declare enum UnitStatus {
+    idle = "idle",
+    active = "active",
+    finished = "finished",
+    error = "error",
+    warning = "warning"
+}
+export declare const WORKFLOW_STATUSES: {
+    readonly "up-to-date": "up-to-date";
+    readonly outdated: "outdated";
+};
+export declare const TAB_NAVIGATION_CONFIG: {
+    readonly overview: {
+        readonly itemName: "Overview";
+        readonly className: "";
+        readonly href: "sw-overview";
+    };
+    readonly importantSettings: {
+        readonly itemName: "Important settings";
+        readonly className: "";
+        readonly href: "sw-important-settings";
+    };
+    readonly detailedView: {
+        readonly itemName: "Detailed view";
+        readonly className: "";
+        readonly href: "sw-detailed-view";
+    };
+    readonly compute: {
+        readonly itemName: "Compute";
+        readonly className: "";
+        readonly href: "sw-compute";
+    };
+};
+export declare const UNIT_NAME_INVALID_CHARS = "/";

package/dist/js/enums.js

@@ -1,65 +1,70 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WORKFLOW_STATUSES = exports.UNIT_TYPES = exports.UNIT_TAGS = exports.UNIT_STATUSES = exports.UNIT_NAME_INVALID_CHARS = exports.TAB_NAVIGATION_CONFIG = exports.IO_ID_COLUMN = void 0;
-/**
- * THIS ENUMS ARE SHARED WITH TESTS.
- * DO NOT IMPORT ANYTHINGS IN THIS MODULE.
- */
-
-const IO_ID_COLUMN = exports.IO_ID_COLUMN = "exabyteId";
-const UNIT_TYPES = exports.UNIT_TYPES = {
-  // not currently used
-  convergence: "convergence",
-  exit: "exit",
-  // actively used
-  execution: "execution",
-  map: "map",
-  reduce: "reduce",
-  assignment: "assignment",
-  condition: "condition",
-  subworkflow: "subworkflow",
-  processing: "processing",
-  io: "io",
-  assertion: "assertion"
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIT_NAME_INVALID_CHARS = exports.TAB_NAVIGATION_CONFIG = exports.WORKFLOW_STATUSES = exports.UnitStatus = exports.UnitTag = exports.UnitType = exports.UNIT_TYPES = void 0;
+exports.UNIT_TYPES = {
+    // not currently used
+    convergence: "convergence",
+    exit: "exit",
+    // actively used
+    execution: "execution",
+    map: "map",
+    reduce: "reduce",
+    assignment: "assignment",
+    condition: "condition",
+    subworkflow: "subworkflow",
+    io: "io",
+    assertion: "assertion",
 };
-const UNIT_STATUSES = exports.UNIT_STATUSES = {
-  idle: "idle",
-  active: "active",
-  finished: "finished",
-  error: "error",
-  warning: "warning"
+var UnitType;
+(function (UnitType) {
+    UnitType["convergence"] = "convergence";
+    UnitType["exit"] = "exit";
+    UnitType["execution"] = "execution";
+    UnitType["map"] = "map";
+    UnitType["reduce"] = "reduce";
+    UnitType["assignment"] = "assignment";
+    UnitType["condition"] = "condition";
+    UnitType["subworkflow"] = "subworkflow";
+    UnitType["io"] = "io";
+    UnitType["assertion"] = "assertion";
+})(UnitType || (exports.UnitType = UnitType = {}));
+var UnitTag;
+(function (UnitTag) {
+    UnitTag["hasConvergenceParam"] = "hasConvergenceParam";
+    UnitTag["hasConvergenceResult"] = "hasConvergenceResult";
+})(UnitTag || (exports.UnitTag = UnitTag = {}));
+var UnitStatus;
+(function (UnitStatus) {
+    UnitStatus["idle"] = "idle";
+    UnitStatus["active"] = "active";
+    UnitStatus["finished"] = "finished";
+    UnitStatus["error"] = "error";
+    UnitStatus["warning"] = "warning";
+})(UnitStatus || (exports.UnitStatus = UnitStatus = {}));
+exports.WORKFLOW_STATUSES = {
+    "up-to-date": "up-to-date",
+    outdated: "outdated",
 };
-const UNIT_TAGS = exports.UNIT_TAGS = {
-  hasConvergenceParam: "hasConvergenceParam",
-  hasConvergenceResult: "hasConvergenceResult"
+exports.TAB_NAVIGATION_CONFIG = {
+    overview: {
+        itemName: "Overview",
+        className: "",
+        href: "sw-overview",
+    },
+    importantSettings: {
+        itemName: "Important settings",
+        className: "",
+        href: "sw-important-settings",
+    },
+    detailedView: {
+        itemName: "Detailed view",
+        className: "",
+        href: "sw-detailed-view",
+    },
+    compute: {
+        itemName: "Compute",
+        className: "",
+        href: "sw-compute",
+    },
 };
-const WORKFLOW_STATUSES = exports.WORKFLOW_STATUSES = {
-  "up-to-date": "up-to-date",
-  outdated: "outdated"
-};
-const TAB_NAVIGATION_CONFIG = exports.TAB_NAVIGATION_CONFIG = {
-  overview: {
-    itemName: "Overview",
-    className: "",
-    href: "sw-overview"
-  },
-  importantSettings: {
-    itemName: "Important settings",
-    className: "",
-    href: "sw-important-settings"
-  },
-  detailedView: {
-    itemName: "Detailed view",
-    className: "",
-    href: "sw-detailed-view"
-  },
-  compute: {
-    itemName: "Compute",
-    className: "",
-    href: "sw-compute"
-  }
-};
-const UNIT_NAME_INVALID_CHARS = exports.UNIT_NAME_INVALID_CHARS = "/";
+exports.UNIT_NAME_INVALID_CHARS = "/";

package/dist/js/generated/AssertionUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AssertionUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type AssertionUnitSchemaMixin = AssertionUnitMixinSchema;
+export type AssertionUnitInMemoryEntity = InMemoryEntity & AssertionUnitSchemaMixin;
+export declare function assertionUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & AssertionUnitSchemaMixin;

package/dist/js/generated/AssertionUnitSchemaMixin.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertionUnitSchemaMixin = assertionUnitSchemaMixin;
+function assertionUnitSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.prop("type");
+        },
+        set type(value) {
+            this.setProp("type", value);
+        },
+        get statement() {
+            return this.requiredProp("statement");
+        },
+        set statement(value) {
+            this.setProp("statement", value);
+        },
+        get errorMessage() {
+            return this.prop("errorMessage");
+        },
+        set errorMessage(value) {
+            this.setProp("errorMessage", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/AssignmentUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AssignmentUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type AssignmentUnitSchemaMixin = AssignmentUnitMixinSchema;
+export type AssignmentUnitInMemoryEntity = InMemoryEntity & AssignmentUnitSchemaMixin;
+export declare function assignmentUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & AssignmentUnitSchemaMixin;

package/dist/js/generated/AssignmentUnitSchemaMixin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignmentUnitSchemaMixin = assignmentUnitSchemaMixin;
+function assignmentUnitSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.prop("type");
+        },
+        set type(value) {
+            this.setProp("type", value);
+        },
+        get input() {
+            return this.prop("input");
+        },
+        set input(value) {
+            this.setProp("input", value);
+        },
+        get operand() {
+            return this.requiredProp("operand");
+        },
+        set operand(value) {
+            this.setProp("operand", value);
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+        set value(value) {
+            this.setProp("value", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/BaseUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { WorkflowBaseUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type BaseUnitSchemaMixin = WorkflowBaseUnitMixinSchema;
+export type BaseUnitInMemoryEntity = InMemoryEntity & BaseUnitSchemaMixin;
+export declare function baseUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & BaseUnitSchemaMixin;

package/dist/js/generated/BaseUnitSchemaMixin.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseUnitSchemaMixin = baseUnitSchemaMixin;
+function baseUnitSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get isDraft() {
+            return this.prop("isDraft");
+        },
+        set isDraft(value) {
+            this.setProp("isDraft", value);
+        },
+        get type() {
+            return this.requiredProp("type");
+        },
+        set type(value) {
+            this.setProp("type", value);
+        },
+        get name() {
+            return this.prop("name");
+        },
+        set name(value) {
+            this.setProp("name", value);
+        },
+        get status() {
+            return this.prop("status");
+        },
+        set status(value) {
+            this.setProp("status", value);
+        },
+        get head() {
+            return this.prop("head");
+        },
+        set head(value) {
+            this.setProp("head", value);
+        },
+        get flowchartId() {
+            return this.requiredProp("flowchartId");
+        },
+        set flowchartId(value) {
+            this.setProp("flowchartId", value);
+        },
+        get next() {
+            return this.prop("next");
+        },
+        set next(value) {
+            this.setProp("next", value);
+        },
+        get enableRender() {
+            return this.prop("enableRender");
+        },
+        set enableRender(value) {
+            this.setProp("enableRender", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ConditionUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ConditionUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type ConditionUnitSchemaMixin = ConditionUnitMixinSchema;
+export type ConditionUnitInMemoryEntity = InMemoryEntity & ConditionUnitSchemaMixin;
+export declare function conditionUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & ConditionUnitSchemaMixin;

package/dist/js/generated/ConditionUnitSchemaMixin.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditionUnitSchemaMixin = conditionUnitSchemaMixin;
+function conditionUnitSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.prop("type");
+        },
+        set type(value) {
+            this.setProp("type", value);
+        },
+        get input() {
+            return this.requiredProp("input");
+        },
+        set input(value) {
+            this.setProp("input", value);
+        },
+        get statement() {
+            return this.requiredProp("statement");
+        },
+        set statement(value) {
+            this.setProp("statement", value);
+        },
+        get then() {
+            return this.requiredProp("then");
+        },
+        set then(value) {
+            this.setProp("then", value);
+        },
+        get else() {
+            return this.requiredProp("else");
+        },
+        set else(value) {
+            this.setProp("else", value);
+        },
+        get maxOccurrences() {
+            return this.requiredProp("maxOccurrences");
+        },
+        set maxOccurrences(value) {
+            this.setProp("maxOccurrences", value);
+        },
+        get throwException() {
+            return this.prop("throwException");
+        },
+        set throwException(value) {
+            this.setProp("throwException", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ExecutionUnitInputSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ExecutionUnitInputItemSchema } from "@mat3ra/esse/dist/js/types";
+export type ExecutionUnitInputSchemaMixin = ExecutionUnitInputItemSchema;
+export type ExecutionUnitInputInMemoryEntity = InMemoryEntity & ExecutionUnitInputSchemaMixin;
+export declare function executionUnitInputSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & ExecutionUnitInputSchemaMixin;

package/dist/js/generated/ExecutionUnitInputSchemaMixin.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executionUnitInputSchemaMixin = executionUnitInputSchemaMixin;
+function executionUnitInputSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get template() {
+            return this.requiredProp("template");
+        },
+        set template(value) {
+            this.setProp("template", value);
+        },
+        get rendered() {
+            return this.prop("rendered");
+        },
+        set rendered(value) {
+            this.setProp("rendered", value);
+        },
+        get isManuallyChanged() {
+            return this.requiredProp("isManuallyChanged");
+        },
+        set isManuallyChanged(value) {
+            this.setProp("isManuallyChanged", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ExecutionUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ExecutionUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type ExecutionUnitSchemaMixin = ExecutionUnitMixinSchema;
+export type ExecutionUnitInMemoryEntity = InMemoryEntity & ExecutionUnitSchemaMixin;
+export declare function executionUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & ExecutionUnitSchemaMixin;

package/dist/js/generated/ExecutionUnitSchemaMixin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executionUnitSchemaMixin = executionUnitSchemaMixin;
+function executionUnitSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.requiredProp("type");
+        },
+        set type(value) {
+            this.setProp("type", value);
+        },
+        get application() {
+            return this.requiredProp("application");
+        },
+        set application(value) {
+            this.setProp("application", value);
+        },
+        get executable() {
+            return this.requiredProp("executable");
+        },
+        set executable(value) {
+            this.setProp("executable", value);
+        },
+        get flavor() {
+            return this.requiredProp("flavor");
+        },
+        set flavor(value) {
+            this.setProp("flavor", value);
+        },
+        get input() {
+            return this.requiredProp("input");
+        },
+        set input(value) {
+            this.setProp("input", value);
+        },
+        get context() {
+            return this.requiredProp("context");
+        },
+        set context(value) {
+            this.setProp("context", value);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/IOUnitSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { DataIOUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+export type IOUnitSchemaMixin = DataIOUnitMixinSchema;
+export type IOUnitInMemoryEntity = InMemoryEntity & IOUnitSchemaMixin;
+export declare function iOUnitSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & IOUnitSchemaMixin;