@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/tests/js/basis/basis.ts

@@ -1,247 +0,0 @@
-import "../setup";
-
-import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { Basis } from "../../../src/js/basis/basis";
-import Material from "../../../src/js/Material";
-import {
-    AsGeBasis,
-    C2H4,
-    C2H4Translated,
-    FeLiSiBasis,
-    LiFeSiBasis,
-    LiFeSiBasisLabels,
-    Na,
-    Na4Cl4,
-    Na4Cl4Cartesian,
-} from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-const TOLERANCE = 1e-4;
-
-describe("Basis", () => {
-    it("should return true if basises are equal", () => {
-        const basis1 = new Basis(FeLiSiBasis);
-        const basis2 = new Basis(LiFeSiBasis);
-        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
-    });
-
-    it("should return true when basis is compared to its clone", () => {
-        const basis1 = new Material(Na4Cl4).getBasis();
-        const basis2 = basis1.clone();
-        expect(basis1.isEqualTo(basis2)).to.be.equal(true);
-        expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
-    });
-
-    it("should return jsonified basis", () => {
-        const basis = new Material(Na4Cl4).getBasis();
-        expect(basis.toJSON()).to.be.deep.almost.equal(Na4Cl4.basis);
-    });
-
-    it("should return true if cells are equal", () => {
-        const basis1 = new Material(Na4Cl4).getBasis();
-        const basis2 = new Material(Na4Cl4Cartesian).getBasis();
-        expect(basis1.hasEquivalentCellTo(basis2)).to.be.equal(true);
-    });
-
-    /**
-     * Elements
-     */
-
-    it("should return Na4Cl4 as unitCellFormula", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.unitCellFormula).to.be.equal("Na4Cl4");
-    });
-
-    it("should return NaCl as formula", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.formula).to.be.equal("NaCl");
-    });
-
-    it("should return elements", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.elements).to.be.deep.almost.equal(Na4Cl4.basis.elements);
-    });
-
-    it("should return unique elements", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.uniqueElements).to.be.deep.equal(["Na", "Cl"]);
-    });
-
-    it("should return elements count", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.elementCounts).to.be.deep.equal([
-            {
-                value: "Na",
-                count: 4,
-            },
-            {
-                value: "Cl",
-                count: 4,
-            },
-        ]);
-    });
-
-    it("should set elements", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        basis.elements = AsGeBasis.elements;
-        expect(basis.elements).to.be.deep.equal(AsGeBasis.elements);
-    });
-
-    /**
-     * Coordinates
-     */
-
-    it("should return coordinates", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.coordinates).to.be.deep.almost.equal(Na4Cl4.basis.coordinates);
-    });
-
-    it("should set coordinates", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        basis.coordinates = AsGeBasis.coordinates;
-        expect(basis.coordinates).to.be.deep.almost.equal(AsGeBasis.coordinates);
-    });
-
-    it("should return coordinate by id", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.getCoordinateValueById(3)).to.be.deep.equal([0.5, 0.5, 0]);
-    });
-
-    /**
-     * Units
-     */
-
-    it("should return true if basis is in crystal units", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.isInCrystalUnits).to.be.equal(true);
-    });
-
-    it("should convert crystal to cartesian", () => {
-        const basis = new Material(Na4Cl4).getBasis();
-        basis.toCartesian();
-        expect(basis.isInCartesianUnits).to.be.equal(true);
-        expect(basis.coordinates).to.be.deep.almost.equal(Na4Cl4Cartesian.basis.coordinates);
-    });
-
-    /**
-     * Labels
-     */
-
-    it("should return elements with labels", () => {
-        const basis = new Basis(LiFeSiBasisLabels);
-        const elementsWithLabels = basis.elementsWithLabelsArray;
-        const expectedElementsWithLabels = ["Li0", "Fe1", "Si2"];
-        expect(elementsWithLabels).to.be.deep.equal(expectedElementsWithLabels);
-    });
-
-    /**
-     * Atoms
-     */
-
-    it("should add a new atom", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        basis.addAtom({
-            element: "Ge",
-            coordinate: [0, 0.25, 0.25],
-        });
-        expect(basis.elements).to.be.deep.equal([
-            ...Na4Cl4.basis.elements,
-            {
-                id: 8,
-                value: "Ge",
-            },
-        ]);
-        expect(basis.coordinates).to.be.deep.almost.equal([
-            ...Na4Cl4.basis.coordinates,
-            {
-                id: 8,
-                value: [0, 0.25, 0.25],
-            },
-        ]);
-    });
-
-    it("should remove an atom", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        basis.removeAtom({
-            id: 3,
-            element: "Na",
-            coordinate: [0.5, 0.5, 0],
-        });
-        expect(basis.elements.length).to.be.equal(7);
-        expect(basis.coordinates.length).to.be.equal(7);
-    });
-
-    it("should return number of atoms", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        expect(basis.nAtoms).to.be.equal(8);
-    });
-
-    /**
-     * Hash
-     */
-
-    it("should return the string", () => {
-        const basis = new Basis(Na4Cl4.basis);
-        const string =
-            "Cl 0,0,0.5;Cl 0,0.5,0;Cl 0.5,0,0;Cl 0.5,0.5,0.5;Na 0,0,0;Na 0,0.5,0.5;Na 0.5,0,0.5;Na 0.5,0.5,0;";
-        expect(basis.getAsSortedString()).to.be.equal(string);
-    });
-
-    /**
-     * Representation
-     */
-
-    it("should return standard representation", () => {
-        const basis = new Material(Na4Cl4Cartesian).getBasis();
-        assertDeepAlmostEqual(basis.standardRepresentation, Na4Cl4.basis, ["constraints"]);
-    });
-
-    /**
-     * Minimum lattice size generated for a molecule with more than one atom.
-     * The minimumLatticeSize is the maximum pairwise distance between two atoms
-     * of the structure, C2H4 in this case.
-     */
-    it("should return minimum lattice size for a molecule", () => {
-        const basis = new Basis(C2H4.basis);
-        const minimumLatticeSize = 3.1622776601683795;
-        const latticeSize = basis.getMinimumLatticeSize();
-        expect(latticeSize).to.be.almost(minimumLatticeSize, TOLERANCE);
-    });
-
-    /**
-     * Minimum lattice size generated for a structure made up of a single atom.
-     * The minimumLatticeSize is the atomic radii of the atom, Na in this case, in units of angstroms.
-     */
-    it("should return minimum lattice size for an atom", () => {
-        const basis = new Basis(Na.basis);
-        const minimumLatticeSize = 3;
-        const latticeSize = basis.getMinimumLatticeSize();
-        expect(latticeSize).to.be.equal(minimumLatticeSize);
-    });
-
-    //* * Pairwise Distance */
-    it("should return max distance", () => {
-        const basis = new Basis(C2H4.basis);
-        const maxDistance = 1.5811388300841898;
-        expect(basis.maxPairwiseDistance).to.be.almost(maxDistance, TOLERANCE);
-    });
-
-    //* * Center of Coordinates */
-    it("should return center of coordinates", () => {
-        const basis = new Basis(C2H4.basis);
-        const centerOfCoordinatesArray = [0.3333, -0.0417, 0.0917];
-        const basisCenterOfCoordinatesPoint = basis.centerOfCoordinatesPoint;
-        assertDeepAlmostEqual(basisCenterOfCoordinatesPoint, centerOfCoordinatesArray);
-    });
-
-    //* * Translation by Vector */
-    it("should return the updated basis coordinates", () => {
-        const basis = new Basis(C2H4.basis);
-        const translationVector = [1.6917, 1.9667, 2] as Vector3DSchema;
-        basis.translateByVector(translationVector);
-        assertDeepAlmostEqual(basis.coordinates, C2H4Translated.basis.coordinates);
-    });
-});

