@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/tests/js/lattice/lattice_reciprocal.ts

@@ -1,104 +0,0 @@
-import "../setup";
-
-import { LatticeSchema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import { ReciprocalLattice } from "../../../src/js/lattice/reciprocal/lattice_reciprocal";
-import { Na4Cl4, Silicon, SiSlab } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Lattice Reciprocal", () => {
-    it("should extract kpoint path", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const expectedPath = [
-            {
-                point: "Γ",
-                steps: 0,
-                coordinates: [0, 0, 0],
-            },
-            {
-                point: "R",
-                steps: 1,
-                coordinates: [0.5, 0.5, 0.5],
-            },
-        ];
-        const actualPath = lattice.extractKpointPath([
-            [0, 0, 0],
-            [0.5, 0.5, 0.5],
-        ]);
-        assertDeepAlmostEqual(expectedPath, actualPath);
-    });
-
-    it("should return cartesian coordinates of a point", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const expectedCoordinates = [0.5, 0.5, 0.5];
-        const actualCoordinates = lattice.getCartesianCoordinates([0.5, 0.5, 0.5]);
-        assertDeepAlmostEqual(actualCoordinates, expectedCoordinates);
-    });
-
-    it("should return reciprocal vectors", () => {
-        const lattice = new ReciprocalLattice(Silicon.lattice as LatticeSchema);
-        const actualVectors = lattice.reciprocalVectors;
-        const expectedVectors = [
-            [1.1547005383792517, -0.40824829046386313, 0],
-            [0, 1.2247448713915892, 0],
-            [-0.5773502691896261, -0.40824829046386313, 1],
-        ];
-        assertDeepAlmostEqual(actualVectors, expectedVectors);
-    });
-
-    it("should extract symmetry points", () => {
-        const lattice = new ReciprocalLattice(Na4Cl4.lattice as LatticeSchema);
-        const actualPoints = lattice.symmetryPoints;
-        const expectedPoints = [
-            {
-                point: "Γ",
-                coordinates: [0, 0, 0],
-            },
-            {
-                point: "R",
-                coordinates: [0.5, 0.5, 0.5],
-            },
-            {
-                point: "X",
-                coordinates: [0, 0.5, 0],
-            },
-            {
-                point: "M",
-                coordinates: [0.5, 0.5, 0],
-            },
-        ];
-        assertDeepAlmostEqual(actualPoints, expectedPoints);
-    });
-
-    it("should calculate k-grid dimensions based on number of points", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromPointsCount(500);
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate k-grid dimensions based on spacing in cartesian units", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromSpacing(0.09);
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate k-grid dimensions based on spacing in 1/angstrom", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = lattice.getDimensionsFromSpacing(0.11, "angstrom");
-        const expectedDimensions = [12, 12, 4];
-        assertDeepAlmostEqual(dimensions, expectedDimensions);
-    });
-
-    it("should calculate average spacing in 1/angstrom based on k-grid dimensions", () => {
-        const lattice = new ReciprocalLattice(SiSlab.lattice as LatticeSchema);
-        const dimensions = [12, 12, 4];
-        const expectedSpacing = 0.1047;
-        const spacing = lattice.getSpacingFromDimensions(dimensions, "angstrom");
-        expect(spacing).to.be.almost(expectedSpacing, 1e-4);
-    });
-});

package/tests/js/material/material.ts

