@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

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

@@ -0,0 +1,171 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { GridContextItemSchema, PointsGridDataProviderSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../../mixins/MaterialContextMixin";
+import type { JinjaExternalContext } from "../base/JSONSchemaDataProvider";
+import JSONSchemaFormDataProvider from "../base/JSONSchemaFormDataProvider";
+type Schema = GridContextItemSchema;
+type Data = PointsGridDataProviderSchema;
+export type ExternalContext = JinjaExternalContext & MaterialExternalContext;
+type Base = typeof JSONSchemaFormDataProvider<Schema, ExternalContext> & Constructor<MaterialContextMixin>;
+type GridMetricType = Data["gridMetricType"];
+declare const PointsGridFormDataProvider_base: Base;
+declare abstract class PointsGridFormDataProvider<N extends Schema["name"]> extends PointsGridFormDataProvider_base {
+    abstract readonly name: N;
+    readonly domain: "important";
+    readonly entityName: "unit";
+    readonly jsonSchemaId = "context-providers-directory/points-grid-data-provider";
+    dimensions: Data["dimensions"];
+    shifts: Data["shifts"];
+    private reciprocalLattice;
+    private gridMetricType;
+    private gridMetricValue;
+    private preferGridMetric;
+    private defaultDimensions;
+    private reciprocalVectorRatios;
+    readonly divisor: number;
+    protected defaultMetric: {
+        type: GridMetricType;
+        value: number;
+    };
+    abstract readonly jsonSchema: JSONSchema7;
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext, divisor: number);
+    private initInstanceFields;
+    private getDefaultGridMetricValue;
+    private resolveGridMetricValue;
+    getData(): Data;
+    getDefaultData(): PointsGridDataProviderSchema;
+    protected get jsonSchemaPatchConfig(): {
+        dimensions: {
+            default?: any[] | undefined;
+            type: string;
+            items: {
+                default?: string | number | readonly number[] | readonly string[] | undefined;
+                type: string;
+            };
+            minItems: number;
+            maxItems: number;
+        };
+        shifts: {
+            default?: any[] | undefined;
+            type: string;
+            items: {
+                default?: string | number | readonly number[] | readonly string[] | undefined;
+                type: string;
+            };
+            minItems: number;
+            maxItems: number;
+        };
+        reciprocalVectorRatios: {
+            default?: any[] | undefined;
+            type: string;
+            items: {
+                default?: string | number | readonly number[] | readonly string[] | undefined;
+                type: string;
+            };
+            minItems: number;
+            maxItems: number;
+        };
+        gridMetricType: {
+            default: "KPPRA" | "spacing";
+        };
+        description: string;
+        required: string[];
+        dependencies: {
+            gridMetricType: {
+                oneOf: ({
+                    properties: {
+                        gridMetricType: {
+                            enum: string[];
+                        };
+                        gridMetricValue: {
+                            type: string;
+                            minimum: number;
+                            title: string;
+                            default: number;
+                            exclusiveMinimum?: undefined;
+                        };
+                        preferGridMetric: {
+                            type: string;
+                            title: string;
+                            default: boolean;
+                        };
+                    };
+                } | {
+                    properties: {
+                        gridMetricType: {
+                            enum: string[];
+                        };
+                        gridMetricValue: {
+                            type: string;
+                            exclusiveMinimum: number;
+                            title: string;
+                            default: number;
+                            minimum?: undefined;
+                        };
+                        preferGridMetric: {
+                            type: string;
+                            title: string;
+                            default: boolean;
+                        };
+                    };
+                })[];
+            };
+        };
+    };
+    /** Prefer persisted `data` — `setData` runs before React re-inits the provider on render. */
+    private get preferGridMetricForUi();
+    get uiSchema(): {
+        dimensions: {
+            readonly "ui:options": {
+                readonly addable: false;
+                readonly orderable: false;
+                readonly removable: false;
+            };
+            readonly items: {
+                readonly "ui:disabled": boolean;
+                readonly "ui:placeholder": "1";
+                readonly "ui:emptyValue": number;
+                readonly "ui:label": false;
+            };
+        };
+        shifts: {
+            readonly "ui:options": {
+                readonly addable: false;
+                readonly orderable: false;
+                readonly removable: false;
+            };
+            readonly items: {
+                readonly "ui:disabled": boolean;
+                readonly "ui:placeholder": "1";
+                readonly "ui:emptyValue": number;
+                readonly "ui:label": false;
+            };
+        };
+        gridMetricType: {
+            "ui:title": string;
+        };
+        gridMetricValue: {
+            "ui:disabled": boolean;
+            "ui:emptyValue": number;
+            "ui:placeholder": string;
+        };
+        preferGridMetric: {
+            "ui:emptyValue": boolean;
+            "ui:disabled": boolean;
+        };
+        reciprocalVectorRatios: {
+            "ui:title": string;
+            "ui:orderable": boolean;
+            "ui:removable": boolean;
+            "ui:readonly": boolean;
+            items: {
+                "ui:label": boolean;
+            };
+        };
+    };
+    private calculateDimensions;
+    private calculateGridMetric;
+    setData(data: Data): void;
+}
+export default PointsGridFormDataProvider;

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

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@mat3ra/code/dist/js/constants");
+const math_1 = require("@mat3ra/code/dist/js/math");
+const made_1 = require("@mat3ra/made");
+const MaterialContextMixin_1 = __importDefault(require("../../mixins/MaterialContextMixin"));
+const JSONSchemaFormDataProvider_1 = __importDefault(require("../base/JSONSchemaFormDataProvider"));
+const settings_1 = require("../settings");
+const vector = (defaultValue, isStringType = false) => {
+    const isArray = Array.isArray(defaultValue);
+    return {
+        type: "array",
+        items: {
+            type: isStringType ? "string" : "number",
+            ...(isArray ? {} : { default: defaultValue }),
+        },
+        minItems: 3,
+        maxItems: 3,
+        ...(isArray ? { default: defaultValue } : {}),
+    };
+};
+const defaultShift = 0;
+const defaultShifts = [defaultShift, defaultShift, defaultShift];
+class PointsGridFormDataProvider extends JSONSchemaFormDataProvider_1.default {
+    constructor(contextItem, externalContext, divisor) {
+        super(contextItem, externalContext);
+        this.domain = "important";
+        this.entityName = "unit";
+        this.jsonSchemaId = "context-providers-directory/points-grid-data-provider";
+        this.divisor = divisor;
+        this.initMaterialContextMixin(externalContext);
+        this.initInstanceFields();
+    }
+    initInstanceFields() {
+        var _a, _b, _c, _d, _e;
+        this.defaultMetric = {
+            type: "KPPRA",
+            value: this.getDefaultGridMetricValue("KPPRA"),
+        };
+        this.shifts = ((_a = this.data) === null || _a === void 0 ? void 0 : _a.shifts) || [...defaultShifts];
+        this.gridMetricType = ((_b = this.data) === null || _b === void 0 ? void 0 : _b.gridMetricType) || this.defaultMetric.type;
+        this.gridMetricValue = ((_c = this.data) === null || _c === void 0 ? void 0 : _c.gridMetricValue) || this.defaultMetric.value;
+        this.preferGridMetric = ((_d = this.data) === null || _d === void 0 ? void 0 : _d.preferGridMetric) || false;
+        this.reciprocalLattice = new made_1.Made.ReciprocalLattice(this.material.lattice);
+        this.defaultDimensions = this.calculateDimensions(this.defaultMetric.type, this.defaultMetric.value);
+        this.dimensions = ((_e = this.data) === null || _e === void 0 ? void 0 : _e.dimensions) || this.defaultDimensions;
+        this.reciprocalVectorRatios = this.reciprocalLattice.reciprocalVectorRatios.map((r) => Number(math_1.math.numberToPrecision(r, 3)));
+    }
+    // TODO: move default values to be extracted from ESSE
+    getDefaultGridMetricValue(metric) {
+        switch (metric) {
+            case "KPPRA":
+                if (!settings_1.globalSettings.defaultKPPRA) {
+                    throw new Error("globalSettings.defaultKPPRA is not set");
+                }
+                return Math.floor(settings_1.globalSettings.defaultKPPRA / this.divisor);
+            case "spacing":
+                return 0.3;
+            default:
+                console.error("Metric type not recognized!");
+                return -1;
+        }
+    }
+    resolveGridMetricValue(gridMetricType, gridMetricValue) {
+        const isValid = gridMetricType === "KPPRA" ? gridMetricValue >= 1 : gridMetricValue > 0;
+        return isValid ? gridMetricValue : this.getDefaultGridMetricValue(gridMetricType);
+    }
+    getData() {
+        const data = super.getData();
+        const { preferGridMetric, gridMetricType, gridMetricValue } = data;
+        if (!preferGridMetric || !gridMetricType) {
+            return data;
+        }
+        const effectiveValue = this.resolveGridMetricValue(gridMetricType, gridMetricValue);
+        return {
+            ...data,
+            gridMetricValue: effectiveValue,
+            dimensions: this.calculateDimensions(gridMetricType, effectiveValue),
+        };
+    }
+    getDefaultData() {
+        const defaultData = {
+            dimensions: this.defaultDimensions,
+            shifts: defaultShifts,
+            gridMetricType: this.defaultMetric.type,
+            gridMetricValue: this.defaultMetric.value,
+            preferGridMetric: false,
+            reciprocalVectorRatios: this.reciprocalVectorRatios,
+        };
+        if (this.material) {
+            const { gridMetricType, gridMetricValue } = this;
+            // if `data` is present and material is updated, prioritize `data` when `preferGridMetric` is not set
+            return this.preferGridMetric
+                ? {
+                    dimensions: this.calculateDimensions(gridMetricType, gridMetricValue),
+                    shifts: defaultShifts,
+                    gridMetricType,
+                    gridMetricValue,
+                }
+                : this.data || defaultData;
+        }
+        return defaultData;
+    }
+    get jsonSchemaPatchConfig() {
+        var _a;
+        const metricDescription = {
+            KPPRA: `${this.name.toUpperCase()}PPRA (${this.name}pt per reciprocal atom)`, // KPPRA or QPPRA
+            spacing: "grid spacing",
+        };
+        const gridMetricType = ((_a = this.data) === null || _a === void 0 ? void 0 : _a.gridMetricType) || this.defaultMetric.type;
+        return {
+            dimensions: vector(this.defaultDimensions, this.isUsingJinjaVariables),
+            shifts: vector(defaultShifts),
+            reciprocalVectorRatios: vector(this.reciprocalVectorRatios),
+            gridMetricType: { default: this.defaultMetric.type },
+            description: `3D grid with shifts. Default min value for ${metricDescription[gridMetricType]} is ${this.getDefaultGridMetricValue(gridMetricType)}.`,
+            required: ["dimensions", "shifts"],
+            dependencies: {
+                gridMetricType: {
+                    oneOf: [
+                        {
+                            properties: {
+                                gridMetricType: { enum: ["KPPRA"] },
+                                gridMetricValue: {
+                                    type: "integer",
+                                    minimum: 1,
+                                    title: "Value",
+                                    default: this.gridMetricValue,
+                                },
+                                preferGridMetric: {
+                                    type: "boolean",
+                                    title: "prefer KPPRA",
+                                    default: this.preferGridMetric,
+                                },
+                            },
+                        },
+                        {
+                            properties: {
+                                gridMetricType: { enum: ["spacing"] },
+                                gridMetricValue: {
+                                    type: "number",
+                                    exclusiveMinimum: 0,
+                                    title: "Value [1/Å]",
+                                    default: this.gridMetricValue,
+                                },
+                                preferGridMetric: {
+                                    type: "boolean",
+                                    title: "prefer spacing",
+                                    default: this.preferGridMetric,
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        };
+    }
+    /** Prefer persisted `data` — `setData` runs before React re-inits the provider on render. */
+    get preferGridMetricForUi() {
+        var _a, _b;
+        return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.preferGridMetric) !== null && _b !== void 0 ? _b : this.preferGridMetric;
+    }
+    get uiSchema() {
+        var _a, _b;
+        const preferGridMetric = this.preferGridMetricForUi;
+        const gridMetricValueForUi = (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.gridMetricValue) !== null && _b !== void 0 ? _b : this.gridMetricValue;
+        const arraySubStyle = (emptyValue = 0) => {
+            return {
+                "ui:options": {
+                    addable: false,
+                    orderable: false,
+                    removable: false,
+                },
+                items: {
+                    "ui:disabled": preferGridMetric,
+                    // TODO: extract the actual current values from context
+                    "ui:placeholder": "1",
+                    "ui:emptyValue": emptyValue,
+                    "ui:label": false,
+                },
+            };
+        };
+        return {
+            dimensions: arraySubStyle(1),
+            shifts: arraySubStyle(0),
+            gridMetricType: {
+                "ui:title": "Grid Metric",
+            },
+            gridMetricValue: {
+                "ui:disabled": !preferGridMetric,
+                "ui:emptyValue": gridMetricValueForUi,
+                "ui:placeholder": gridMetricValueForUi.toString(), // make string to prevent prop type error
+            },
+            preferGridMetric: {
+                "ui:emptyValue": true,
+                "ui:disabled": this.isUsingJinjaVariables,
+            },
+            reciprocalVectorRatios: {
+                "ui:title": "reciprocal vector ratios",
+                "ui:orderable": false,
+                "ui:removable": false,
+                "ui:readonly": true,
+                items: {
+                    "ui:label": false,
+                },
+            },
+        };
+    }
+    calculateDimensions(gridMetricType, gridMetricValue) {
+        switch (gridMetricType) {
+            case "KPPRA": {
+                const nAtoms = this.material ? this.material.Basis.nAtoms : 1;
+                return this.reciprocalLattice.getDimensionsFromPointsCount(gridMetricValue / nAtoms);
+            }
+            case "spacing":
+                return this.reciprocalLattice.getDimensionsFromSpacing(gridMetricValue, constants_1.Units.angstrom);
+            default:
+                return [1, 1, 1];
+        }
+    }
+    calculateGridMetric(gridMetricType, dimensions) {
+        switch (gridMetricType) {
+            case "KPPRA": {
+                const nAtoms = this.material ? this.material.Basis.nAtoms : 1;
+                return dimensions.reduce((a, b) => a * b) * nAtoms;
+            }
+            case "spacing":
+                return Number(this.reciprocalLattice
+                    .getSpacingFromDimensions(dimensions, constants_1.Units.angstrom)
+                    .toFixed(3));
+            default:
+                return 1;
+        }
+    }
+    setData(data) {
+        const { dimensions, gridMetricType, preferGridMetric, gridMetricValue } = data;
+        if (preferGridMetric !== undefined) {
+            this.preferGridMetric = preferGridMetric;
+        }
+        if (gridMetricType !== undefined) {
+            this.gridMetricType = gridMetricType;
+        }
+        if (preferGridMetric && gridMetricType) {
+            const effectiveValue = this.resolveGridMetricValue(gridMetricType, gridMetricValue);
+            this.gridMetricValue = effectiveValue;
+            return super.setData({
+                ...data,
+                gridMetricValue: effectiveValue,
+                dimensions: this.calculateDimensions(gridMetricType, effectiveValue),
+            });
+        }
+        if (!preferGridMetric && dimensions.every((d) => typeof d === "number")) {
+            const derivedMetric = this.calculateGridMetric(gridMetricType, dimensions);
+            this.gridMetricValue = derivedMetric;
+            return super.setData({
+                ...data,
+                gridMetricValue: derivedMetric,
+            });
+        }
+        if (gridMetricValue !== undefined) {
+            this.gridMetricValue = gridMetricValue;
+        }
+        return super.setData(data);
+    }
+}
+(0, MaterialContextMixin_1.default)(PointsGridFormDataProvider.prototype);
+exports.default = PointsGridFormDataProvider;

package/dist/js/context/providers/PointsGrid/QGridFormDataManager.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 = "qgrid";
+type Schema = GridContextItemSchema;
+export default class QGridFormDataManager extends PointsGridFormDataProvider<Name> {
+    readonly name: "qgrid";
+    readonly jsonSchema: JSONSchema7;
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): QGridFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsGrid/QGridFormDataManager.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 QGridFormDataManager extends PointsGridFormDataProvider_1.default {
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext, 5);
+        this.name = "qgrid";
+        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, "qgrid");
+        return new QGridFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = QGridFormDataManager;

package/dist/js/context/providers/PointsPath/ExplicitKPath2PIBAFormDataManager.d.ts

@@ -0,0 +1,10 @@
+import type { UnitContext } from "../base/ContextProvider";
+import PointsPathFormDataProvider, { type PointsPathFormDataProviderExternalContext } from "./PointsPathFormDataProvider";
+type Name = "explicitKPath2PIBA";
+export default class ExplicitKPath2PIBAFormDataManager extends PointsPathFormDataProvider<Name> {
+    readonly name: "explicitKPath2PIBA";
+    readonly is2PIBA = true;
+    readonly useExplicitPath = true;
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PointsPathFormDataProviderExternalContext): ExplicitKPath2PIBAFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsPath/ExplicitKPath2PIBAFormDataManager.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PointsPathFormDataProvider_1 = __importDefault(require("./PointsPathFormDataProvider"));
+class ExplicitKPath2PIBAFormDataManager extends PointsPathFormDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = "explicitKPath2PIBA";
+        this.is2PIBA = true;
+        this.useExplicitPath = true;
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "explicitKPath2PIBA");
+        return new ExplicitKPath2PIBAFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = ExplicitKPath2PIBAFormDataManager;

package/dist/js/context/providers/PointsPath/ExplicitKPathFormDataManager.d.ts

@@ -0,0 +1,9 @@
+import type { UnitContext } from "../base/ContextProvider";
+import PointsPathFormDataProvider, { type PointsPathFormDataProviderExternalContext } from "./PointsPathFormDataProvider";
+type Name = "explicitKPath";
+export default class ExplicitKPathFormDataManager extends PointsPathFormDataProvider<Name> {
+    readonly name: "explicitKPath";
+    readonly useExplicitPath = true;
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PointsPathFormDataProviderExternalContext): ExplicitKPathFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsPath/ExplicitKPathFormDataManager.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 });
+const PointsPathFormDataProvider_1 = __importDefault(require("./PointsPathFormDataProvider"));
+class ExplicitKPathFormDataManager extends PointsPathFormDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = "explicitKPath";
+        this.useExplicitPath = true;
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "explicitKPath");
+        return new ExplicitKPathFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = ExplicitKPathFormDataManager;

