@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

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

@@ -0,0 +1,24 @@
+import type { MlSettingsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+type Schema = MlSettingsContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+declare class MLSettingsDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "mlSettings";
+    readonly domain: "important";
+    readonly entityName: "unit";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): MLSettingsDataManager;
+    readonly jsonSchema: JSONSchema7;
+    readonly uiSchema: {
+        readonly target_column_name: {};
+        readonly problem_category: {};
+    };
+    readonly extraData: {};
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): {
+        target_column_name: string;
+        problem_category: "regression";
+    };
+}
+export default MLSettingsDataManager;

package/dist/js/context/providers/MLSettingsDataManager.js

@@ -0,0 +1,42 @@
+"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 JSONSchemaDataProvider_1 = __importDefault(require("./base/JSONSchemaDataProvider"));
+const jsonSchemaId = "context-providers-directory/ml-settings-context-provider";
+const defaultData = {
+    target_column_name: "target",
+    problem_category: "regression",
+};
+class MLSettingsDataManager extends JSONSchemaDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "mlSettings");
+        return new MLSettingsDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.name = "mlSettings";
+        this.domain = "important";
+        this.entityName = "unit";
+        this.uiSchema = {
+            target_column_name: {},
+            problem_category: {},
+        };
+        this.extraData = {};
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            target_column_name: { default: defaultData.target_column_name },
+            problem_category: { default: defaultData.problem_category },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}
+exports.default = MLSettingsDataManager;

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

@@ -0,0 +1,23 @@
+import type { MlTrainTestSplitContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+type Schema = MlTrainTestSplitContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+declare class MLTrainTestSplitDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "mlTrainTestSplit";
+    readonly domain: "important";
+    readonly entityName: "unit";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): MLTrainTestSplitDataManager;
+    readonly jsonSchema: JSONSchema7;
+    readonly uiSchema: {
+        readonly target_column_name: {};
+        readonly problem_category: {};
+    };
+    readonly extraData: {};
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): {
+        fraction_held_as_test_set: number;
+    };
+}
+export default MLTrainTestSplitDataManager;

package/dist/js/context/providers/MLTrainTestSplitDataManager.js

@@ -0,0 +1,40 @@
+"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 JSONSchemaDataProvider_1 = __importDefault(require("./base/JSONSchemaDataProvider"));
+const jsonSchemaId = "context-providers-directory/ml-train-test-split-context-provider";
+const defaultData = {
+    fraction_held_as_test_set: 0.2,
+};
+class MLTrainTestSplitDataManager extends JSONSchemaDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "mlTrainTestSplit");
+        return new MLTrainTestSplitDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.name = "mlTrainTestSplit";
+        this.domain = "important";
+        this.entityName = "unit";
+        this.uiSchema = {
+            target_column_name: {},
+            problem_category: {},
+        };
+        this.extraData = {};
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            fraction_held_as_test_set: { default: defaultData.fraction_held_as_test_set },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}
+exports.default = MLTrainTestSplitDataManager;

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

@@ -0,0 +1,23 @@
+import type { NebContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import type { UnitContext } from "./base/ContextProvider";
+import type { JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+import JSONSchemaFormDataProvider from "./base/JSONSchemaFormDataProvider";
+type Schema = NebContextItemSchema;
+type ExternalContext = JinjaExternalContext;
+export default class NEBFormDataManager extends JSONSchemaFormDataProvider<Schema> {
+    readonly name: "neb";
+    readonly domain: "important";
+    readonly entityName: "unit";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): NEBFormDataManager;
+    readonly uiSchema: {
+        readonly nImages: {};
+    };
+    readonly jsonSchema: JSONSchema7;
+    readonly extraData: {};
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): {
+        nImages: number;
+    };
+}
+export {};

package/dist/js/context/providers/NEBFormDataManager.js

