@mat3ra/wode 2026.5.23-0 → 2026.5.29-0

package/dist/js/Workflow.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const DefaultableMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/DefaultableMixin");
+const HasDescriptionMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/HasDescriptionMixin");
+const HashedEntityMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/HashedEntityMixin");
+const NamedEntityMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/NamedEntityMixin");
+const TaggableMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/TaggableMixin");
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const compute_1 = require("@mat3ra/ide/dist/js/compute");
+const standata_1 = require("@mat3ra/standata");
+const utils_1 = require("@mat3ra/utils");
+const enums_1 = require("./enums");
+const WorkflowSchemaMixin_1 = require("./generated/WorkflowSchemaMixin");
+const Subworkflow_1 = __importDefault(require("./Subworkflow"));
+const units_1 = require("./units");
+const factory_1 = require("./units/factory");
+const workflow_1 = require("./utils/workflow");
+const default_1 = __importDefault(require("./workflows/default"));
+class Workflow extends entity_1.InMemoryEntity {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow");
+    }
+    setTotalRepetitions(totalRepetition) {
+        this.totalRepetitions = totalRepetition;
+    }
+    setRepetition(repetition) {
+        this.repetition = repetition;
+        this.unitInstances.forEach((u) => u.setRepetition(repetition));
+        this.subworkflowInstances.forEach((sw) => sw.setRepetition(repetition));
+        this.workflowInstances.forEach((wf) => wf.setRepetition(repetition));
+    }
+    static fromSubworkflow(subworkflow) {
+        const config = {
+            name: subworkflow.name,
+            subworkflows: [subworkflow.toJSON()],
+            units: [subworkflow.getAsUnit().toJSON()],
+            properties: subworkflow.properties,
+            applicationName: subworkflow.application.name,
+            workflows: [],
+        };
+        return new this(config);
+    }
+    constructor(config) {
+        var _a;
+        super({
+            ...config,
+            _id: config._id || utils_1.Utils.uuid.getUUID(),
+        });
+        this.repetition = 0;
+        this.totalRepetitions = 1;
+        this.subworkflowInstances = this.subworkflows.map((x) => new Subworkflow_1.default(x));
+        this.workflowInstances = ((_a = this.workflows) === null || _a === void 0 ? void 0 : _a.map((x) => new Workflow(x))) || [];
+        this.setUnits(this.units.map((unit) => factory_1.UnitFactory.createInWorkflow(unit)));
+    }
+    get workflows() {
+        return this.requiredProp("workflows");
+    }
+    set workflows(value) {
+        this.setProp("workflows", value);
+    }
+    addSubworkflow(subworkflow, head = false, index = -1) {
+        const subworkflowUnit = subworkflow.getAsUnit();
+        if (head) {
+            this.subworkflowInstances.unshift(subworkflow);
+            this.addUnit(subworkflowUnit, head, index);
+        }
+        else {
+            this.subworkflowInstances.push(subworkflow);
+            this.addUnit(subworkflowUnit, head, index);
+        }
+    }
+    updateMethodData(materials, metaProperties) {
+        this.subworkflowInstances.forEach((sw) => {
+            sw.updateMethodData(materials, metaProperties);
+        });
+    }
+    removeSubworkflow(id) {
+        const subworkflowUnit = this.unitInstances.find((u) => u.id === id);
+        if (subworkflowUnit) {
+            this.removeUnit(subworkflowUnit.flowchartId);
+        }
+    }
+    setUnits(arr) {
+        this.unitInstances = (0, standata_1.setUnitLinks)(arr);
+        this.units = this.unitInstances.map((u) => u.toJSON());
+    }
+    /**
+     * A top-level subworkflow branch is represented twice: a {@link UnitType.subworkflow} unit in
+     * `unitInstances` (flowchart card) and a full {@link Subworkflow} in `subworkflowInstances`
+     * (linked by the same `id` as {@link Subworkflow.getAsUnit}). Their display names must match
+     * so `toJSON()` and editors stay consistent. Call this after mutating a subworkflow unit's
+     * `name` (and updating `unitInstances` via {@link setUnits}).
+     */
+    syncLinkedSubworkflowNameFromUnit(unit) {
+        if (unit.type !== enums_1.UnitType.subworkflow)
+            return;
+        const linked = this.subworkflowInstances.find((s) => s.id === unit.id);
+        linked === null || linked === void 0 ? void 0 : linked.setName(unit.name);
+    }
+    render(context) {
+        this.subworkflowInstances.forEach((sw) => {
+            sw.render({
+                ...context,
+                workflowHasRelaxation: this.hasRelaxation,
+            });
+        });
+        this.workflowInstances.forEach((wf) => {
+            wf.render(context);
+        });
+    }
+    get usedApplications() {
+        return (0, workflow_1.getUsedApplications)(this);
+    }
+    // return application names
+    get usedApplicationNames() {
+        return this.usedApplications.map((a) => a.name);
+    }
+    get usedApplicationVersions() {
+        return this.usedApplications.map((a) => a.version);
+    }
+    get usedApplicationNamesWithVersions() {
+        return this.usedApplications.map((a) => `${a.name} ${a.version}`);
+    }
+    getUsedModels() {
+        return (0, workflow_1.getUsedModels)(this);
+    }
+    getHumanReadableUsedModels() {
+        return (0, workflow_1.getHumanReadableUsedModels)(this);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            name: this.name,
+            properties: (0, workflow_1.getProperties)(this),
+            units: this.unitInstances.map((x) => x.toJSON()),
+            subworkflows: this.subworkflowInstances.map((x) => x.toJSON()),
+            workflows: this.workflowInstances.map((x) => x.toJSON()),
+        };
+    }
+    getHumanReadableProperties() {
+        return (0, workflow_1.getHumanReadableProperties)(this);
+    }
+    getProperties() {
+        return (0, workflow_1.getProperties)(this);
+    }
+    getSystemName() {
+        return (0, workflow_1.getSystemName)(this);
+    }
+    getDefaultDescription() {
+        return (0, workflow_1.getDefaultDescription)(this);
+    }
+    addUnit(unit, head = false, index = -1) {
+        const [...unitInstances] = this.unitInstances;
+        if (unitInstances.length === 0) {
+            this.setUnits([unit]);
+        }
+        else {
+            if (head) {
+                unitInstances.unshift(unit);
+            }
+            else if (index >= 0) {
+                unitInstances.splice(index, 0, unit);
+            }
+            else {
+                unitInstances.push(unit);
+            }
+            this.setUnits(unitInstances);
+        }
+    }
+    removeUnit(flowchartId) {
+        if (this.units.length < 2) {
+            return;
+        }
+        const unit = this.unitInstances.find((x) => x.flowchartId === flowchartId);
+        if (!unit) {
+            return;
+        }
+        const previousUnit = this.unitInstances.find((x) => x.next === unit.flowchartId);
+        if (previousUnit) {
+            delete previousUnit.next;
+        }
+        this.subworkflowInstances = this.subworkflowInstances.filter((x) => x.id !== unit.id);
+        this.setUnits(this.unitInstances.filter((x) => x.flowchartId !== flowchartId));
+    }
+    /*
+     * @param type {String|Object} Unit type, map or subworkflow
+     * @param head {Boolean}
+     * @param index {Number} Index at which the unit will be added. -1 by default (ignored).
+     */
+    addUnitType(type, head = false, index = -1) {
+        switch (type) {
+            case enums_1.UnitType.map: {
+                const mapWorkflowConfig = {
+                    ...default_1.default,
+                    _id: utils_1.Utils.uuid.getUUID(),
+                };
+                const mapUnit = new units_1.MapUnit({
+                    workflowId: mapWorkflowConfig._id,
+                });
+                this.workflows = [...(this.workflows || []), mapWorkflowConfig];
+                this.workflowInstances = this.workflows.map((x) => new Workflow(x));
+                this.addUnit(mapUnit, head, index);
+                break;
+            }
+            case enums_1.UnitType.subworkflow:
+                this.addSubworkflow(Subworkflow_1.default.createDefault(), head, index);
+                break;
+            default:
+                console.log(`unit_type=${type} unrecognized, skipping.`);
+        }
+    }
+    addMapUnit(mapUnit, mapWorkflow) {
+        const mapWorkflowConfig = {
+            _id: utils_1.Utils.uuid.getUUID(),
+            ...mapWorkflow.toJSON(),
+        };
+        mapUnit.setWorkflowId(mapWorkflowConfig._id);
+        this.addUnit(mapUnit);
+        this.workflows = [...(this.workflows || []), mapWorkflowConfig];
+        this.workflowInstances = this.workflows.map((x) => new Workflow(x));
+    }
+    get allSubworkflows() {
+        const subworkflowsList = [];
+        this.subworkflowInstances.forEach((sw) => subworkflowsList.push(sw));
+        this.workflowInstances.forEach((workflow) => {
+            return Array.prototype.push.apply(subworkflowsList, workflow.allSubworkflows);
+        });
+        return subworkflowsList;
+    }
+    get hasRelaxation() {
+        return Boolean(this.getRelaxationSubworkflow());
+    }
+    toggleRelaxation() {
+        const relaxSubworkflow = this.getRelaxationSubworkflow();
+        if (relaxSubworkflow === null || relaxSubworkflow === void 0 ? void 0 : relaxSubworkflow._id) {
+            this.removeSubworkflow(relaxSubworkflow._id);
+        }
+        else {
+            const vcRelax = this.getStandataRelaxationSubworkflow();
+            if (vcRelax) {
+                this.addSubworkflow(new Subworkflow_1.default(vcRelax), true);
+            }
+        }
+    }
+    getHashObject() {
+        return {
+            units: this.unitInstances.map((u) => u.calculateHash()).join(),
+            subworkflows: this.subworkflowInstances.map((sw) => sw.calculateHash()).join(),
+            workflows: this.workflowInstances.map((w) => w.calculateHash()).join(),
+        };
+    }
+    getStandataRelaxationSubworkflow() {
+        // TODO: fix standata type
+        const subworkflow = new standata_1.SubworkflowStandata().getRelaxationSubworkflowByApplication(this.subworkflowInstances[0].application.name);
+        if (!subworkflow) {
+            return undefined;
+        }
+        const executionUnit = subworkflow.units.find((unit) => unit.type === enums_1.UnitType.execution);
+        if (!executionUnit) {
+            throw new Error("Relaxation subworkflow is missing an execution unit");
+        }
+        return {
+            ...subworkflow,
+            application: executionUnit.application,
+        };
+    }
+    getRelaxationSubworkflow() {
+        const standataSubworkflow = this.getStandataRelaxationSubworkflow();
+        return this.subworkflowInstances.find((sw) => {
+            return standataSubworkflow && standataSubworkflow.systemName === sw.systemName;
+        });
+    }
+}
+Workflow.defaultConfig = default_1.default;
+(0, NamedEntityMixin_1.namedEntityMixin)(Workflow.prototype);
+(0, WorkflowSchemaMixin_1.workflowSchemaMixin)(Workflow.prototype);
+(0, TaggableMixin_1.taggableMixin)(Workflow.prototype);
+(0, compute_1.computedEntityMixin)(Workflow.prototype);
+(0, DefaultableMixin_1.defaultableEntityMixin)(Workflow);
+(0, HashedEntityMixin_1.hashedEntityMixin)(Workflow.prototype);
+(0, HasDescriptionMixin_1.hasDescriptionMixin)(Workflow.prototype);
+exports.default = Workflow;

