@mat3ra/wode 2026.4.9-0 → 2026.5.29-0

package/src/js/generated/BaseUnitSchemaMixin.ts

@@ -0,0 +1,64 @@
+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 function baseUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & BaseUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & BaseUnitSchemaMixin = {
+        get isDraft() {
+            return this.prop<WorkflowBaseUnitMixinSchema["isDraft"]>("isDraft");
+        },
+        set isDraft(value: WorkflowBaseUnitMixinSchema["isDraft"]) {
+            this.setProp("isDraft", value);
+        },
+        get type() {
+            return this.requiredProp<WorkflowBaseUnitMixinSchema["type"]>("type");
+        },
+        set type(value: WorkflowBaseUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get name() {
+            return this.prop<WorkflowBaseUnitMixinSchema["name"]>("name");
+        },
+        set name(value: WorkflowBaseUnitMixinSchema["name"]) {
+            this.setProp("name", value);
+        },
+        get status() {
+            return this.prop<WorkflowBaseUnitMixinSchema["status"]>("status");
+        },
+        set status(value: WorkflowBaseUnitMixinSchema["status"]) {
+            this.setProp("status", value);
+        },
+        get head() {
+            return this.prop<WorkflowBaseUnitMixinSchema["head"]>("head");
+        },
+        set head(value: WorkflowBaseUnitMixinSchema["head"]) {
+            this.setProp("head", value);
+        },
+        get flowchartId() {
+            return this.requiredProp<WorkflowBaseUnitMixinSchema["flowchartId"]>("flowchartId");
+        },
+        set flowchartId(value: WorkflowBaseUnitMixinSchema["flowchartId"]) {
+            this.setProp("flowchartId", value);
+        },
+        get next() {
+            return this.prop<WorkflowBaseUnitMixinSchema["next"]>("next");
+        },
+        set next(value: WorkflowBaseUnitMixinSchema["next"]) {
+            this.setProp("next", value);
+        },
+        get enableRender() {
+            return this.prop<WorkflowBaseUnitMixinSchema["enableRender"]>("enableRender");
+        },
+        set enableRender(value: WorkflowBaseUnitMixinSchema["enableRender"]) {
+            this.setProp("enableRender", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ConditionUnitSchemaMixin.ts

@@ -0,0 +1,58 @@
+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 function conditionUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ConditionUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ConditionUnitSchemaMixin = {
+        get type() {
+            return this.prop<ConditionUnitMixinSchema["type"]>("type");
+        },
+        set type(value: ConditionUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get input() {
+            return this.requiredProp<ConditionUnitMixinSchema["input"]>("input");
+        },
+        set input(value: ConditionUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+        get statement() {
+            return this.requiredProp<ConditionUnitMixinSchema["statement"]>("statement");
+        },
+        set statement(value: ConditionUnitMixinSchema["statement"]) {
+            this.setProp("statement", value);
+        },
+        get then() {
+            return this.requiredProp<ConditionUnitMixinSchema["then"]>("then");
+        },
+        set then(value: ConditionUnitMixinSchema["then"]) {
+            this.setProp("then", value);
+        },
+        get else() {
+            return this.requiredProp<ConditionUnitMixinSchema["else"]>("else");
+        },
+        set else(value: ConditionUnitMixinSchema["else"]) {
+            this.setProp("else", value);
+        },
+        get maxOccurrences() {
+            return this.requiredProp<ConditionUnitMixinSchema["maxOccurrences"]>("maxOccurrences");
+        },
+        set maxOccurrences(value: ConditionUnitMixinSchema["maxOccurrences"]) {
+            this.setProp("maxOccurrences", value);
+        },
+        get throwException() {
+            return this.prop<ConditionUnitMixinSchema["throwException"]>("throwException");
+        },
+        set throwException(value: ConditionUnitMixinSchema["throwException"]) {
+            this.setProp("throwException", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ExecutionUnitInputSchemaMixin.ts

@@ -0,0 +1,36 @@
+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 function executionUnitInputSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ExecutionUnitInputSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ExecutionUnitInputSchemaMixin = {
+        get template() {
+            return this.requiredProp<ExecutionUnitInputItemSchema["template"]>("template");
+        },
+        set template(value: ExecutionUnitInputItemSchema["template"]) {
+            this.setProp("template", value);
+        },
+        get rendered() {
+            return this.prop<ExecutionUnitInputItemSchema["rendered"]>("rendered");
+        },
+        set rendered(value: ExecutionUnitInputItemSchema["rendered"]) {
+            this.setProp("rendered", value);
+        },
+        get isManuallyChanged() {
+            return this.requiredProp<ExecutionUnitInputItemSchema["isManuallyChanged"]>(
+                "isManuallyChanged",
+            );
+        },
+        set isManuallyChanged(value: ExecutionUnitInputItemSchema["isManuallyChanged"]) {
+            this.setProp("isManuallyChanged", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ExecutionUnitSchemaMixin.ts

@@ -0,0 +1,52 @@
+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 function executionUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ExecutionUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ExecutionUnitSchemaMixin = {
+        get type() {
+            return this.requiredProp<ExecutionUnitMixinSchema["type"]>("type");
+        },
+        set type(value: ExecutionUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get application() {
+            return this.requiredProp<ExecutionUnitMixinSchema["application"]>("application");
+        },
+        set application(value: ExecutionUnitMixinSchema["application"]) {
+            this.setProp("application", value);
+        },
+        get executable() {
+            return this.requiredProp<ExecutionUnitMixinSchema["executable"]>("executable");
+        },
+        set executable(value: ExecutionUnitMixinSchema["executable"]) {
+            this.setProp("executable", value);
+        },
+        get flavor() {
+            return this.requiredProp<ExecutionUnitMixinSchema["flavor"]>("flavor");
+        },
+        set flavor(value: ExecutionUnitMixinSchema["flavor"]) {
+            this.setProp("flavor", value);
+        },
+        get input() {
+            return this.requiredProp<ExecutionUnitMixinSchema["input"]>("input");
+        },
+        set input(value: ExecutionUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+        get context() {
+            return this.requiredProp<ExecutionUnitMixinSchema["context"]>("context");
+        },
+        set context(value: ExecutionUnitMixinSchema["context"]) {
+            this.setProp("context", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/IOUnitSchemaMixin.ts

@@ -0,0 +1,40 @@
+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 function iOUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & IOUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & IOUnitSchemaMixin = {
+        get type() {
+            return this.prop<DataIOUnitMixinSchema["type"]>("type");
+        },
+        set type(value: DataIOUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get subtype() {
+            return this.requiredProp<DataIOUnitMixinSchema["subtype"]>("subtype");
+        },
+        set subtype(value: DataIOUnitMixinSchema["subtype"]) {
+            this.setProp("subtype", value);
+        },
+        get source() {
+            return this.requiredProp<DataIOUnitMixinSchema["source"]>("source");
+        },
+        set source(value: DataIOUnitMixinSchema["source"]) {
+            this.setProp("source", value);
+        },
+        get input() {
+            return this.requiredProp<DataIOUnitMixinSchema["input"]>("input");
+        },
+        set input(value: DataIOUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/MapUnitSchemaMixin.ts

@@ -0,0 +1,34 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { MapUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type MapUnitSchemaMixin = MapUnitMixinSchema;
+
+export type MapUnitInMemoryEntity = InMemoryEntity & MapUnitSchemaMixin;
+
+export function mapUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & MapUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & MapUnitSchemaMixin = {
+        get type() {
+            return this.prop<MapUnitMixinSchema["type"]>("type");
+        },
+        set type(value: MapUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get workflowId() {
+            return this.requiredProp<MapUnitMixinSchema["workflowId"]>("workflowId");
+        },
+        set workflowId(value: MapUnitMixinSchema["workflowId"]) {
+            this.setProp("workflowId", value);
+        },
+        get input() {
+            return this.requiredProp<MapUnitMixinSchema["input"]>("input");
+        },
+        set input(value: MapUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ReduceUnitSchemaMixin.ts

@@ -0,0 +1,34 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ReduceUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type ReduceUnitSchemaMixin = ReduceUnitMixinSchema;
+
+export type ReduceUnitInMemoryEntity = InMemoryEntity & ReduceUnitSchemaMixin;
+
+export function reduceUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ReduceUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ReduceUnitSchemaMixin = {
+        get type() {
+            return this.prop<ReduceUnitMixinSchema["type"]>("type");
+        },
+        set type(value: ReduceUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+        get mapFlowchartId() {
+            return this.requiredProp<ReduceUnitMixinSchema["mapFlowchartId"]>("mapFlowchartId");
+        },
+        set mapFlowchartId(value: ReduceUnitMixinSchema["mapFlowchartId"]) {
+            this.setProp("mapFlowchartId", value);
+        },
+        get input() {
+            return this.requiredProp<ReduceUnitMixinSchema["input"]>("input");
+        },
+        set input(value: ReduceUnitMixinSchema["input"]) {
+            this.setProp("input", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/StatusSchemaMixin.ts

@@ -0,0 +1,28 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { StatusSchema } from "@mat3ra/esse/dist/js/types";
+
+export type StatusSchemaMixin = StatusSchema;
+
+export type StatusInMemoryEntity = InMemoryEntity & StatusSchemaMixin;
+
+export function statusSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & StatusSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & StatusSchemaMixin = {
+        get status() {
+            return this.prop<StatusSchema["status"]>("status");
+        },
+        set status(value: StatusSchema["status"]) {
+            this.setProp("status", value);
+        },
+        get statusTrack() {
+            return this.prop<StatusSchema["statusTrack"]>("statusTrack");
+        },
+        set statusTrack(value: StatusSchema["statusTrack"]) {
+            this.setProp("statusTrack", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/SubworkflowSchemaMixin.ts

@@ -0,0 +1,58 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { SubworkflowMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type SubworkflowSchemaMixin = SubworkflowMixinSchema;
+
+export type SubworkflowInMemoryEntity = InMemoryEntity & SubworkflowSchemaMixin;
+
+export function subworkflowSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & SubworkflowSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & SubworkflowSchemaMixin = {
+        get properties() {
+            return this.requiredProp<SubworkflowMixinSchema["properties"]>("properties");
+        },
+        set properties(value: SubworkflowMixinSchema["properties"]) {
+            this.setProp("properties", value);
+        },
+        get compute() {
+            return this.prop<SubworkflowMixinSchema["compute"]>("compute");
+        },
+        set compute(value: SubworkflowMixinSchema["compute"]) {
+            this.setProp("compute", value);
+        },
+        get units() {
+            return this.requiredProp<SubworkflowMixinSchema["units"]>("units");
+        },
+        set units(value: SubworkflowMixinSchema["units"]) {
+            this.setProp("units", value);
+        },
+        get model() {
+            return this.requiredProp<SubworkflowMixinSchema["model"]>("model");
+        },
+        set model(value: SubworkflowMixinSchema["model"]) {
+            this.setProp("model", value);
+        },
+        get application() {
+            return this.requiredProp<SubworkflowMixinSchema["application"]>("application");
+        },
+        set application(value: SubworkflowMixinSchema["application"]) {
+            this.setProp("application", value);
+        },
+        get isMultiMaterial() {
+            return this.prop<SubworkflowMixinSchema["isMultiMaterial"]>("isMultiMaterial");
+        },
+        set isMultiMaterial(value: SubworkflowMixinSchema["isMultiMaterial"]) {
+            this.setProp("isMultiMaterial", value);
+        },
+        get isDraft() {
+            return this.prop<SubworkflowMixinSchema["isDraft"]>("isDraft");
+        },
+        set isDraft(value: SubworkflowMixinSchema["isDraft"]) {
+            this.setProp("isDraft", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/SubworkflowUnitSchemaMixin.ts

@@ -0,0 +1,22 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { SubworkflowUnitMixinSchema } from "@mat3ra/esse/dist/js/types";
+
+export type SubworkflowUnitSchemaMixin = SubworkflowUnitMixinSchema;
+
+export type SubworkflowUnitInMemoryEntity = InMemoryEntity & SubworkflowUnitSchemaMixin;
+
+export function subworkflowUnitSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & SubworkflowUnitSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & SubworkflowUnitSchemaMixin = {
+        get type() {
+            return this.prop<SubworkflowUnitMixinSchema["type"]>("type");
+        },
+        set type(value: SubworkflowUnitMixinSchema["type"]) {
+            this.setProp("type", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/WorkflowSchemaMixin.ts

@@ -0,0 +1,58 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BaseWorkflowSchema } from "@mat3ra/esse/dist/js/types";
+
+export type WorkflowSchemaMixin = BaseWorkflowSchema;
+
+export type WorkflowInMemoryEntity = InMemoryEntity & WorkflowSchemaMixin;
+
+export function workflowSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & WorkflowSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & WorkflowSchemaMixin = {
+        get properties() {
+            return this.requiredProp<BaseWorkflowSchema["properties"]>("properties");
+        },
+        set properties(value: BaseWorkflowSchema["properties"]) {
+            this.setProp("properties", value);
+        },
+        get isUsingDataset() {
+            return this.prop<BaseWorkflowSchema["isUsingDataset"]>("isUsingDataset");
+        },
+        set isUsingDataset(value: BaseWorkflowSchema["isUsingDataset"]) {
+            this.setProp("isUsingDataset", value);
+        },
+        get isMultiMaterial() {
+            return this.prop<BaseWorkflowSchema["isMultiMaterial"]>("isMultiMaterial");
+        },
+        set isMultiMaterial(value: BaseWorkflowSchema["isMultiMaterial"]) {
+            this.setProp("isMultiMaterial", value);
+        },
+        get subworkflows() {
+            return this.requiredProp<BaseWorkflowSchema["subworkflows"]>("subworkflows");
+        },
+        set subworkflows(value: BaseWorkflowSchema["subworkflows"]) {
+            this.setProp("subworkflows", value);
+        },
+        get units() {
+            return this.requiredProp<BaseWorkflowSchema["units"]>("units");
+        },
+        set units(value: BaseWorkflowSchema["units"]) {
+            this.setProp("units", value);
+        },
+        get application() {
+            return this.prop<BaseWorkflowSchema["application"]>("application");
+        },
+        set application(value: BaseWorkflowSchema["application"]) {
+            this.setProp("application", value);
+        },
+        get tags() {
+            return this.prop<BaseWorkflowSchema["tags"]>("tags");
+        },
+        set tags(value: BaseWorkflowSchema["tags"]) {
+            this.setProp("tags", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/index.ts

@@ -0,0 +1,44 @@
+import PointsPathFormDataProvider from "./context/providers/PointsPath/PointsPathFormDataProvider";
+import { globalSettings } from "./context/providers/settings";
+import { TAB_NAVIGATION_CONFIG, UNIT_NAME_INVALID_CHARS, WORKFLOW_STATUSES } from "./enums";
+import Subworkflow from "./Subworkflow";
+import {
+    AssertionUnit,
+    AssignmentUnit,
+    BaseUnit,
+    ConditionUnit,
+    ExecutionUnit,
+    IOUnit,
+    MapUnit,
+    ReduceUnit,
+    SubworkflowUnit,
+} from "./units";
+import { UnitFactory } from "./units/factory";
+import { defaultMapConfig } from "./units/MapUnit";
+import * as utils from "./utils";
+import Workflow from "./Workflow";
+
+export type { OrderedMaterial } from "./context/mixins/MaterialContextMixin";
+export type { MaterialsSet } from "./context/mixins/MaterialsSetContextMixin";
+export type { AnySubworkflowUnit, DefaultSubworkflowUnitType } from "./units/factory";
+export {
+    Subworkflow,
+    Workflow,
+    UnitFactory,
+    TAB_NAVIGATION_CONFIG,
+    UNIT_NAME_INVALID_CHARS,
+    WORKFLOW_STATUSES,
+    BaseUnit,
+    ExecutionUnit,
+    AssertionUnit,
+    AssignmentUnit,
+    ConditionUnit,
+    IOUnit,
+    MapUnit,
+    ReduceUnit,
+    SubworkflowUnit,
+    defaultMapConfig,
+    PointsPathFormDataProvider,
+    globalSettings,
+    utils,
+};

package/src/js/units/AssertionUnit.ts

@@ -0,0 +1,49 @@
+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 { AssertionUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import { UnitType } from "../enums";
+import {
+    type AssertionUnitSchemaMixin,
+    assertionUnitSchemaMixin,
+} from "../generated/AssertionUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+
+type Schema = AssertionUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<AssertionUnitSchemaMixin>;
+
+export type AssertionUnitConfig = Partial<Schema>;
+
+class AssertionUnit extends (BaseUnit as Base) implements Schema {
+    declare toJSON: () => Schema & AnyObject;
+
+    declare _json: Schema & AnyObject;
+
+    static get jsonSchema() {
+        return JSONSchemasInterface.getSchemaById("workflow/unit/assertion");
+    }
+
+    constructor(config: AssertionUnitConfig) {
+        const schema = {
+            name: UnitType.assertion,
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            statement: "true",
+            errorMessage: "assertion failed",
+            ...config,
+            type: UnitType.assertion as Schema["type"],
+        };
+        super(schema);
+    }
+
+    getHashObject() {
+        return { statement: this.statement, errorMessage: this.errorMessage };
+    }
+}
+
+assertionUnitSchemaMixin(AssertionUnit.prototype);
+
+export default AssertionUnit;

package/src/js/units/AssignmentUnit.ts

@@ -0,0 +1,49 @@
+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 { AssignmentUnitSchema } from "@mat3ra/esse/dist/js/types";
+
+import { UnitType } from "../enums";
+import {
+    type AssignmentUnitSchemaMixin,
+    assignmentUnitSchemaMixin,
+} from "../generated/AssignmentUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+
+type Schema = AssignmentUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<AssignmentUnitSchemaMixin>;
+export type AssignmentUnitConfig = Partial<Schema>;
+
+class AssignmentUnit extends (BaseUnit as Base) implements Schema {
+    declare toJSON: () => Schema & AnyObject;
+
+    declare _json: Schema & AnyObject;
+
+    static get jsonSchema() {
+        return JSONSchemasInterface.getSchemaById("workflow/unit/assignment");
+    }
+
+    constructor(config: AssignmentUnitConfig) {
+        const schema = {
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            operand: "X",
+            value: "1",
+            ...config,
+            name: config.name ?? UnitType.assignment,
+            type: UnitType.assignment as Schema["type"],
+        };
+        super(schema);
+    }
+
+    getHashObject(): object {
+        return { input: this.input, operand: this.operand, value: this.value };
+    }
+}
+
+assignmentUnitSchemaMixin(AssignmentUnit.prototype);
+
+export default AssignmentUnit;