package/tests/js/cell/cell.ts

@@ -1,182 +0,0 @@
-import { Coordinate3DSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { Cell } from "../../../src/js/cell/cell";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-const VECTORS: Matrix3X3Schema = [
-    [1.0, 0.0, 0.0],
-    [0.0, 2.0, 0.0],
-    [0.0, 0.0, 3.0],
-];
-
-const CELL_JSON = {
-    a: VECTORS[0],
-    b: VECTORS[1],
-    c: VECTORS[2],
-    alat: 1,
-    units: "angstrom",
-};
-
-const POINT_IN_CELL_CRYSTAL: Coordinate3DSchema = [0.5, 0.5, 0.5];
-const POINT_OUTSIDE_CELL_CRYSTAL: Coordinate3DSchema = [1.1, 1.1, 1.1];
-const POINT_IN_CELL_CARTESIAN: Coordinate3DSchema = [0.5, 1.0, 1.5];
-
-const POINT_IN_CELL: Coordinate3DSchema = [0.5, 0.5, 0.5];
-const POINT_OUTSIDE_CELL: Coordinate3DSchema = [1.5, 1.5, 1.5];
-
-// This is in crystal coordinates, but since VECTORS[0] is [1,0,0], it's the same in cartesian
-const POINT_IN_CELL_TOLERANCE = 0.01;
-const POINT_IN_CELL_WITH_TOLERANCE_0_1: Coordinate3DSchema = [0.99, 0.5, 0.5];
-const POINT_OUTSIDE_CELL_WITH_TOLERANCE_0_1: Coordinate3DSchema = [1.01, 0.5, 0.5];
-const POINT_OUTSIDE_CELL_WITH_TOLERANCE_0_1_ALT: Coordinate3DSchema = [0.999, 0.5, 0.5];
-
-const VECTORS_VOLUME = 6.0;
-
-const VECTORS_EQUAL_UP_TO_PRECISION_4: Matrix3X3Schema = [
-    [1.00001, 0.0, 0.0],
-    [0.0, 2.00001, 0.0],
-    [0.0, 0.0, 3.00001],
-];
-
-const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME = 6.000110000600001;
-const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4 = 6.0001;
-const VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5 = 6.00011;
-
-const SCALING_MATRIX: Matrix3X3Schema = [
-    [2, 0, 0],
-    [0, 2, 0],
-    [0, 0, 2],
-];
-
-const VECTORS_SCALED_BY_MATRIX = [
-    [2.0, 0.0, 0.0],
-    [0.0, 4.0, 0.0],
-    [0.0, 0.0, 6.0],
-];
-
-describe("Cell", () => {
-    it("cell creation", () => {
-        const cell = new Cell({
-            a: VECTORS[0],
-            b: VECTORS[1],
-            c: VECTORS[2],
-        });
-        expect(cell.a).to.deep.equal(VECTORS[0]);
-        expect(cell.b).to.deep.equal(VECTORS[1]);
-        expect(cell.c).to.deep.equal(VECTORS[2]);
-    });
-    it("cell creation default", () => {
-        const cell = new Cell();
-        expect(cell.a).to.deep.equal(Cell.defaultConfig.a);
-        expect(cell.b).to.deep.equal(Cell.defaultConfig.b);
-        expect(cell.c).to.deep.equal(Cell.defaultConfig.c);
-    });
-    it("from vectors array", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        expect(cell.a).to.deep.equal(VECTORS[0]);
-        expect(cell.b).to.deep.equal(VECTORS[1]);
-        expect(cell.c).to.deep.equal(VECTORS[2]);
-    });
-    it("get vector arrays", () => {
-        const cell = new Cell({
-            a: VECTORS[0],
-            b: VECTORS[1],
-            c: VECTORS[2],
-        });
-        expect(cell.vectorArrays).to.deep.equal(VECTORS);
-    });
-    it("vector arrays including rounded", () => {
-        const classReference = Cell;
-        classReference.RoundedVector3DClassReference.roundPrecision = 4;
-        const cell = classReference.fromVectorsArray(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        expect(cell.vectorArrays).to.deep.equal(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        expect(cell.vectorArraysRounded).to.deep.equal(VECTORS);
-
-        classReference.RoundedVector3DClassReference.roundPrecision = 5;
-        const cellRounded = classReference.fromVectorsArray(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        expect(cellRounded.vectorArrays).to.deep.equal(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        expect(cellRounded.vectorArraysRounded).not.to.deep.equal(VECTORS);
-    });
-    it("convert point to cartesian", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const cartesian = cell.convertPointToCartesian(POINT_IN_CELL_CRYSTAL);
-        expect(cartesian).to.deep.equal(POINT_IN_CELL_CARTESIAN);
-    });
-    it("convert point to crystal", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const point = cell.convertPointToCrystal(POINT_IN_CELL_CARTESIAN);
-        expect(point).to.deep.equal(POINT_IN_CELL_CRYSTAL);
-    });
-    it("volume", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const { volume } = cell;
-        expect(volume).to.equal(VECTORS_VOLUME);
-    });
-    it("volume rounded", () => {
-        const classReference = Cell;
-        classReference.roundPrecision = 4;
-        const cell = classReference.fromVectorsArray(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        const { volume, volumeRounded } = cell;
-        expect(volume).to.equal(VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME);
-        expect(volumeRounded).to.equal(
-            VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4,
-        );
-
-        classReference.roundPrecision = 5;
-        const cellRounded1 = classReference.fromVectorsArray(VECTORS_EQUAL_UP_TO_PRECISION_4);
-        expect(cellRounded1.volume).to.equal(VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME);
-        expect(cellRounded1.volumeRounded).to.equal(
-            VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_5,
-        );
-        expect(cellRounded1.volumeRounded).not.to.equal(
-            VECTORS_EQUAL_UP_TO_PRECISION_4_VOLUME_ROUNDED_TO_PRECISION_4,
-        );
-    });
-
-    // Unique to JS/TS
-
-    it("clone", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const clonedCell = cell.clone();
-        expect(clonedCell).not.to.equal(cell);
-        expect(clonedCell).to.deep.equal(cell);
-    });
-    it("clone and scale by matrix", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const clonedCell = cell.cloneAndScaleByMatrix(SCALING_MATRIX);
-        expect(clonedCell).not.to.equal(cell);
-        assertDeepAlmostEqual(clonedCell.vectorArrays, VECTORS_SCALED_BY_MATRIX);
-    });
-    it("scale by matrix", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        cell.scaleByMatrix(SCALING_MATRIX);
-        assertDeepAlmostEqual(cell.vectorArrays, VECTORS_SCALED_BY_MATRIX);
-    });
-    it("is point inside cell", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        expect(cell.isPointInsideCell(POINT_IN_CELL)).to.equal(true);
-        expect(cell.isPointInsideCell(POINT_OUTSIDE_CELL)).to.equal(false);
-    });
-    it("is point inside cell with tolerance", () => {
-        const classReference = Cell;
-        classReference.tolerance = POINT_IN_CELL_TOLERANCE;
-        const cell = Cell.fromVectorsArray(VECTORS);
-        expect(cell.isPointInsideCell(POINT_IN_CELL_WITH_TOLERANCE_0_1)).to.equal(true);
-        expect(cell.isPointInsideCell(POINT_OUTSIDE_CELL_WITH_TOLERANCE_0_1)).to.equal(false);
-        expect(cell.isPointInsideCell(POINT_OUTSIDE_CELL_WITH_TOLERANCE_0_1_ALT)).to.equal(false);
-    });
-    it("is point inside cell crystal", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const pointInCellCrystal = cell.convertPointToCrystal(POINT_IN_CELL_CARTESIAN);
-        expect(cell.isPointInsideCellCrystal(pointInCellCrystal)).to.equal(true);
-        expect(cell.isPointInsideCellCrystal(POINT_OUTSIDE_CELL_CRYSTAL)).to.equal(false);
-    });
-    it("toJSON", () => {
-        const cell = Cell.fromVectorsArray(VECTORS);
-        const json = cell.toJSON();
-        expect(json).to.deep.equal(CELL_JSON);
-    });
-});