package/dist/js/WorkflowDesignerMaterial.d.ts

@@ -0,0 +1,21 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import { type InMemoryEntityInSet } from "@mat3ra/code/dist/js/entity/set/InMemoryEntityInSetMixin";
+import type { OrderedInMemoryEntityInSet } from "@mat3ra/code/dist/js/entity/set/ordered/OrderedInMemoryEntityInSetMixin";
+import type { ConsistencyCheck, MaterialSchema } from "@mat3ra/esse/dist/js/types";
+import { Material } from "@mat3ra/made";
+type Schema = Omit<MaterialSchema, "consistencyChecks"> & {
+    consistencyChecks?: ConsistencyCheck[];
+};
+interface WorkflowDesignerMaterial extends InMemoryEntityInSet, OrderedInMemoryEntityInSet {
+}
+/**
+ * `Material` with `OrderedInMemoryEntityInSet` for workflow designer / map nested `Workflow.render`
+ * (expects `OrderedMaterial` in render context), mirroring app materials that use ordered-set mixins.
+ */
+declare class WorkflowDesignerMaterial extends Material implements Schema {
+    constructor(config?: object | InMemoryEntity);
+    static createDefault(): WorkflowDesignerMaterial;
+    /** Wrap any `Material` as `OrderedMaterial` for `Workflow.render`. */
+    static fromMaterial(material: Material): WorkflowDesignerMaterial;
+}
+export default WorkflowDesignerMaterial;