package/dist/js/context/providers/PointsPath/IPathFormDataManager.d.ts

@@ -0,0 +1,8 @@
+import type { UnitContext } from "../base/ContextProvider";
+import PointsPathFormDataProvider, { type PointsPathFormDataProviderExternalContext } from "./PointsPathFormDataProvider";
+type Name = "ipath";
+export default class IPathFormDataManager extends PointsPathFormDataProvider<Name> {
+    readonly name: "ipath";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PointsPathFormDataProviderExternalContext): IPathFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsPath/IPathFormDataManager.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PointsPathFormDataProvider_1 = __importDefault(require("./PointsPathFormDataProvider"));
+class IPathFormDataManager extends PointsPathFormDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = "ipath";
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "ipath");
+        return new IPathFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = IPathFormDataManager;

package/dist/js/context/providers/PointsPath/KPathFormDataManager.d.ts

@@ -0,0 +1,8 @@
+import type { UnitContext } from "../base/ContextProvider";
+import PointsPathFormDataProvider, { type PointsPathFormDataProviderExternalContext } from "./PointsPathFormDataProvider";
+type Name = "kpath";
+export default class KPathFormDataManager extends PointsPathFormDataProvider<Name> {
+    readonly name: "kpath";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PointsPathFormDataProviderExternalContext): KPathFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsPath/KPathFormDataManager.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PointsPathFormDataProvider_1 = __importDefault(require("./PointsPathFormDataProvider"));
+class KPathFormDataManager extends PointsPathFormDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = "kpath";
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "kpath");
+        return new KPathFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = KPathFormDataManager;