@@ -1,161 +0,0 @@
-import { expect } from "chai";
-
-import Material from "../../../src/js/Material";
-import { FeOStandata, Graphene, Na4Cl4, Silicon } from "../fixtures";
-
-const newBasisXYZ = `Si     0.000000    0.000000    0.000000
-Ge     0.250000    0.250000    0.250000
-`;
-
-describe("Material", () => {
-    it("should return unique elements", () => {
-        const material = new Material(Na4Cl4);
-        expect(material.uniqueElements).to.have.same.members(["Na", "Cl"]);
-    });
-
-    it("should return cloned material", () => {
-        const material = new Material(Silicon);
-        const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.getBasis().units);
-        expect(clonedMaterial.getBasis().elements).to.have.lengthOf(2);
-    });
-
-    it("defaults missing metadata to empty object", () => {
-        const material = new Material({
-            name: Silicon.name,
-            basis: Silicon.basis,
-            lattice: Silicon.lattice,
-        });
-        expect(material.metadata).to.deep.equal({});
-        expect(material.toJSON().metadata).to.deep.equal({});
-    });
-
-    describe("toJSON variants", () => {
-        const material = new Material(Silicon);
-
-        it("toJSONPure omits hash and basis.constraints", () => {
-            const json = material.toJSONPure();
-            expect(json).to.not.have.property("hash");
-            expect(json).to.not.have.property("scaledHash");
-            expect(json.basis).to.not.have.property("constraints");
-            expect(json.name).to.equal(Silicon.name);
-        });
-
-        it("toJSONEnhanced includes basis.constraints and omits hash", () => {
-            const json = material.toJSONEnhanced();
-            expect(json).to.not.have.property("hash");
-            expect(json).to.not.have.property("scaledHash");
-            expect(json.basis).to.have.property("constraints").that.is.an("array");
-        });
-
-        it("toJSONHashed includes hash and omits basis.constraints", () => {
-            const json = material.toJSONHashed();
-            expect(json.hash).to.be.a("string");
-            expect(json.hash.length).to.be.greaterThan(0);
-            expect(json.basis).to.not.have.property("constraints");
-        });
-
-        it("toJSONEnhancedHashed includes hash and basis.constraints", () => {
-            const json = material.toJSONEnhancedHashed();
-            expect(json.hash).to.be.a("string");
-            expect(json.hash.length).to.be.greaterThan(0);
-            expect(json.basis.constraints).to.be.an("array");
-        });
-
-        it("toJSON equals toJSONEnhancedHashed", () => {
-            expect(material.toJSON()).to.deep.equal(material.toJSONEnhancedHashed());
-        });
-    });
-
-    it("getBasisAsXyz includes atomic constraints via toJSONEnhanced", () => {
-        const material = new Material({
-            name: "Li-with-constraints",
-            basis: {
-                elements: [
-                    { id: 0, value: "Li" },
-                    { id: 1, value: "Li" },
-                ],
-                coordinates: [
-                    { id: 0, value: [0, 0, 0] },
-                    { id: 1, value: [0.25, 0.25, 0.25] },
-                ],
-                units: "crystal",
-                constraints: [
-                    { id: 0, value: [true, true, false] },
-                    { id: 1, value: [true, true, true] },
-                ],
-            },
-            lattice: Silicon.lattice,
-        });
-
-        const xyz = material.getBasisAsXyz();
-        expect(xyz).to.match(/Li\s+0\.000000\s+0\.000000\s+0\.000000\s+1\s+1\s+0/);
-        expect(xyz).to.match(/Li\s+0\.250000\s+0\.250000\s+0\.250000\s+1\s+1\s+1/);
-        // Regression: toJSONPure strips constraints — must not be used for XYZ display.
-        expect(material.toJSONPure().basis).to.not.have.property("constraints");
-    });
-
-    describe("calculateHash", () => {
-        [
-            { name: "Silicon", fixture: Silicon },
-            { name: "Graphene", fixture: Graphene },
-        ].forEach(({ name, fixture }) => {
-            it(`should match expected hash for ${name}`, () => {
-                const material = new Material(fixture);
-                expect(material.calculateHash()).to.equal(fixture.hash);
-                expect(material.scaledHash).to.equal(fixture.scaledHash);
-            });
-        });
-
-        it("should match expected hash for FeO (standata)", () => {
-            // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
-            const expectedHashes = require("../../fixtures/hashes.json");
-            const material = new Material(FeOStandata);
-            expect(material.calculateHash()).to.equal(expectedHashes.FeO.hash);
-            // scaledHash is stored on schema; standata config may omit it — match main's computed getter.
-            expect(material.calculateHash("", true)).to.equal(expectedHashes.FeO.scaledHash);
-        });
-
-        it("stores InChI hash for non-periodic materials when InChI is present", () => {
-            // MD5 of the InChI string — same contract as web-app MolView upload.
-            const inchi =
-                "1S/C8H18N4O2/c1-10-4-9-6-5(10)7(13)12(3)8(14)11(6)2/h5-9,13-14H,4H2,1-3H3";
-            const expectedInchiHash = "b3680772bb4f0cba602788d519531914";
-
-            const material = new Material({
-                name: "non-periodic-inchi",
-                isNonPeriodic: true,
-                basis: Silicon.basis,
-                lattice: Silicon.lattice,
-                derivedProperties: [{ name: "inchi", value: inchi }],
-            });
-
-            expect(material.isNonPeriodic).to.equal(true);
-            expect(material.getInchiStringForHash()).to.equal(inchi);
-            expect(material.calculateHash()).to.equal(expectedInchiHash);
-            expect(material.hash).to.equal(expectedInchiHash);
-
-            const geometricHashWithBypass = material.calculateHash("", false, true);
-            material.lattice = { ...material.lattice };
-            expect(material.hash).to.equal(expectedInchiHash);
-            expect(material.hash).to.not.equal(geometricHashWithBypass);
-        });
-
-        it("uses geometric hash when non-periodic but InChI is not derived yet", () => {
-            // Designer toggle sets isNonPeriodic then scales lattice before butler adds InChI.
-            const material = new Material({
-                name: "non-periodic-no-inchi",
-                isNonPeriodic: true,
-                basis: Silicon.basis,
-                lattice: Silicon.lattice,
-            });
-
-            const expectedGeometricHash = material.calculateHash("", false, true);
-            expect(material.hash).to.equal(expectedGeometricHash);
-            expect(() => material.calculateHash()).to.throw(/Missing InChI/);
-
-            material.lattice = { ...material.lattice };
-            expect(material.hash).to.equal(material.calculateHash("", false, true));
-        });
-    });
-});