package/dist/js/WorkflowDesignerMaterial.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const InMemoryEntityInSetMixin_1 = require("@mat3ra/code/dist/js/entity/set/InMemoryEntityInSetMixin");
+const OrderedInMemoryEntityInSetMixin_1 = require("@mat3ra/code/dist/js/entity/set/ordered/OrderedInMemoryEntityInSetMixin");
+const made_1 = require("@mat3ra/made");
+/**
+ * `Material` with `OrderedInMemoryEntityInSet` for workflow designer / map nested `Workflow.render`
+ * (expects `OrderedMaterial` in render context), mirroring app materials that use ordered-set mixins.
+ */
+class WorkflowDesignerMaterial extends made_1.Material {
+    constructor(config = {}) {
+        super(config instanceof entity_1.InMemoryEntity ? config.toJSON() : config);
+        this.setProp("inSet", this.prop("inSet", []));
+    }
+    static createDefault() {
+        return new WorkflowDesignerMaterial(made_1.defaultMaterialConfig);
+    }
+    /** Wrap any `Material` as `OrderedMaterial` for `Workflow.render`. */
+    static fromMaterial(material) {
+        return new WorkflowDesignerMaterial(material.toJSON());
+    }
+}
+(0, InMemoryEntityInSetMixin_1.inMemoryEntityInSetMixin)(WorkflowDesignerMaterial.prototype);
+(0, OrderedInMemoryEntityInSetMixin_1.orderedEntityInSetMixin)(WorkflowDesignerMaterial.prototype);
+exports.default = WorkflowDesignerMaterial;