package/tests/js/cell/primitive_cell.ts

@@ -1,21 +0,0 @@
-import { LatticeSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-
-import { getPrimitiveLatticeVectorsFromConfig } from "../../../src/js/cell/primitive_cell";
-import { Lattice } from "../../../src/js/lattice/lattice";
-import { Na4Cl4 } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Primitive Cell", () => {
-    it("should return primitive lattice", () => {
-        const lattice = new Lattice(Na4Cl4.lattice as LatticeSchema);
-        const actualPrimitiveCell = getPrimitiveLatticeVectorsFromConfig(lattice);
-        const expectedPrimitiveCell = [
-            [5.691694, 0, 0],
-            [0, 5.691694, 0],
-            [0, 0, 5.691694],
-        ];
-        assertDeepAlmostEqual(expectedPrimitiveCell, actualPrimitiveCell);
-    });
-});

package/tests/js/constraints/constraints.ts

@@ -1,11 +0,0 @@
-import { expect } from "chai";
-
-import { AtomicConstraints } from "../../../src/js/constraints/constraints";
-import { atomicConstraints } from "../fixtures";
-
-describe("AtomicConstraints", () => {
-    it("should return constraints as string", () => {
-        const constraints = AtomicConstraints.fromObjects(atomicConstraints);
-        expect(constraints.getAsStringByIndex(0)).to.be.equal("1 1 0");
-    });
-});