package/tests/js/parsers/espresso.ts

@@ -1,12 +0,0 @@
-import { expect } from "chai";
-
-import Material from "../../../src/js/Material";
-import parsers from "../../../src/js/parsers/parsers";
-import { Silicon, SiPWSCFInput } from "../fixtures";
-
-describe("Parsers:Espresso", () => {
-    it("should return textual representation of a material according to QE pw.x input format", () => {
-        const material = new Material(Silicon);
-        expect(parsers.espresso.toEspressoFormat(material.toJSON())).to.be.equal(SiPWSCFInput);
-    });
-});

package/tests/js/parsers/native_formats.ts

@@ -1,35 +0,0 @@
-import "../setup";
-
-import { Utils } from "@mat3ra/utils";
-import { expect } from "chai";
-
-import nativeFormatParsers from "../../../src/js/parsers/native_format_parsers";
-import { Graphene, GraphenePoscar, NiHex, NiHexPoscar } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Parsers.NativeFormat", () => {
-    it("should return a material config for graphene from a json", () => {
-        const json = JSON.stringify(Graphene);
-        expect(nativeFormatParsers.convertFromNativeFormat(json)).to.deep.equal(Graphene);
-    });
-
-    it("should return a material config for graphene from a poscar", () => {
-        const poscar = GraphenePoscar;
-        const config = nativeFormatParsers.convertFromNativeFormat(poscar);
-        assertDeepAlmostEqual(config, Graphene, ["basis.labels", "lattice"]);
-        assertDeepAlmostEqual(config.lattice, Graphene.lattice, ["type"]);
-    });
-
-    it("should return a material config for Ni hex from a poscar", () => {
-        const poscar = NiHexPoscar;
-        const config = nativeFormatParsers.convertFromNativeFormat(poscar);
-        assertDeepAlmostEqual(config, NiHex, ["lattice", "basis.labels"]);
-        assertDeepAlmostEqual(config.lattice, NiHex.lattice, ["type"]); // to omit "lattice.type" property
-    });
-
-    it("should throw an error for unknown format", () => {
-        const text = "A\n snippet from an unknown format";
-        expect(() => nativeFormatParsers.convertFromNativeFormat(text)).to.throw("Unknown format");
-    });
-});