@@ -0,0 +1,39 @@
+"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 JSONSchemaFormDataProvider_1 = __importDefault(require("./base/JSONSchemaFormDataProvider"));
+const jsonSchemaId = "context-providers-directory/neb-data-provider";
+const defaultData = {
+    nImages: 1,
+};
+class NEBFormDataManager extends JSONSchemaFormDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "neb");
+        return new NEBFormDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.name = "neb";
+        this.domain = "important";
+        this.entityName = "unit";
+        this.uiSchema = {
+            nImages: {},
+        };
+        this.extraData = {};
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            nImages: { default: defaultData.nImages },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultData() {
+        return defaultData;
+    }
+}
+exports.default = NEBFormDataManager;

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

@@ -0,0 +1,78 @@
+import type { NonCollinearMagnetizationContextItemSchema, NonCollinearMagnetizationContextProviderSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../mixins/MaterialContextMixin";
+import type { UnitContext } from "./base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./base/JSONSchemaDataProvider";
+type Data = NonCollinearMagnetizationContextProviderSchema;
+type Schema = NonCollinearMagnetizationContextItemSchema;
+type ExternalContext = JinjaExternalContext & MaterialExternalContext;
+interface NonCollinearMagnetizationDataManager extends MaterialContextMixin {
+}
+declare class NonCollinearMagnetizationDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "nonCollinearMagnetization";
+    readonly domain: "important";
+    readonly entityName: "unit";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): NonCollinearMagnetizationDataManager;
+    readonly isStartingMagnetization: boolean;
+    readonly isConstrainedMagnetization: boolean;
+    readonly isExistingChargeDensity: boolean;
+    readonly isArbitrarySpinDirection: boolean;
+    readonly isFixedMagnetization: boolean;
+    readonly constrainedMagnetization: Data["constrainedMagnetization"];
+    readonly jsonSchema: JSONSchema7;
+    private readonly uniqueElementsWithLabels;
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): Data;
+    get uiSchemaStyled(): {
+        isExistingChargeDensity: {};
+        lforcet: {
+            "ui:readonly": boolean;
+            "ui:widget": string;
+            "ui:options": {
+                inline: boolean;
+            };
+        };
+        isArbitrarySpinDirection: {};
+        spinAngles: {
+            items: {
+                atomicSpecies: {
+                    "ui:readonly": boolean;
+                };
+            };
+            "ui:readonly": boolean;
+            "ui:options": {
+                addable: boolean;
+                orderable: boolean;
+                removable: boolean;
+            };
+        };
+        isStartingMagnetization: {};
+        startingMagnetization: {
+            items: {
+                atomicSpecies: {
+                    "ui:readonly": boolean;
+                };
+                value: {
+                    "ui:classNames": string;
+                };
+            };
+            "ui:readonly": boolean;
+            "ui:options": {
+                addable: boolean;
+                orderable: boolean;
+                removable: boolean;
+            };
+        };
+        isConstrainedMagnetization: {};
+        constrainedMagnetization: {
+            "ui:readonly": boolean;
+        };
+        isFixedMagnetization: {
+            "ui:readonly": boolean;
+        };
+        fixedMagnetization: {
+            "ui:readonly": boolean;
+        };
+    };
+}
+export default NonCollinearMagnetizationDataManager;

package/dist/js/context/providers/NonCollinearMagnetizationDataManager.js