package/tests/js/fixtures.ts

@@ -1,123 +0,0 @@
-import {
-    AtomicConstraintsSchema,
-    BasisSchema,
-    MaterialHashedSchema,
-    MaterialSchema,
-} from "@mat3ra/esse/dist/js/types";
-import { MaterialStandata } from "@mat3ra/standata";
-import fs from "fs";
-import path from "path";
-
-import AsGeBasis_JSON from "../fixtures/AsGe-basis.json";
-import atomicConstraints_JSON from "../fixtures/atomic-constraints.json";
-import C2H4_JSON from "../fixtures/C2H4.json";
-import C2H4Translated_JSON from "../fixtures/C2H4-translated.json";
-import FeLiSiBasis_JSON from "../fixtures/FeLiSi-basis.json";
-import FeO_JSON from "../fixtures/FeO.json";
-import Ge2Basis_JSON from "../fixtures/Ge2-basis.json";
-import Graphene_JSON from "../fixtures/Graphene.json";
-import H2HFinal_JSON from "../fixtures/H2+H-final.json";
-import H2HImage_JSON from "../fixtures/H2+H-image.json";
-import H2HInitial_JSON from "../fixtures/H2+H-initial.json";
-import LiFeSiBasis_JSON from "../fixtures/LiFeSi-basis.json";
-import LiFeSiBasisLabels_JSON from "../fixtures/LiFeSi-basis-labels.json";
-import Na_JSON from "../fixtures/Na.json";
-import Na4Cl4_JSON from "../fixtures/Na4Cl4.json";
-import Na4Cl4Cartesian_JSON from "../fixtures/Na4Cl4-cartesian.json";
-import NiHex_JSON from "../fixtures/Ni-hex.json";
-import OSiBasis_JSON from "../fixtures/OSi-basis.json";
-import SiSlab_JSON from "../fixtures/Si-slab.json";
-import SiSlab100_JSON from "../fixtures/si-slab-100.json";
-import SiSlab111Gamma120_JSON from "../fixtures/si-slab-111-0.5-vacuum-gamma-120.json";
-import SiSlab111_JSON from "../fixtures/si-slab-111-0.5-vacuum-ratio.json";
-import SiSlab111NoVacuum_JSON from "../fixtures/si-slab-111-0-vacuum.json";
-import Silicon_JSON from "../fixtures/si-standata.json";
-import SiSupercell_JSON from "../fixtures/Si-supercell.json";
-import Si2Basis_JSON from "../fixtures/Si2-basis.json";
-import Si2BasisRepeated_JSON from "../fixtures/Si2-basis-repeated.json";
-import Zr1H23Zr1H1_JSON from "../fixtures/Zr1H23Zr1H1.json";
-
-// Material
-const Silicon = Silicon_JSON as unknown as MaterialHashedSchema;
-const SiSupercell = SiSupercell_JSON as unknown as MaterialHashedSchema;
-const SiSlab = SiSlab_JSON as unknown as MaterialSchema;
-const SiSlab100 = SiSlab100_JSON as unknown as MaterialSchema;
-const SiSlab111 = SiSlab111_JSON as unknown as MaterialSchema;
-const SiSlab111Gamma120 = SiSlab111Gamma120_JSON as unknown as MaterialSchema;
-const SiSlab111NoVacuum = SiSlab111NoVacuum_JSON as unknown as MaterialSchema;
-const FeO = FeO_JSON as unknown as MaterialSchema;
-const FeOStandata = MaterialStandata.getRuntimeDataConfigs().find((m: any) =>
-    m.name?.includes("FeO"),
-) as MaterialHashedSchema;
-const Na4Cl4 = Na4Cl4_JSON as unknown as MaterialSchema;
-const Na4Cl4Cartesian = Na4Cl4Cartesian_JSON as unknown as MaterialSchema;
-const C2H4 = C2H4_JSON as unknown as MaterialSchema;
-const C2H4Translated = C2H4Translated_JSON as unknown as MaterialSchema;
-const Na = Na_JSON as unknown as MaterialSchema;
-const H2HInitial = H2HInitial_JSON as unknown as MaterialSchema;
-const H2HFinal = H2HFinal_JSON as unknown as MaterialSchema;
-const H2HImage = H2HImage_JSON as unknown as MaterialSchema;
-const Zr1H23Zr1H1 = Zr1H23Zr1H1_JSON as unknown as MaterialSchema;
-const Graphene = Graphene_JSON as unknown as MaterialHashedSchema;
-const NiHex = NiHex_JSON as unknown as MaterialSchema;
-
-// Basis
-const Si2Basis = Si2Basis_JSON as BasisSchema;
-const Si2BasisRepeated = Si2BasisRepeated_JSON as BasisSchema;
-const OSiBasis = OSiBasis_JSON as BasisSchema;
-const Ge2Basis = Ge2Basis_JSON as BasisSchema;
-const AsGeBasis = AsGeBasis_JSON as BasisSchema;
-const FeLiSiBasis = FeLiSiBasis_JSON as BasisSchema;
-const LiFeSiBasis = LiFeSiBasis_JSON as BasisSchema;
-const LiFeSiBasisLabels = LiFeSiBasisLabels_JSON as BasisSchema;
-
-// Other
-const atomicConstraints = atomicConstraints_JSON as AtomicConstraintsSchema;
-
-export {
-    // Silicon
-    Silicon,
-    SiSupercell,
-    SiSlab,
-    SiSlab100,
-    SiSlab111,
-    SiSlab111Gamma120,
-    SiSlab111NoVacuum,
-    Si2Basis,
-    Si2BasisRepeated,
-    // Other
-    FeO,
-    FeOStandata,
-    Na4Cl4,
-    Na4Cl4Cartesian,
-    C2H4,
-    C2H4Translated,
-    Na,
-    OSiBasis,
-    Ge2Basis,
-    AsGeBasis,
-    FeLiSiBasis,
-    LiFeSiBasis,
-    LiFeSiBasisLabels,
-    atomicConstraints,
-    H2HInitial,
-    H2HFinal,
-    H2HImage,
-    Zr1H23Zr1H1,
-    Graphene,
-    NiHex,
-};
-
-// NON-JSON
-export const FIXTURES_DIR = path.resolve(__dirname, "../fixtures");
-
-// NON-JSON
-export const Na4Cl4Poscar = fs.readFileSync(path.join(FIXTURES_DIR, "Na4Cl4.poscar"), "utf8");
-export const SiPWSCFInput = fs.readFileSync(path.join(FIXTURES_DIR, "Si-pwscf.in"), "utf8");
-export const Zr1H23Zr1H1Poscar = fs.readFileSync(
-    path.join(FIXTURES_DIR, "Zr1H23Zr1H1.poscar"),
-    "utf8",
-);
-export const H2OPoscar = fs.readFileSync(path.join(FIXTURES_DIR, "H2O.poscar"), "utf8");
-export const GraphenePoscar = fs.readFileSync(path.join(FIXTURES_DIR, "Graphene.poscar"), "utf8");
-export const NiHexPoscar = fs.readFileSync(path.join(FIXTURES_DIR, "Ni-hex.poscar"), "utf8");