package/tests/js/parsers/poscar.ts

@@ -1,89 +0,0 @@
-import { expect } from "chai";
-
-import { AtomicConstraints } from "../../../src/js/constraints/constraints";
-import Material from "../../../src/js/Material";
-import parsers from "../../../src/js/parsers/parsers";
-import { atomsCount } from "../../../src/js/parsers/poscar";
-import {
-    atomicConstraints,
-    H2OPoscar,
-    Na4Cl4,
-    Na4Cl4Poscar,
-    Silicon,
-    Zr1H23Zr1H1,
-    Zr1H23Zr1H1Poscar,
-} from "../fixtures";
-
-const O2_POSCAR_WITH_COMMENTS = `O2 molecule in a box
-1.0 ! universal scaling parameters
-12.0 0.0 0.0 ! lattice vector a(1)
-0.0 12.0 0.0 ! lattice vector a(2)
-0.0 0.0 12.0 ! lattice vector a(3)
-O
-2 ! number of atoms
-cart ! positions in cartesian coordinates
-0 0 0 O
-0 0 1.21 O
-`;
-
-describe("Parsers.POSCAR", () => {
-    it("should return a valid poscar", () => {
-        const material = new Material(Na4Cl4);
-        expect(`${material.getAsPOSCAR()}\n`).to.be.equal(Na4Cl4Poscar);
-    });
-
-    it("should return poscar elements line according to id in basis, duplicate entries separate", () => {
-        const material = new Material(Zr1H23Zr1H1);
-        expect(`${material.getAsPOSCAR()}\n`).to.be.equal(Zr1H23Zr1H1Poscar);
-    });
-
-    it("should return the number of atoms for a molecule in a poscar file", () => {
-        expect(atomsCount(H2OPoscar)).to.be.equal(3);
-    });
-
-    it("should detect POSCAR with VASP-style comments", () => {
-        expect(parsers.poscar.isPoscar(O2_POSCAR_WITH_COMMENTS)).to.be.equal(true);
-        expect(parsers.nativeFormatParsers.detectFormat(O2_POSCAR_WITH_COMMENTS)).to.be.equal(
-            "poscar",
-        );
-    });
-
-    it("should parse POSCAR with VASP-style comments", () => {
-        const materialConfig = parsers.poscar.fromPoscar(O2_POSCAR_WITH_COMMENTS);
-        expect(materialConfig).to.have.property("basis");
-        expect((materialConfig as { basis: { elements: object[] } }).basis.elements).to.have.length(
-            2,
-        );
-    });
-
-    it("should return constraints as string with given map function", () => {
-        const constraints = AtomicConstraints.fromObjects(atomicConstraints);
-        expect(
-            constraints.getAsStringByIndex(0, parsers.poscar.atomicConstraintsCharFromBool),
-        ).to.be.equal("T T F");
-    });
-
-    it("should generate POSCAR with constraints if they were present", () => {
-        const newBasisXYZ = `Si     0.000000    0.000000    0.000000 0 0 0
-Ge     0.250000    0.250000    0.250000 1 1 1
-`;
-        const poscarConstraints = `Silicon FCC
-1.0
-   3.348920000\t   0.000000000\t   1.933500000
-   1.116307000\t   3.157392000\t   1.933500000
-   0.000000000\t   0.000000000\t   3.867000000
-Si Ge
-1 1
-Selective dynamics
-direct
-   0.000000000    0.000000000    0.000000000 F F F Si
-   0.250000000    0.250000000    0.250000000 T T T Ge`;
-
-        const material = new Material(Silicon);
-        const clonedMaterial = material.clone();
-        clonedMaterial.setBasis(newBasisXYZ, "xyz", clonedMaterial.getBasis().units);
-
-        const poscar = clonedMaterial.getAsPOSCAR(true);
-        expect(poscar).to.be.equal(poscarConstraints);
-    });
-});