@@ -0,0 +1,181 @@
+"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 defaultData = {
+    isExistingChargeDensity: false,
+    isStartingMagnetization: true,
+    isConstrainedMagnetization: false,
+    isArbitrarySpinAngle: false,
+    isArbitrarySpinDirection: false,
+    isFixedMagnetization: false,
+    lforcet: true,
+    value: 0.0,
+    angle1: 0.0,
+    angle2: 0.0,
+    constrainType: "atomic direction",
+    lambda: 0.0,
+    fixedMagnetizationX: 0.0,
+    fixedMagnetizationY: 0.0,
+    fixedMagnetizationZ: 0.0,
+};
+const jsonSchemaId = "context-providers-directory/non-collinear-magnetization-context-provider";
+class NonCollinearMagnetizationDataManager extends JSONSchemaDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "nonCollinearMagnetization");
+        return new NonCollinearMagnetizationDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        super(contextItem, externalContext);
+        this.name = "nonCollinearMagnetization";
+        this.domain = "important";
+        this.entityName = "unit";
+        this.initMaterialContextMixin(externalContext);
+        this.isStartingMagnetization = (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.isStartingMagnetization) !== null && _b !== void 0 ? _b : true;
+        this.isConstrainedMagnetization = (_d = (_c = this.data) === null || _c === void 0 ? void 0 : _c.isConstrainedMagnetization) !== null && _d !== void 0 ? _d : false;
+        this.isExistingChargeDensity = (_f = (_e = this.data) === null || _e === void 0 ? void 0 : _e.isExistingChargeDensity) !== null && _f !== void 0 ? _f : false;
+        this.isArbitrarySpinDirection = (_h = (_g = this.data) === null || _g === void 0 ? void 0 : _g.isArbitrarySpinDirection) !== null && _h !== void 0 ? _h : false;
+        this.isFixedMagnetization = (_k = (_j = this.data) === null || _j === void 0 ? void 0 : _j.isFixedMagnetization) !== null && _k !== void 0 ? _k : false;
+        this.constrainedMagnetization = (_m = (_l = this.data) === null || _l === void 0 ? void 0 : _l.constrainedMagnetization) !== null && _m !== void 0 ? _m : {
+            lambda: 0.0,
+            constrainType: "atomic direction",
+        };
+        this.uniqueElementsWithLabels = [
+            ...new Set(((_p = (_o = this.material) === null || _o === void 0 ? void 0 : _o.Basis) === null || _p === void 0 ? void 0 : _p.elementsWithLabelsArray) || []),
+        ];
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            isExistingChargeDensity: { default: defaultData.isExistingChargeDensity },
+            isStartingMagnetization: { default: defaultData.isStartingMagnetization },
+            isArbitrarySpinAngle: { default: defaultData.isArbitrarySpinAngle },
+            isConstrainedMagnetization: { default: defaultData.isConstrainedMagnetization },
+            isFixedMagnetization: { default: defaultData.isFixedMagnetization },
+            startingMagnetization: {
+                minItems: this.uniqueElementsWithLabels.length,
+                maxItems: this.uniqueElementsWithLabels.length,
+            },
+            "startingMagnetization.items.properties.value": {
+                default: defaultData.value,
+                minimum: -1.0,
+                maximum: 1.0,
+            },
+            spinAngles: {
+                minItems: this.uniqueElementsWithLabels.length,
+                maxItems: this.uniqueElementsWithLabels.length,
+            },
+            "spinAngles.items.properties.angle1": { default: defaultData.angle1 },
+            "spinAngles.items.properties.angle2": { default: defaultData.angle2 },
+            "constrainedMagnetization.properties.constrainType": {
+                default: defaultData.constrainType,
+            },
+            "constrainedMagnetization.properties.lambda": { default: defaultData.lambda },
+            "fixedMagnetization.properties.x": { default: defaultData.fixedMagnetizationX },
+            "fixedMagnetization.properties.y": { default: defaultData.fixedMagnetizationY },
+            "fixedMagnetization.properties.z": { default: defaultData.fixedMagnetizationZ },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    getDefaultData() {
+        const startingMagnetization = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                value: defaultData.value,
+            };
+        });
+        const spinAngles = this.uniqueElementsWithLabels.map((element, index) => {
+            return {
+                index: index + 1,
+                atomicSpecies: element,
+                angle1: defaultData.angle1,
+                angle2: defaultData.angle2,
+            };
+        });
+        return {
+            isExistingChargeDensity: defaultData.isExistingChargeDensity,
+            isStartingMagnetization: defaultData.isStartingMagnetization,
+            isConstrainedMagnetization: defaultData.isConstrainedMagnetization,
+            isArbitrarySpinAngle: defaultData.isArbitrarySpinAngle,
+            isArbitrarySpinDirection: defaultData.isArbitrarySpinDirection,
+            isFixedMagnetization: defaultData.isFixedMagnetization,
+            lforcet: defaultData.lforcet,
+            spinAngles,
+            startingMagnetization,
+            constrainedMagnetization: {
+                lambda: defaultData.lambda,
+                constrainType: defaultData.constrainType,
+            },
+            fixedMagnetization: {
+                x: defaultData.fixedMagnetizationX,
+                y: defaultData.fixedMagnetizationY,
+                z: defaultData.fixedMagnetizationZ,
+            },
+        };
+    }
+    get uiSchemaStyled() {
+        var _a, _b;
+        return {
+            isExistingChargeDensity: {},
+            lforcet: {
+                "ui:readonly": !this.isExistingChargeDensity,
+                "ui:widget": "radio",
+                "ui:options": {
+                    inline: true,
+                },
+            },
+            isArbitrarySpinDirection: {},
+            spinAngles: {
+                items: {
+                    atomicSpecies: {
+                        "ui:readonly": true,
+                    },
+                },
+                "ui:readonly": !this.isArbitrarySpinDirection,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isStartingMagnetization: {},
+            startingMagnetization: {
+                items: {
+                    atomicSpecies: {
+                        "ui:readonly": true,
+                    },
+                    value: {
+                        "ui:classNames": "col-xs-6",
+                    },
+                },
+                "ui:readonly": !this.isStartingMagnetization,
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+            },
+            isConstrainedMagnetization: {},
+            constrainedMagnetization: {
+                "ui:readonly": !this.isConstrainedMagnetization,
+            },
+            isFixedMagnetization: {
+                "ui:readonly": !(this.isConstrainedMagnetization &&
+                    ((_a = this.constrainedMagnetization) === null || _a === void 0 ? void 0 : _a.constrainType) === "total"),
+            },
+            fixedMagnetization: {
+                "ui:readonly": !(this.isFixedMagnetization &&
+                    this.isConstrainedMagnetization &&
+                    ((_b = this.constrainedMagnetization) === null || _b === void 0 ? void 0 : _b.constrainType) === "total"),
+            },
+        };
+    }
+}
+(0, MaterialContextMixin_1.default)(NonCollinearMagnetizationDataManager.prototype);
+exports.default = NonCollinearMagnetizationDataManager;

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