package/tests/js/lattice/lattice.ts

@@ -1,43 +0,0 @@
-import "../setup";
-
-import { LatticeSchema, LatticeVectorsSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { Lattice } from "../../../src/js/lattice/lattice";
-import { Na4Cl4, Silicon } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Lattice", () => {
-    it("should create a lattice", () => {
-        const lattice = Lattice.fromConfig(Silicon.lattice);
-        expect(lattice).to.be.instanceOf(Lattice);
-        expect(lattice.a).to.be.equal(Silicon.lattice.a);
-    });
-    it("should return lattice type", () => {
-        const lattice = new Lattice(Silicon.lattice as LatticeSchema);
-        expect(lattice.type).to.be.equal("FCC");
-    });
-
-    it("should return lattice cell volume", () => {
-        const lattice = new Lattice(Silicon.lattice as LatticeSchema);
-        expect(lattice.volume).to.be.almost.equal(40.889096881496656);
-    });
-
-    it("should return lattice from vectors", () => {
-        const lattice = Lattice.fromVectors(Na4Cl4.lattice.vectors as LatticeVectorsSchema);
-        assertDeepAlmostEqual(Na4Cl4.lattice, lattice.toJSON(), ["type"]);
-    });
-
-    it("should return lattice type", () => {
-        const lattice = new Lattice(Silicon.lattice as LatticeSchema);
-        expect(lattice.typeExtended).to.be.equal("FCC");
-    });
-
-    it("should return lattice hash string", () => {
-        const lattice = new Lattice(Na4Cl4.lattice as LatticeSchema);
-        expect(lattice.getHashString()).to.be.equal("5.692;5.692;5.692;90;90;90;");
-    });
-    // TODO: add more tests
-});