package/dist/js/context/providers/PointsPath/PointsPathFormDataProvider.d.ts

@@ -0,0 +1,40 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { JSONSchema } from "@mat3ra/esse/dist/js/esse/utils";
+import type { PathContextItemSchema, PointsPathDataProviderRenderingSchema, PointsPathDataProviderSchema } from "@mat3ra/esse/dist/js/types";
+import { type ApplicationContextMixin, type ApplicationExternalContext } from "../../mixins/ApplicationContextMixin";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../../mixins/MaterialContextMixin";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "../base/JSONSchemaDataProvider";
+export type PointsPathFormDataProviderData = PointsPathDataProviderSchema;
+export type PointsPathFormDataProviderRenderingData = PointsPathDataProviderRenderingSchema;
+export type PointsPathFormDataProviderExternalContext = JinjaExternalContext & MaterialExternalContext & ApplicationExternalContext;
+type Data = PointsPathFormDataProviderData;
+type RenderingData = PointsPathFormDataProviderRenderingData;
+type Schema = PathContextItemSchema;
+type ExternalContext = PointsPathFormDataProviderExternalContext;
+type Base = typeof JSONSchemaDataProvider<Schema, ExternalContext, RenderingData> & Constructor<MaterialContextMixin> & Constructor<ApplicationContextMixin>;
+declare const MixinsContextProvider_base: Base;
+declare abstract class MixinsContextProvider extends MixinsContextProvider_base {
+    constructor(contextItem: Partial<Schema>, externalContext: ExternalContext);
+}
+declare abstract class PointsPathFormDataProvider<N extends Schema["name"]> extends MixinsContextProvider {
+    abstract name: N;
+    readonly domain: "important";
+    readonly entityName: "unit";
+    private reciprocalLattice;
+    readonly useExplicitPath: boolean;
+    readonly is2PIBA: boolean;
+    constructor(config: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): Data;
+    updateMaterialHash(): void;
+    get jsonSchema(): JSONSchema;
+    readonly uiSchemaStyled: {
+        items: {
+            point: {};
+            steps: {};
+        };
+    };
+    protected patchForRendering(data: Data): RenderingData;
+    private addCoordinates;
+    private convertToExplicitPath;
+}
+export default PointsPathFormDataProvider;