@mat3ra/made 2026.8.7-0 → 2026.8.13-0

package/src/js/basis/basis.ts

@@ -1,13 +1,17 @@
 // @ts-ignore
 import { getElectronegativity, getElementAtomicRadius } from "@exabyte-io/periodic-table.js";
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { BasisSchema, Coordinate3DSchema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import {
+    BaseInMemoryEntitySchema,
+    BasisSchema,
+    Coordinate3DSchema,
+    Vector3DSchema,
+} from "@mat3ra/esse/dist/js/types";
 import { Utils } from "@mat3ra/utils";
 import { chain, toPairs, uniq, values } from "lodash";
 
 import { Cell } from "../cell/cell";
 import { ATOMIC_COORD_UNITS, HASH_TOLERANCE } from "../constants";
-
 import {
     defaultNonPeriodicMinimumLatticeSize,
     diatomicLatticePaddingFactor,
@@ -72,7 +76,11 @@ const DEFAULT_BASIS_CONFIG = {
     units: "crystal",
 };
 
-export class Basis extends InMemoryEntity implements BasisSchema {
+type BasisEntitySchema<S extends BasisConfig = BasisConfig> = S & BaseInMemoryEntitySchema;
+
+// Keep `{` on same line as `implements` to satisfy brace-style (conflicts with Prettier multi-line heritage).
+// prettier-ignore
+export class Basis<S extends BasisConfig = BasisConfig> extends InMemoryEntity<BasisEntitySchema<S>> implements BasisSchema {
     static defaultConfig: BasisSchema = DEFAULT_BASIS_CONFIG as BasisSchema;
 
     units: BasisSchema["units"];
@@ -122,8 +130,9 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         );
     }
 
-    constructor(config: BasisConfig = Basis.defaultConfig) {
-        super(config);
+    // NoInfer: keep default S (or an explicit type arg) instead of inferring S from the config literal.
+    constructor(config: NoInfer<S> = Basis.defaultConfig as NoInfer<S>) {
+        super(config as BasisEntitySchema<S>);
         const { elements, coordinates, units, labels } = config;
         this.cell = new Cell(config.cell);
         this.units = units || (ATOMIC_COORD_UNITS.crystal as BasisSchema["units"]);
@@ -156,20 +165,19 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         this._labels = Labels.fromObjects(labels || []);
     }
 
-    // TODO: figure out how to override toJSON in the parent class with generic classes
-    // @ts-ignore
-    toJSON(exclude: string[] = ["cell"]): BasisSchema {
+    toJSON(
+        exclude: (keyof BasisEntitySchema<S>)[] = ["cell"] as (keyof BasisEntitySchema<S>)[],
+    ): BasisEntitySchema<S> {
         return {
             ...super.toJSON(exclude),
             elements: this.elements,
             coordinates: this.coordinates,
             units: this.units,
             ...(this.labels?.length ? { labels: this.labels } : {}),
-        };
+        } as BasisEntitySchema<S>;
     }
 
-    // @ts-ignore
-    override clone(): Basis {
+    override clone(): this {
         const instance = super.clone();
         instance.cell = this.cell.clone();
         return instance;
@@ -205,16 +213,18 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         return this.units === ATOMIC_COORD_UNITS.crystal;
     }
 
-    toCartesian(): void {
-        if (this.isInCartesianUnits) return;
+    toCartesian() {
+        if (this.isInCartesianUnits) return this;
         this._coordinates.mapArrayInPlace((point) => this.cell.convertPointToCartesian(point));
         this.units = ATOMIC_COORD_UNITS.cartesian as BasisSchema["units"];
+        return this;
     }
 
-    toCrystal(): void {
-        if (this.isInCrystalUnits) return;
+    toCrystal() {
+        if (this.isInCrystalUnits) return this;
         this._coordinates.mapArrayInPlace((point) => this.cell.convertPointToCrystal(point));
         this.units = ATOMIC_COORD_UNITS.crystal as BasisSchema["units"];
+        return this;
     }
 
     getElementByIndex(idx: number): AtomicElementValue {
@@ -393,7 +403,9 @@ export class Basis extends InMemoryEntity implements BasisSchema {
             const element = entry[0];
             const coordinate = entry[1];
             const atomicLabel = entry[2];
-            const toleratedCoordinate = coordinate.map((x) => Utils.math.roundCustom(x, HASH_TOLERANCE));
+            const toleratedCoordinate = coordinate.map((x) =>
+                Utils.math.roundCustom(x, HASH_TOLERANCE),
+            );
             return `${element}${atomicLabel} ${toleratedCoordinate.join()}`;
         });
         return `${standardRep.sort().join(";")};`;
@@ -416,7 +428,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
 
     /* Returns array of atomic labels E.g., ["1", "2", "", ""] */
     get atomicLabelsArray(): string[] {
-        const labelsArray = Array.from({ length: this.elements.length }, (_) => "");
+        const labelsArray = Array.from({ length: this.elements.length }, () => "");
         // https://dev.to/maafaishal/benchmarking-for-while-forof-and-arrayforeach-using-performancenow-1jjg
         if (this.labels?.length) {
             for (let i = 0; i < this.labels.length; i++) {
@@ -461,7 +473,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
      * @summary Returns true if bases are equal, otherwise - false.
      * @param anotherBasisClsInstance {Basis} Another Basis.
      */
-    isEqualTo(anotherBasisClsInstance: Basis): boolean {
+    isEqualTo(anotherBasisClsInstance: { hashString: string }): boolean {
         return this.hashString === anotherBasisClsInstance.hashString;
     }
 
@@ -469,7 +481,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
      * @summary Returns true if basis cells are equal, otherwise - false.
      * @param anotherBasisClsInstance {Basis} Another Basis.
      */
-    hasEquivalentCellTo(anotherBasisClsInstance: Basis): boolean {
+    hasEquivalentCellTo(anotherBasisClsInstance: { cell: Cell }): boolean {
         return !this.cell.vectorArrays
             .map((vector, idx) => {
                 return Utils.math.vEqualWithTolerance(
@@ -576,12 +588,13 @@ export class Basis extends InMemoryEntity implements BasisSchema {
                         this._coordinates.getElementValueByIndex(i) as Coordinate3DSchema,
                         this._coordinates.getElementValueByIndex(j) as Coordinate3DSchema,
                     );
-                    if (!distance) continue;
-                    if (extremum === "max" && distance > resultDistance) {
-                        resultDistance = distance;
-                    }
-                    if (extremum === "min" && distance < resultDistance) {
-                        resultDistance = distance;
+                    if (distance) {
+                        if (extremum === "max" && distance > resultDistance) {
+                            resultDistance = distance;
+                        }
+                        if (extremum === "min" && distance < resultDistance) {
+                            resultDistance = distance;
+                        }
                     }
                 }
             }

package/src/js/basis/constrained_basis.ts

@@ -1,14 +1,16 @@
-import { AtomicConstraintsSchema } from "@mat3ra/esse/dist/js/types";
+import { AtomicConstraintsSchema, BasisConstrainedSchema } from "@mat3ra/esse/dist/js/types";
 
+import { Cell } from "../cell/cell";
 import { AtomicConstraints, AtomicConstraintValue, Constraint } from "../constraints/constraints";
-import { Basis, BasisConfig, ElementsAndCoordinatesConfig } from "./basis";
+import { Basis, ElementsAndCoordinatesConfig } from "./basis";
 import { AtomicCoordinateValue, Coordinate } from "./coordinates";
 import { AtomicElementValue } from "./elements";
 import { ElementWithLabel } from "./helpers";
 import { AtomicLabelValue } from "./labels";
 
-export interface ConstrainedBasisConfig extends BasisConfig {
-    constraints: AtomicConstraintsSchema;
+export interface ConstrainedBasisConfig extends BasisConstrainedSchema {
+    cell?: Cell;
+    isEmpty?: boolean;
 }
 
 export interface ElementsCoordinatesAndConstraintsConfig extends ElementsAndCoordinatesConfig {
@@ -19,13 +21,12 @@ export interface ElementsCoordinatesAndConstraintsConfig extends ElementsAndCoor
  * @summary Extension of the Basis class able to deal with atomic constraints.
  * @extends Basis
  */
-export class ConstrainedBasis extends Basis {
-    _constraints: AtomicConstraints;
+export class ConstrainedBasis extends Basis<ConstrainedBasisConfig> {
+    private _constraints: AtomicConstraints;
 
     constructor(config: ConstrainedBasisConfig) {
         super(config);
-        const { constraints } = config;
-        this._constraints = AtomicConstraints.fromObjects(constraints || []); // `constraints` is an Array with ids
+        this._constraints = AtomicConstraints.fromObjects(config.constraints ?? []); // `constraints` is an Array with ids
     }
 
     static fromElementsCoordinatesAndConstraints(
@@ -51,9 +52,9 @@ export class ConstrainedBasis extends Basis {
         return AtomicConstraints.fromObjects(this.constraints);
     }
 
-    override toJSON(): ConstrainedBasisConfig {
+    override toJSON(exclude: (keyof ConstrainedBasisConfig)[] = ["cell"]): ConstrainedBasisConfig {
         return {
-            ...super.toJSON(),
+            ...super.toJSON(exclude as (keyof ConstrainedBasisConfig)[]),
             constraints: this.constraints,
         };
     }
@@ -75,7 +76,7 @@ export class ConstrainedBasis extends Basis {
         AtomicCoordinateValue,
         AtomicConstraintValue,
     ][] {
-        return this._elements.values.map((element: any, idx: number) => {
+        return this._elements.values.map((element: AtomicElementValue, idx: number) => {
             const coordinate = this.getCoordinateValueByIndex(idx);
             const constraint = this.getConstraintByIndex(idx);
             const label = this.atomicLabelsArray[idx];

package/src/js/basis/coordinates.ts

@@ -8,7 +8,6 @@ import {
 import { Utils } from "@mat3ra/utils";
 import { sprintf } from "underscore.string";
 
-
 export type AtomicCoordinateValue = AtomicCoordinateSchema["value"];
 
 type AxisType = "x" | "y" | "z";

package/src/js/cell/cell.ts

@@ -9,7 +9,6 @@ import { Utils } from "@mat3ra/utils";
 
 import constants from "../constants";
 
-
 const MATRIX = Utils.math.matrix;
 const MULT = Utils.math.multiply;
 const INV = Utils.math.inv;

package/src/js/generated/MaterialSchemaMixin.ts

@@ -0,0 +1,79 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type {
+    BaseInMemoryEntitySchema,
+    MaterialPropertiesSchema,
+} from "@mat3ra/esse/dist/js/types";
+
+export type MaterialSchemaMixin = MaterialPropertiesSchema;
+
+export type MaterialInMemoryEntity = InMemoryEntity<BaseInMemoryEntitySchema & MaterialSchemaMixin>;
+
+export function materialSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & MaterialSchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity<MaterialSchemaMixin> & MaterialSchemaMixin = {
+        get formula() {
+            return this.prop("formula");
+        },
+        set formula(value: MaterialPropertiesSchema["formula"]) {
+            this.setProp("formula", value);
+        },
+        get unitCellFormula() {
+            return this.prop("unitCellFormula");
+        },
+        set unitCellFormula(value: MaterialPropertiesSchema["unitCellFormula"]) {
+            this.setProp("unitCellFormula", value);
+        },
+        get basis() {
+            return this.requiredProp("basis");
+        },
+        set basis(value: MaterialPropertiesSchema["basis"]) {
+            this.setProp("basis", value);
+        },
+        get lattice() {
+            return this.requiredProp("lattice");
+        },
+        set lattice(value: MaterialPropertiesSchema["lattice"]) {
+            this.setProp("lattice", value);
+        },
+        get derivedProperties() {
+            return this.prop("derivedProperties");
+        },
+        set derivedProperties(value: MaterialPropertiesSchema["derivedProperties"]) {
+            this.setProp("derivedProperties", value);
+        },
+        get external() {
+            return this.prop("external");
+        },
+        set external(value: MaterialPropertiesSchema["external"]) {
+            this.setProp("external", value);
+        },
+        get src() {
+            return this.prop("src");
+        },
+        set src(value: MaterialPropertiesSchema["src"]) {
+            this.setProp("src", value);
+        },
+        get icsdId() {
+            return this.prop("icsdId");
+        },
+        set icsdId(value: MaterialPropertiesSchema["icsdId"]) {
+            this.setProp("icsdId", value);
+        },
+        get isNonPeriodic() {
+            return this.prop("isNonPeriodic");
+        },
+        set isNonPeriodic(value: MaterialPropertiesSchema["isNonPeriodic"]) {
+            this.setProp("isNonPeriodic", value);
+        },
+        get consistencyChecks() {
+            return this.prop("consistencyChecks");
+        },
+        set consistencyChecks(value: MaterialPropertiesSchema["consistencyChecks"]) {
+            this.setProp("consistencyChecks", value);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/lattice/lattice.ts

@@ -1,5 +1,6 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import {
+    BaseInMemoryEntitySchema,
     Coordinate3DSchema,
     LatticeSchema,
     LatticeTypeEnum,
@@ -30,7 +31,9 @@ export class LatticeVectors extends Cell implements LatticeVectorsSchema {}
 
 export type { LatticeVectorsSchema };
 
-export class Lattice extends InMemoryEntity implements LatticeSchema {
+type LatticeEntitySchema = LatticeSchema & BaseInMemoryEntitySchema;
+
+export class Lattice extends InMemoryEntity<LatticeEntitySchema> implements LatticeSchema {
     static defaultConfig: LatticeSchema = {
         a: 1,
         b: 1,
@@ -296,11 +299,10 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
         return object;
     }
 
-    // @ts-ignore
-    toJSON(exclude?: string[]): LatticeSchema {
+    toJSON(exclude: (keyof LatticeSchema)[] = []): LatticeSchema {
         return {
             ...super.toJSON(exclude),
             vectors: this.vectors.toJSON(),
-        } as LatticeSchema;
+        };
     }
 }

package/src/js/lattice/reciprocal/lattice_reciprocal.ts

@@ -7,7 +7,6 @@ import { Lattice } from "../lattice";
 import { paths } from "./paths";
 import { symmetryPoints } from "./symmetry_points";
 
-
 export type KPointCoordinates = number[];
 export type KPointPath = Array<{
     point: string;
@@ -47,9 +46,18 @@ export class ReciprocalLattice extends Lattice {
                 Utils.math.cross(vectors_[1], vectors_[2]),
             ) as unknown as number) / a;
         return [
-            Utils.math.multiply(Utils.math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
-            Utils.math.multiply(Utils.math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
-            Utils.math.multiply(Utils.math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(
+                Utils.math.cross(vectors_[1], vectors_[2]),
+                1 / divider,
+            ) as Vector3DSchema,
+            Utils.math.multiply(
+                Utils.math.cross(vectors_[2], vectors_[0]),
+                1 / divider,
+            ) as Vector3DSchema,
+            Utils.math.multiply(
+                Utils.math.cross(vectors_[0], vectors_[1]),
+                1 / divider,
+            ) as Vector3DSchema,
         ];
     }
 
@@ -57,7 +65,9 @@ export class ReciprocalLattice extends Lattice {
      * Norms of reciprocal vectors.
      */
     get reciprocalVectorNorms(): Vector3DSchema {
-        return this.reciprocalVectors.map((vec) => Utils.math.norm(vec) as number) as Vector3DSchema;
+        return this.reciprocalVectors.map(
+            (vec) => Utils.math.norm(vec) as number,
+        ) as Vector3DSchema;
     }
 
     /**
@@ -167,7 +177,10 @@ export class ReciprocalLattice extends Lattice {
     getDimensionsFromSpacing(spacing: number, units: string = ATOMIC_COORD_UNITS.cartesian) {
         const factor: number = this.conversionTable[units][ATOMIC_COORD_UNITS.cartesian] || 1;
         return this.reciprocalVectorNorms.map((norm: number) => {
-            return Utils.math.max(1, Utils.math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
+            return Utils.math.max(
+                1,
+                Utils.math.ceil(lodash.round(norm / (spacing * factor), 4)),
+            ) as number;
         }) as Vector3DSchema;
     }
 

package/src/js/made.ts

@@ -11,7 +11,7 @@ import {
 import { DEFAULT_LATTICE_UNITS, LATTICE_TYPE_CONFIGS } from "./lattice/lattice_types";
 import { ReciprocalLattice } from "./lattice/reciprocal/lattice_reciprocal";
 import { UnitCell } from "./lattice/unit_cell";
-import { defaultMaterialConfig, Material } from "./material";
+import Material, { defaultMaterialConfig } from "./Material";
 import parsers from "./parsers/parsers";
 import tools from "./tools/index";
 

package/src/js/parsers/espresso.ts

@@ -1,4 +1,4 @@
-import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
+import { MaterialEnhancedSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
 import { map } from "lodash";
 import s from "underscore.string";
 
@@ -7,9 +7,8 @@ import xyz from "./xyz";
 
 /**
  * Construct textual representation of a materialOrConfig according to Quantum ESPRESSO pw.x input format.
- * @param materialOrConfig - material class instance or its config object
  */
-function toEspressoFormat(materialOrConfig: MaterialSchema): string {
+function toEspressoFormat(materialOrConfig: MaterialSchema | MaterialEnhancedSchema): string {
     const l = new Lattice(materialOrConfig.lattice);
     const vectors = l.vectorArrays;
     const vectorsAsString = map(vectors, (v) => {

package/src/js/parsers/native_format_parsers.ts

@@ -1,3 +1,4 @@
+import type { MaterialConfig } from "../Material";
 import Poscar from "./poscar";
 
 const NATIVE_FORMAT = {
@@ -7,13 +8,13 @@ const NATIVE_FORMAT = {
     PWX: "pwx",
     XYZ: "xyz",
     UNKNOWN: "unknown",
-};
+} as const;
 
 /**
  * @summary Detects the format of the input string
- * @throws {Error} - If the input string is unknown format
- * @param {string} text -  input string to detect format
- * @returns {NATIVE_FORMAT} - Format of the input string
+ * @throws If the input string is unknown format
+ * @param text input string to detect format
+ * @returns Format of the input string
  */
 function detectFormat(text: string) {
     const jsonRegex = /^\s*\{/;
@@ -25,11 +26,11 @@ function detectFormat(text: string) {
 
 /**
  * @summary Function to handle conversion from native formats
- * @param {String} text - input string to detect format and convert
- * @throws {Error} - If the input string is of unknown format
- * @return {Object} - Material config
+ * @param text - input string to detect format and convert
+ * @throws If the input string is of unknown format
+ * @return Material config
  */
-function convertFromNativeFormat(text: string) {
+function convertFromNativeFormat(text: string): MaterialConfig {
     const format = detectFormat(text);
 
     switch (format) {

package/src/js/parsers/poscar.ts

@@ -1,6 +1,7 @@
 import {
     BasisSchema,
     Coordinate3DSchema,
+    MaterialEnhancedSchema,
     MaterialSchema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
@@ -14,7 +15,7 @@ import { Cell } from "../cell/cell";
 import { ATOMIC_COORD_UNITS } from "../constants";
 import { AtomicConstraintValue } from "../constraints/constraints";
 import { Lattice } from "../lattice/lattice";
-
+import type { MaterialConfig } from "../Material";
 
 const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, Utils.math.precise(x));
 const _latticeVectorsToString = (vectors: Vector3DSchema[]) =>
@@ -24,15 +25,20 @@ const atomicConstraintsCharFromBool = (bool: boolean): string => (bool ? "T" : "
 /**
  * Obtain a textual representation of a material in POSCAR format.
  * @param materialOrConfig - material class instance or config object.
- * @param omitConstraints - whether to discard constraints passed with material.
+ * @param omitConstraints - whether to discard constraints when serializing.
  */
-function toPoscar(materialOrConfig: MaterialSchema, omitConstraints = false): string {
+function toPoscar(
+    materialOrConfig: MaterialSchema | MaterialEnhancedSchema,
+    omitConstraints = false,
+): string {
     const lattice = new Lattice(materialOrConfig.lattice);
     const vectorsAsString = _latticeVectorsToString(lattice.vectorArrays);
-    // @ts-ignore
+    const constraints =
+        "constraints" in materialOrConfig.basis ? materialOrConfig.basis.constraints : [];
     const basis = new ConstrainedBasis({
         ...materialOrConfig.basis,
         cell: Cell.fromVectorsArray(lattice.vectorArrays),
+        constraints: omitConstraints ? [] : constraints,
     });
     const BasisLines: string[] = [];
     let addSelectiveDynamics = false;
@@ -78,7 +84,7 @@ export function atomsCount(poscarFileContent: string): number {
  * @param fileContent - POSCAR file content.
  * @return Material config.
  */
-function fromPoscar(fileContent: string): object {
+function fromPoscar(fileContent: string): MaterialConfig {
     const cleanContent = Utils.str.removeCommentsFromSourceCode(fileContent, "fortran");
     const lines = cleanContent.split("\n");
 
@@ -151,7 +157,7 @@ function fromPoscar(fileContent: string): object {
         constraints,
     });
 
-    const materialConfig = {
+    const materialConfig: MaterialConfig = {
         lattice: lattice.toJSON(),
         basis: basis.toJSON(),
         name: comment,

package/src/js/parsers/xyz.ts

@@ -1,4 +1,4 @@
-import { MaterialSchema } from "@mat3ra/esse/dist/js/types";
+import { MaterialEnhancedSchema, MaterialSchema } from "@mat3ra/esse/dist/js/types";
 import { isEmpty, isNaN, map } from "lodash";
 import s from "underscore.string";
 
@@ -161,16 +161,19 @@ function fromBasis(basisClsInstance: ConstrainedBasis, coordinatePrintFormat: st
 
 /**
  * Create XYZ from Material class instance (or its JSON config).
- * @param materialOrConfig Material.
- * @param fractional Coordinate units as fractional.
- * @return Class Instance
+ * Prefer fromBasis when you already have a ConstrainedBasis instance.
  */
-function fromMaterial(materialOrConfig: MaterialSchema, fractional = false): string {
+function fromMaterial(
+    materialOrConfig: MaterialSchema | MaterialEnhancedSchema,
+    fractional = false,
+): string {
     const lattice = new Lattice(materialOrConfig.lattice);
-    // @ts-ignore
+    const constraints =
+        "constraints" in materialOrConfig.basis ? materialOrConfig.basis.constraints : [];
     const basis = new ConstrainedBasis({
         ...materialOrConfig.basis,
         cell: Cell.fromVectorsArray(lattice.vectorArrays),
+        constraints,
     });
     if (fractional) {
         basis.toCrystal();

package/src/js/parsers/xyz_combinatorial_basis.ts

@@ -8,7 +8,6 @@ import { AtomicCoordinateValue } from "../basis/coordinates";
 import { AtomicElementValue } from "../basis/elements";
 import { Cell } from "../cell/cell";
 
-
 /**
  * @summary Combinatorial XYZ basis class and related. Create and get all information about basis and elements in it.
  * Constructor accepts string in extended XYZ format. Extended XYZ format is as follows:
@@ -225,7 +224,11 @@ export class CombinatorialBasis {
             dimensions.push(itemsSet);
         });
         // @ts-ignore // We're multiplying objects with math, not numbers. No type casting will help.
-        const basisSet = Utils.math.cartesianProduct.apply(null, dimensions) as ElementWithCoordinate[][];
+        const basisSet = Utils.math.cartesianProduct.apply(
+            null,
+            // @ts-ignore
+            dimensions,
+        ) as ElementWithCoordinate[][];
         return basisSet.map((basis: ElementWithCoordinate[]) =>
             basis.filter((entry) => entry.element !== VACANCY_CHARACTER),
         );

package/src/js/tools/basis.ts

@@ -5,7 +5,6 @@ import { chunk, flatten } from "lodash";
 import { Basis } from "../basis/basis";
 import { AtomicCoordinateValue, Coordinate } from "../basis/coordinates";
 
-
 const ADD = Utils.math.add;
 const MULT = Utils.math.multiply;
 

package/src/js/tools/cell.ts

@@ -3,7 +3,6 @@ import { Utils } from "@mat3ra/utils";
 
 import { Cell } from "../cell/cell";
 
-
 /**
  * Returns the list of points on the original lattice contained in the supercell in fractional coordinates.
  * Source: https://pymatgen.org/_modules/pymatgen/util/coord.html

package/src/js/tools/material.ts

@@ -3,8 +3,7 @@ import { Utils } from "@mat3ra/utils";
 
 import { ATOMIC_COORD_UNITS } from "../constants";
 import { Lattice } from "../lattice/lattice";
-import { Material } from "../material";
-
+import Material from "../Material";
 
 /**
  * Scales one lattice vector for the given material
@@ -18,9 +17,9 @@ function scaleOneLatticeVector(material: Material, key: "a" | "b" | "c" = "a", f
     if (lattice.vectors === undefined) {
         throw new Error("Lattice vectors are undefined");
     }
-    lattice.vectors[key] = lattice.vectors![key].map((v) => v * factor) as Vector3DSchema;
+    lattice.vectors[key] = lattice.vectors[key].map((v) => v * factor) as Vector3DSchema;
 
-    material.lattice = Lattice.fromVectors(lattice.vectors).toJSON();
+    material.setLattice(Lattice.fromVectors(lattice.vectors).toJSON());
 }
 
 /**
@@ -29,10 +28,12 @@ function scaleOneLatticeVector(material: Material, key: "a" | "b" | "c" = "a", f
  * @param material {Material}
  */
 function scaleLatticeToMakeNonPeriodic(material: Material) {
-    material.lattice = Lattice.fromConfigPartial({
-        a: material.Basis.getMinimumLatticeSize(),
-        type: "CUB",
-    } as LatticeSchema).toJSON();
+    material.setLattice(
+        Lattice.fromConfigPartial({
+            a: material.getBasis().getMinimumLatticeSize(),
+            type: "CUB",
+        } as LatticeSchema).toJSON(),
+    );
 }
 
 /**
@@ -41,13 +42,14 @@ function scaleLatticeToMakeNonPeriodic(material: Material) {
  * @param material {Material}
  * */
 function translateAtomsToCenter(material: Material) {
-    const originalUnits = material.Basis.units;
+    const basis = material.getBasis();
+    const originalUnits = basis.units;
     material.toCartesian();
-    const updatedBasis = material.Basis;
+    const updatedBasis = basis.toCartesian();
     const centerOfCoordinates = updatedBasis.centerOfCoordinatesPoint;
     const centerOfLattice = Utils.math.multiply(
         0.5,
-        material.Lattice.vectorArrays.reduce((a, b) => Utils.math.add(a, b) as Vector3DSchema),
+        material.getLattice().vectorArrays.reduce((a, b) => Utils.math.add(a, b) as Vector3DSchema),
     );
     const translationVector = Utils.math.subtract(centerOfLattice, centerOfCoordinates);
     updatedBasis.translateByVector(translationVector as Vector3DSchema);