@@ -0,0 +1,26 @@
+import type { CutoffsContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type ApplicationContextMixin, type ApplicationExternalContext } from "../mixins/ApplicationContextMixin";
+import ContextProvider, { type BaseExternalContext, type UnitContext } from "./base/ContextProvider";
+type Schema = CutoffsContextItemSchema;
+type PlanewaveExternalContext = BaseExternalContext & ApplicationExternalContext;
+interface PlanewaveCutoffDataManager extends ApplicationContextMixin {
+}
+declare class PlanewaveCutoffDataManager extends ContextProvider<Schema, PlanewaveExternalContext> {
+    readonly name: "cutoffs";
+    readonly domain: "important";
+    readonly entityName: "subworkflow";
+    readonly jsonSchema: JSONSchema7;
+    readonly uiSchema: {
+        readonly wavefunction: {};
+        readonly density: {};
+    };
+    readonly extraData: {};
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PlanewaveExternalContext): PlanewaveCutoffDataManager;
+    constructor(contextItem: Partial<Schema>, externalContext: PlanewaveExternalContext);
+    getDefaultData(): {
+        wavefunction: number | undefined;
+        density: number | undefined;
+    };
+}
+export default PlanewaveCutoffDataManager;

package/dist/js/context/providers/PlanewaveCutoffDataManager.js