package/tests/js/parsers/xyz.ts

@@ -1,33 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-
-import parsers from "../../../src/js/parsers/parsers";
-import { FeO, Silicon } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Parsers:XYZ", () => {
-    it("should extract basis from XYZ text", () => {
-        const text = "Si 0 0 0 \n Si 0.25 0.25 0.25";
-        assertDeepAlmostEqual(parsers.xyz.toBasisConfig(text), Silicon.basis, [
-            "constraints",
-            "cell",
-            "units",
-        ]);
-    });
-
-    it("should extract basis from XYZ text with atomic labels", () => {
-        const text =
-            "Fe1  0.00  0.00  0.00  1 1 1\n" +
-            "Fe2  0.50  0.50  0.50  1 1 1\n" +
-            "O    0.25  0.25  0.25  1 1 1\n" +
-            "O    0.75  0.75  0.75  1 1 1";
-        assertDeepAlmostEqual(parsers.xyz.toBasisConfig(text), FeO.basis, ["cell", "units"]);
-    });
-
-    it("should return [true, true, true] as constraints for the line without any constraints", () => {
-        const text = "Si 0 0 0 0 1 1\n Si 0.25 0.25 0.25";
-        const basis = parsers.xyz.toBasisConfig(text);
-        assertDeepAlmostEqual(basis.constraints[0].value, [false, true, true]);
-        assertDeepAlmostEqual(basis.constraints[1].value, [true, true, true]);
-    });
-});

package/tests/js/parsers/xyz_combinatorial_basis.ts

@@ -1,156 +0,0 @@
-import { expect } from "chai";
-
-import { Basis } from "../../../src/js/basis/basis";
-import { CombinatorialBasis } from "../../../src/js/parsers/xyz_combinatorial_basis";
-import { AsGeBasis, FeLiSiBasis, Ge2Basis, OSiBasis, Si2Basis } from "../fixtures";
-
-describe("Parsers:CombinatorialBasis", () => {
-    it("toBasisConfig", () => {
-        // eslint-disable-next-line new-cap
-        const basisConfig2 = CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-            {
-                element: "Si",
-                coordinate: [0, 0, 0],
-            },
-            {
-                element: "Li",
-                coordinate: [0.3, 0.3, 0.3],
-            },
-            {
-                element: "Fe",
-                coordinate: [0.5, 0.5, 0.5],
-            },
-        ]);
-        const [basis1, basis2] = [
-            new Basis(FeLiSiBasis),
-            Basis.fromElementsAndCoordinates(basisConfig2),
-        ];
-
-        expect(basis1.isEqualTo(basis2)).to.equal(true);
-    });
-
-    it("Regular XYZ", () => {
-        const xyz = `
-            Si 0.0 0.0 0.0
-            O 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(xyz);
-        expect(basis.uniqueElements).deep.equal(["O", "Si"]);
-        const basis1 = Basis.fromElementsAndCoordinates(basis.allBasisConfigs[0]);
-        const basis2 = new Basis(OSiBasis);
-        expect(basis1.isEqualTo(basis2)).to.equal(true);
-    });
-
-    it("Permutation XYZ", () => {
-        const permutation = `
-            Si/Ge/As 0.0 0.0 0.0
-            Si/Ge 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(permutation);
-        expect(basis.uniqueElements).deep.equal(["As", "Ge", "Si"]);
-        const basisList1 = basis.allBasisConfigs.map((c) => Basis.fromElementsAndCoordinates(c));
-        const basisList2 = [Si2Basis, Ge2Basis, AsGeBasis].map((c) => new Basis(c));
-
-        basisList1.forEach((basis1) => {
-            const condition = basisList2
-                .map((basis2) => basis2.isEqualTo(basis1))
-                .reduce((a, b) => a || b);
-            expect(condition).to.equal(true);
-        });
-    });
-
-    it("Combination XYZ", () => {
-        const combination = `
-            Si,Ge,As 0.0 0.0 0.0
-            Si,Ge 0.5 0.5 0.5
-        `;
-        const basis = new CombinatorialBasis(combination);
-        expect(basis.uniqueElements).deep.equal(["As", "Ge", "Si"]);
-
-        const basisList1 = basis.allBasisConfigs.map((c) => Basis.fromElementsAndCoordinates(c));
-        expect(basisList1.length).to.equal(6);
-
-        const basisList2 = [
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Si",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Si",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Ge",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "Ge",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "As",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Si",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-            CombinatorialBasis.toBasisConfigForElementsAndCoordinates([
-                {
-                    element: "As",
-                    coordinate: [0, 0, 0],
-                },
-                {
-                    element: "Ge",
-                    coordinate: [0.5, 0.5, 0.5],
-                },
-            ]),
-        ].map((c) => Basis.fromElementsAndCoordinates(c));
-
-        basisList1.forEach((basis1) => {
-            const condition = basisList2
-                .map((basis2) => basis2.isEqualTo(basis1))
-                .reduce((a, b) => a || b);
-            expect(condition).to.equal(true);
-        });
-    });
-
-    it("Mixing combination and permutation should fail", () => {
-        const mixedInMultipleLines = `
-            Si/Ge/As 0.0 0.0 0.0\n
-            Si,Ge 0.5 0.5 0.5
-        `;
-        const mixedInOneLine = `
-            Si/Ge,As 0.0 0.0 0.0
-        `;
-        // Wrapping into function as recommended in: http://chaijs.com/api/bdd/
-        expect(() => new CombinatorialBasis(mixedInMultipleLines)).to.throw();
-        expect(() => new CombinatorialBasis(mixedInOneLine)).to.throw();
-    });
-});