package/dist/js/context/mixins/ApplicationContextMixin.d.ts

@@ -0,0 +1,10 @@
+import type { ApplicationSchema } from "@mat3ra/esse/dist/js/types";
+import type ContextProvider from "../providers/base/ContextProvider";
+export type ApplicationContextMixin = {
+    application: ApplicationSchema;
+    initApplicationContextMixin(externalContext: ApplicationExternalContext): void;
+};
+export type ApplicationExternalContext = {
+    application: ApplicationSchema;
+};
+export default function applicationContextMixin(item: ContextProvider): void;

package/dist/js/context/mixins/ApplicationContextMixin.js

@@ -1,19 +1,12 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.applicationContextMixin = applicationContextMixin;
-var _settings = require("../providers/settings");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = applicationContextMixin;
 function applicationContextMixin(item) {
-  const properties = {
-    _application: undefined,
-    initApplicationContextMixin() {
-      this._application = this.config.context && this.config.context.application || _settings.globalSettings.Application.createDefault();
-    },
-    get application() {
-      return this._application;
-    }
-  };
-  Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
-}
+    // @ts-expect-error
+    const properties = {
+        initApplicationContextMixin(externalContext) {
+            this.application = externalContext.application;
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/context/mixins/MaterialContextMixin.d.ts

@@ -0,0 +1,18 @@
+import type { OrderedInMemoryEntityInSet } from "@mat3ra/code/dist/js/entity/set/ordered/OrderedInMemoryEntityInSetMixin";
+import { Material } from "@mat3ra/made/dist/js/material";
+import type ContextProvider from "../providers/base/ContextProvider";
+export type OrderedMaterial = OrderedInMemoryEntityInSet & Material;
+export type MaterialContextMixin = {
+    readonly isMaterialCreatedDefault: boolean;
+    readonly isMaterialUpdated: boolean;
+    material: OrderedMaterial;
+    extraData?: {
+        materialHash: string;
+    };
+    initMaterialContextMixin(externalContext: MaterialExternalContext): void;
+    updateMaterialHash(): void;
+};
+export type MaterialExternalContext = {
+    material: OrderedMaterial;
+};
+export default function materialContextMixin(item: ContextProvider): void;

package/dist/js/context/mixins/MaterialContextMixin.js

@@ -1,40 +1,16 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.materialContextMixin = materialContextMixin;
-var _settings = require("../providers/settings");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = materialContextMixin;
 function materialContextMixin(item) {
-  const properties = {
-    _material: undefined,
-    updateMaterialHash() {
-      if (this.isEditedIsSetToFalseOnMaterialUpdate) this.isEdited = false;
-      this.extraData = {
-        materialHash: this.material.hash
-      };
-    },
-    // Workaround: Material.createDefault() used to initiate workflow reducer and hence here too
-    //  does not have an id. Here we catch when such material is used and avoid resetting isEdited
-    get isMaterialCreatedDefault() {
-      return !this.material.id;
-    },
-    get isMaterialUpdated() {
-      return Boolean(this.extraData && this.extraData.materialHash !== this.material.hash);
-    },
-    get material() {
-      if (!this._material) {
-        throw new Error("Material is not set");
-      }
-      return this._material;
-    },
-    initMaterialContextMixin() {
-      this._material = this.config.context && this.config.context.material;
-      if (!this._material) {
-        this._material = _settings.globalSettings.Material.createDefault();
-      }
-      this.updateMaterialHash();
-    }
-  };
-  Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
-}
+    // @ts-expect-error
+    const properties = {
+        updateMaterialHash() {
+            this.extraData = { materialHash: this.material.hash };
+        },
+        initMaterialContextMixin(externalContext) {
+            this.material = externalContext.material;
+            this.updateMaterialHash();
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/context/mixins/MaterialsContextMixin.d.ts

@@ -0,0 +1,10 @@
+import type ContextProvider from "../providers/base/ContextProvider";
+import type { OrderedMaterial } from "./MaterialContextMixin";
+export type MaterialsContextMixin = {
+    materials: OrderedMaterial[];
+    initMaterialsContextMixin(externalContext: MaterialsExternalContext): void;
+};
+export type MaterialsExternalContext = {
+    materials: OrderedMaterial[];
+};
+export default function materialsContextMixin(item: ContextProvider): void;

package/dist/js/context/mixins/MaterialsContextMixin.js

@@ -1,19 +1,13 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.materialsContextMixin = materialsContextMixin;
-var _settings = require("../providers/settings");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = materialsContextMixin;
 function materialsContextMixin(item) {
-  const properties = {
-    get materials() {
-      return this._materials;
-    },
-    initMaterialsContextMixin() {
-      const materials = this.config.context?.materials;
-      this._materials = materials && materials.length ? materials : [_settings.globalSettings.Material.createDefault()];
-    }
-  };
-  Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
-}
+    // @ts-expect-error
+    const properties = {
+        materials: [],
+        initMaterialsContextMixin(externalContext) {
+            this.materials = externalContext.materials;
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/context/mixins/MaterialsSetContextMixin.d.ts

@@ -0,0 +1,14 @@
+import type ContextProvider from "../providers/base/ContextProvider";
+import type { OrderedMaterial } from "./MaterialContextMixin";
+export type MaterialsSet = {
+    _id: string;
+};
+export type MaterialsSetExternalContext = {
+    materialsSet?: MaterialsSet;
+};
+export type MaterialsSetContextMixin = {
+    materialsSet?: MaterialsSet;
+    initMaterialsSetContextMixin(externalContext: MaterialsSetExternalContext): void;
+    sortMaterialsByIndexInSet(materials?: OrderedMaterial[]): OrderedMaterial[];
+};
+export default function materialsSetContextMixin(item: ContextProvider): void;

package/dist/js/context/mixins/MaterialsSetContextMixin.js

@@ -1,25 +1,23 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.materialsSetContextMixin = materialsSetContextMixin;
-var _utils = require("@mat3ra/code/dist/js/entity/set/ordered/utils");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = materialsSetContextMixin;
+const utils_1 = require("@mat3ra/code/dist/js/entity/set/ordered/utils");
 function materialsSetContextMixin(item) {
-  const properties = {
-    _materialsSet: undefined,
-    get materialsSet() {
-      return this._materialsSet;
-    },
-    initMaterialsSetContextMixin() {
-      this._materialsSet = this.config.context?.materialsSet;
-    },
-    sortMaterialsByIndexInSet(materials = []) {
-      // DO NOT SORT IN PLACE AS IT CHANGES THE ORDER IN `this.materials` AND HAS SIDE EFFECTS (MaterialViewer).
-      return materials.concat().sort((a, b) => {
-        return (0, _utils.compareEntitiesInOrderedSetForSorting)(a, b, this.materialsSet._id, false);
-      });
-    }
-  };
-  Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
-}
+    // @ts-expect-error
+    const properties = {
+        initMaterialsSetContextMixin(externalContext) {
+            this.materialsSet = externalContext.materialsSet;
+        },
+        sortMaterialsByIndexInSet(materials = []) {
+            const { materialsSet } = this;
+            if (!materialsSet) {
+                return materials;
+            }
+            // DO NOT SORT IN PLACE AS IT CHANGES THE ORDER IN `this.materials` AND HAS SIDE EFFECTS (MaterialViewer).
+            return [...materials].sort((a, b) => {
+                return (0, utils_1.compareEntitiesInOrderedSetForSorting)(a, b, materialsSet._id, false);
+            });
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/context/providers/BoundaryConditionsFormDataManager.d.ts

@@ -0,0 +1,30 @@
+import type { JSONSchema } from "@mat3ra/esse/dist/js/esse/utils";
+import type { BoundaryConditionsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../mixins/MaterialContextMixin";
+import type { UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+type Schema = BoundaryConditionsContextItemSchema;
+type ExternalContext = JinjaExternalContext & MaterialExternalContext;
+interface BoundaryConditionsFormDataManager extends MaterialContextMixin {
+}
+declare class BoundaryConditionsFormDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "boundaryConditions";
+    readonly domain: "important";
+    readonly entityName: "unit";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): BoundaryConditionsFormDataManager;
+    readonly humanName: "Boundary Conditions";
+    readonly uiSchema: {
+        readonly type: {
+            readonly "ui:disabled": true;
+        };
+        readonly offset: {
+            readonly "ui:disabled": true;
+        };
+        readonly electricField: {};
+        readonly targetFermiEnergy: {};
+    };
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): Schema["data"];
+    get jsonSchema(): JSONSchema;
+}
+export default BoundaryConditionsFormDataManager;

package/dist/js/context/providers/BoundaryConditionsFormDataManager.js

@@ -0,0 +1,62 @@
+"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 MaterialContextMixin_1 = __importDefault(require("../mixins/MaterialContextMixin"));
+const JSONSchemaDataProvider_1 = __importDefault(require("./base/JSONSchemaDataProvider"));
+const jsonSchemaId = "context-providers-directory/boundary-conditions-data-provider";
+// TODO: move to esse
+var BoundaryConditionsType;
+(function (BoundaryConditionsType) {
+    BoundaryConditionsType["pbc"] = "pbc";
+    BoundaryConditionsType["bc1"] = "bc1";
+    BoundaryConditionsType["bc2"] = "bc2";
+    BoundaryConditionsType["bc3"] = "bc3";
+})(BoundaryConditionsType || (BoundaryConditionsType = {}));
+class BoundaryConditionsFormDataManager extends JSONSchemaDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "boundaryConditions");
+        return new BoundaryConditionsFormDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.name = "boundaryConditions";
+        this.domain = "important";
+        this.entityName = "unit";
+        this.humanName = "Boundary Conditions";
+        this.uiSchema = {
+            type: { "ui:disabled": true },
+            offset: { "ui:disabled": true },
+            electricField: {},
+            targetFermiEnergy: {},
+        };
+        this.initMaterialContextMixin(externalContext);
+    }
+    getDefaultData() {
+        var _a, _b, _c;
+        const metadata = (_a = this.material) === null || _a === void 0 ? void 0 : _a.metadata;
+        return {
+            type: ((_b = metadata === null || metadata === void 0 ? void 0 : metadata.boundaryConditions) === null || _b === void 0 ? void 0 : _b.type) || BoundaryConditionsType.pbc,
+            offset: ((_c = metadata === null || metadata === void 0 ? void 0 : metadata.boundaryConditions) === null || _c === void 0 ? void 0 : _c.offset) || 0,
+            electricField: 0,
+            targetFermiEnergy: 0,
+        };
+    }
+    get jsonSchema() {
+        const defaults = this.getDefaultData();
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            type: { default: defaults.type },
+            offset: { default: defaults.offset },
+            electricField: { default: defaults.electricField },
+            targetFermiEnergy: { default: defaults.targetFermiEnergy },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        return jsonSchema;
+    }
+}
+(0, MaterialContextMixin_1.default)(BoundaryConditionsFormDataManager.prototype);
+exports.default = BoundaryConditionsFormDataManager;