@@ -0,0 +1,69 @@
+"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 ApplicationContextMixin_1 = __importDefault(require("../mixins/ApplicationContextMixin"));
+const ContextProvider_1 = __importDefault(require("./base/ContextProvider"));
+// Type guard to check if a string is a valid ApplicationName
+function isApplicationName(name) {
+    return name === "vasp" || name === "espresso";
+}
+// TODO: create a task to move this handling to standata
+const cutoffConfig = {
+    vasp: { wavefunction: undefined, density: undefined },
+    espresso: { wavefunction: 40, density: 200 },
+};
+const defaultData = {
+    wavefunction: undefined,
+    density: undefined,
+};
+const jsonSchemaId = "context-providers-directory/planewave-cutoffs-context-provider";
+class PlanewaveCutoffDataManager extends ContextProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "cutoffs");
+        return new PlanewaveCutoffDataManager(contextItem, externalContext);
+    }
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.name = "cutoffs";
+        this.domain = "important";
+        this.entityName = "subworkflow";
+        this.uiSchema = {
+            wavefunction: {},
+            density: {},
+        };
+        this.extraData = {};
+        this.initApplicationContextMixin(externalContext);
+        const { wavefunction, density } = this.getDefaultData();
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            wavefunction: { default: wavefunction },
+            density: { default: density },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    getDefaultData() {
+        const applicationName = this.application.name;
+        // Type-safe check: ensure application name is valid and exists in config
+        if (!isApplicationName(applicationName)) {
+            // Fallback to default values if application is not supported
+            return defaultData;
+        }
+        const config = cutoffConfig[applicationName];
+        if (!config) {
+            // Fallback to default values if application is not in cutoffConfig
+            return defaultData;
+        }
+        const { wavefunction, density } = config;
+        return {
+            wavefunction: wavefunction !== null && wavefunction !== void 0 ? wavefunction : defaultData.wavefunction,
+            density: density !== null && density !== void 0 ? density : defaultData.density,
+        };
+    }
+}
+(0, ApplicationContextMixin_1.default)(PlanewaveCutoffDataManager.prototype);
+exports.default = PlanewaveCutoffDataManager;

package/dist/js/context/providers/PointsGrid/IGridFormDataManager.d.ts

@@ -0,0 +1,13 @@
+import type { GridContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import type { UnitContext } from "../base/ContextProvider";
+import PointsGridFormDataProvider, { type ExternalContext } from "./PointsGridFormDataProvider";
+type Name = "igrid";
+type Schema = GridContextItemSchema;
+export default class IGridFormDataManager extends PointsGridFormDataProvider<Name> {
+    readonly name: "igrid";
+    readonly jsonSchema: JSONSchema7;
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): IGridFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsGrid/IGridFormDataManager.js

@@ -0,0 +1,23 @@
+"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 PointsGridFormDataProvider_1 = __importDefault(require("./PointsGridFormDataProvider"));
+class IGridFormDataManager extends PointsGridFormDataProvider_1.default {
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext, 0.2);
+        this.name = "igrid";
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(this.jsonSchemaId, this.jsonSchemaPatchConfig);
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "igrid");
+        return new IGridFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = IGridFormDataManager;

package/dist/js/context/providers/PointsGrid/KGridFormDataManager.d.ts

@@ -0,0 +1,15 @@
+import type { GridContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import ConvergenceParameter from "../../../convergence/ConvergenceParameter";
+import type { UnitContext } from "../base/ContextProvider";
+import PointsGridFormDataProvider, { type ExternalContext } from "./PointsGridFormDataProvider";
+type Name = "kgrid";
+type Schema = GridContextItemSchema;
+export default class KGridFormDataManager extends PointsGridFormDataProvider<Name> {
+    readonly name: "kgrid";
+    readonly jsonSchema: JSONSchema7;
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): KGridFormDataManager;
+    applyConvergenceParameter(parameter: ConvergenceParameter): void;
+}
+export {};

package/dist/js/context/providers/PointsGrid/KGridFormDataManager.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 PointsGridFormDataProvider_1 = __importDefault(require("./PointsGridFormDataProvider"));
+class KGridFormDataManager extends PointsGridFormDataProvider_1.default {
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext, 1);
+        this.name = "kgrid";
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(this.jsonSchemaId, this.jsonSchemaPatchConfig);
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "kgrid");
+        return new KGridFormDataManager(contextItem, externalContext);
+    }
+    applyConvergenceParameter(parameter) {
+        this.setData({
+            ...this.getData(),
+            ...parameter.unitContext.data,
+        });
+        this.setIsEdited(true);
+    }
+}
+exports.default = KGridFormDataManager;