package/tests/js/register-esse-schemas.cjs

@@ -1,10 +0,0 @@
-/**
- * Registers ESSE schemas for made unit tests.
- * Kept as CommonJS so mocha `--require` can load it without ESM JSON import issues.
- * Library / web-app code must not import `@mat3ra/esse/dist/js/schemas.json` — the host
- * (web-app) registers the (possibly extended) schema set once at startup.
- */
-const JSONSchemasInterface = require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface").default;
-const allSchemas = require("@mat3ra/esse/dist/js/schemas.json");
-
-JSONSchemasInterface.setSchemas(allSchemas);

package/tests/js/setup.ts

@@ -1,6 +0,0 @@
-import chai from "chai";
-import chaiAlmost from "chai-almost";
-
-const TOLERANCE = 1e-3;
-
-chai.use(chaiAlmost(TOLERANCE));

package/tests/js/tools/basis.ts

@@ -1,22 +0,0 @@
-import { Utils } from "@mat3ra/utils";
-
-import { Basis } from "../../../src/js/basis/basis";
-import tools from "../../../src/js/tools";
-import { H2HFinal, H2HImage, H2HInitial, Si2Basis, Si2BasisRepeated } from "../fixtures";
-
-const { assertDeepAlmostEqual } = Utils.assertion;
-
-describe("Tools:Basis", () => {
-    it("should return a repeated basis", () => {
-        const basis = new Basis(Si2Basis);
-        const repeatedBasis = tools.basis.repeat(basis, [2, 1, 1]);
-        assertDeepAlmostEqual(Si2BasisRepeated, repeatedBasis.toJSON());
-    });
-
-    it("should return interpolated basises", () => {
-        const finalBasis = new Basis(H2HFinal.basis);
-        const initialBasis = new Basis(H2HInitial.basis);
-        const images = tools.basis.interpolate(initialBasis, finalBasis, 1);
-        assertDeepAlmostEqual(H2HImage.basis, images[0].toJSON());
-    });
-});