@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/src/js/basis/constrained_basis.ts

@@ -1,115 +0,0 @@
-import { AtomicConstraintsSchema, BasisConstrainedSchema } from "@mat3ra/esse/dist/js/types";
-
-import { Cell } from "../cell/cell";
-import { AtomicConstraints, AtomicConstraintValue, Constraint } from "../constraints/constraints";
-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 BasisConstrainedSchema {
-    cell?: Cell;
-    isEmpty?: boolean;
-}
-
-export interface ElementsCoordinatesAndConstraintsConfig extends ElementsAndCoordinatesConfig {
-    constraints: AtomicConstraintValue[];
-}
-
-/**
- * @summary Extension of the Basis class able to deal with atomic constraints.
- * @extends Basis
- */
-export class ConstrainedBasis extends Basis<ConstrainedBasisConfig> {
-    private _constraints: AtomicConstraints;
-
-    constructor(config: ConstrainedBasisConfig) {
-        super(config);
-        this._constraints = AtomicConstraints.fromObjects(config.constraints ?? []); // `constraints` is an Array with ids
-    }
-
-    static fromElementsCoordinatesAndConstraints(
-        config: ElementsCoordinatesAndConstraintsConfig,
-    ): ConstrainedBasis {
-        const basisConfig = this._convertValuesToConfig(config);
-        const constraints = AtomicConstraints.fromValues(config.constraints);
-        return new this({
-            ...basisConfig,
-            constraints: constraints.toJSON() as AtomicConstraintsSchema,
-        });
-    }
-
-    get constraints() {
-        return this._constraints.toJSON() as AtomicConstraintsSchema;
-    }
-
-    set constraints(constraints: AtomicConstraintsSchema) {
-        this._constraints = AtomicConstraints.fromObjects(constraints);
-    }
-
-    get AtomicConstraints() {
-        return AtomicConstraints.fromObjects(this.constraints);
-    }
-
-    override toJSON(exclude: (keyof ConstrainedBasisConfig)[] = ["cell"]): ConstrainedBasisConfig {
-        return {
-            ...super.toJSON(exclude as (keyof ConstrainedBasisConfig)[]),
-            constraints: this.constraints,
-        };
-    }
-
-    getConstraintByIndex(idx: number): AtomicConstraintValue {
-        return this._constraints.getElementValueByIndex(idx) || [true, true, true];
-    }
-
-    getConstraintById(id: number): AtomicConstraintValue {
-        return this._constraints.getElementValueById(id) || [true, true, true];
-    }
-
-    /**
-     * Helper function returning a nested array with [element, coordinates, constraints] as elements
-     */
-    get elementsCoordinatesConstraintsArray(): [
-        AtomicElementValue,
-        AtomicLabelValue,
-        AtomicCoordinateValue,
-        AtomicConstraintValue,
-    ][] {
-        return this._elements.values.map((element: AtomicElementValue, idx: number) => {
-            const coordinate = this.getCoordinateValueByIndex(idx);
-            const constraint = this.getConstraintByIndex(idx);
-            const label = this.atomicLabelsArray[idx];
-            return [element, label, coordinate, constraint];
-        });
-    }
-
-    /**
-     * Returns an array with atomic positions (with constraints) per atom stored as strings.
-     * E.g., ``` ['Si  0 0 0  0 1 0', 'Li  0.5 0.5 0.5  1 0 1']```
-     */
-    getAtomicPositionsWithConstraintsAsStrings(
-        coordinatePrintFormat?: string,
-        precision?: number,
-    ): string[] {
-        const omitConstraints = this._constraints.areUnconstrained;
-        return this.elementsCoordinatesConstraintsArray.map(
-            ([element, label, coordinate, constraint]) => {
-                const _elementWithLabel = new ElementWithLabel({ element, label });
-                const _coordinate = Coordinate.fromValueAndId(coordinate);
-                const _constraint = Constraint.fromValueAndId(constraint);
-
-                return [
-                    _elementWithLabel.prettyPrint(),
-                    _coordinate.prettyPrint(coordinatePrintFormat, precision),
-                    omitConstraints ? "" : _constraint.prettyPrint(),
-                ].join(" ");
-            },
-        );
-    }
-
-    removeAllAtoms() {
-        super.removeAllAtoms();
-        this.constraints = [];
-    }
-}

package/src/js/basis/coordinates.ts

@@ -1,92 +0,0 @@
-import { RoundedArrayWithIds, RoundedValueWithId, RoundedVector3D, Vector3D } from "@mat3ra/code";
-import {
-    AtomicCoordinateSchema,
-    Coordinate3DSchema,
-    Matrix3X3Schema,
-    Vector3DSchema,
-} from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-import { sprintf } from "underscore.string";
-
-export type AtomicCoordinateValue = AtomicCoordinateSchema["value"];
-
-type AxisType = "x" | "y" | "z";
-
-export class Coordinate extends RoundedValueWithId<AtomicCoordinateValue> {
-    value: AtomicCoordinateValue;
-
-    constructor({ value, id }: AtomicCoordinateSchema) {
-        super(id, value);
-        this.value = value;
-    }
-
-    getValueAlongAxis(axis: AxisType = "z"): number {
-        const index = { x: 0, y: 1, z: 2 }[axis];
-        return this.value[index] as number;
-    }
-
-    translateByVector(vectorAsArray: Vector3DSchema): Coordinate {
-        const vector3D = new Vector3D(this.value);
-        this.value = vector3D.translateByVector(vectorAsArray).value;
-        return this;
-    }
-
-    get valueRounded(): number[] {
-        return new RoundedVector3D(this.value).valueRounded;
-    }
-
-    getValueRoundedWithPrecision(precision: number): number[] {
-        const RoundedInstance = RoundedVector3D;
-        RoundedInstance.roundPrecision = precision;
-        return new RoundedInstance(this.value).valueRounded;
-    }
-
-    prettyPrint(format = "%14.9f", precision: number = this.precision): string {
-        return this.getValueRoundedWithPrecision(precision)
-            .map((x) => sprintf(format, x))
-            .join(" ");
-    }
-}
-
-export class Coordinates extends RoundedArrayWithIds<Coordinate3DSchema> {
-    getValuesAlongAxis(axis: AxisType = "z"): number[] {
-        return this.values.map((coord) => {
-            const coordinate = Coordinate.fromValueAndId(coord);
-            return coordinate.getValueAlongAxis(axis);
-        });
-    }
-
-    getMaxValueAlongAxis(axis: AxisType = "z"): number {
-        return Math.max(...this.getValuesAlongAxis(axis));
-    }
-
-    getMinValueAlongAxis(axis: AxisType = "z"): number {
-        return Math.min(...this.getValuesAlongAxis(axis));
-    }
-
-    getExtremumValueAlongAxis(extremum: "max" | "min" = "max", axis: AxisType = "z"): number {
-        return extremum === "max"
-            ? this.getMaxValueAlongAxis(axis)
-            : this.getMinValueAlongAxis(axis);
-    }
-
-    translateByVector(vector: Vector3DSchema): void {
-        this.mapArrayInPlace((x) => {
-            const coordinate = Coordinate.fromValueAndId(x);
-            return coordinate.translateByVector(vector).value;
-        });
-    }
-
-    getCenterPoint(): Vector3DSchema {
-        const transposed = Utils.math.transpose(this.values) as Matrix3X3Schema;
-        const center: Vector3DSchema = [0, 0, 0];
-
-        for (let i = 0; i < 3; i++) {
-            const axisCoords = transposed[i] as Coordinate3DSchema;
-            const sum = axisCoords.reduce((a, b) => a + b, 0);
-            center[i] = sum / this.values.length;
-        }
-
-        return center;
-    }
-}

package/src/js/basis/elements.ts

@@ -1,24 +0,0 @@
-import { ArrayWithIds, ValueWithId } from "@mat3ra/code";
-import { AtomicElementSchema } from "@mat3ra/esse/dist/js/types";
-import { uniq } from "lodash";
-
-export type AtomicElementValue = AtomicElementSchema["value"];
-
-export class Element extends ValueWithId<AtomicElementValue> {
-    value: AtomicElementValue;
-
-    constructor({ value, id }: AtomicElementSchema) {
-        super({ id, value });
-        this.value = value;
-    }
-
-    prettyPrint(): string {
-        return this.value;
-    }
-}
-
-export class Elements extends ArrayWithIds<AtomicElementValue> {
-    getUnique(): string[] {
-        return uniq(this.values.map((element) => element)) as string[];
-    }
-}

package/src/js/basis/helpers.ts

@@ -1,20 +0,0 @@
-import s from "underscore.string";
-
-import { AtomicElementValue } from "./elements";
-import { AtomicLabelValue } from "./labels";
-
-export class ElementWithLabel {
-    element: AtomicElementValue;
-
-    label: AtomicLabelValue;
-
-    constructor({ element, label }: { element: AtomicElementValue; label: AtomicLabelValue }) {
-        this.element = element;
-        this.label = label;
-    }
-
-    prettyPrint(): string {
-        const elementWithLabel = `${this.element}${this.label}`;
-        return s.sprintf("%-3s", elementWithLabel);
-    }
-}

package/src/js/basis/labels.ts

@@ -1,6 +0,0 @@
-import { ArrayWithIds } from "@mat3ra/code";
-import { AtomicLabelSchema } from "@mat3ra/esse/dist/js/types";
-
-export type AtomicLabelValue = AtomicLabelSchema["value"];
-
-export class Labels extends ArrayWithIds<AtomicLabelValue> {}

package/src/js/cell/cell.ts

@@ -1,149 +0,0 @@
-import { RoundedVector3D } from "@mat3ra/code";
-import {
-    Coordinate3DSchema,
-    LatticeVectorsSchema as CellSchema,
-    Matrix3X3Schema,
-    Vector3DSchema,
-} from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-
-import constants from "../constants";
-
-const MATRIX = Utils.math.matrix;
-const MULT = Utils.math.multiply;
-const INV = Utils.math.inv;
-// @ts-ignore
-const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
-
-export class Cell implements CellSchema {
-    static RoundedVector3DClassReference = RoundedVector3D;
-
-    static roundPrecision = 9;
-
-    static tolerance = constants.tolerance.length; // in crystal coordinates
-
-    static defaultConfig: CellSchema = {
-        a: [1.0, 0, 0],
-        b: [0, 1.0, 0],
-        c: [0, 0, 1.0],
-    };
-
-    a: CellSchema["a"];
-
-    b: CellSchema["b"];
-
-    c: CellSchema["c"];
-
-    alat = 1;
-
-    units: CellSchema["units"] = "angstrom";
-
-    constructor(config = Cell.defaultConfig) {
-        const { a, b, c } = config;
-        this.a = a;
-        this.b = b;
-        this.c = c;
-    }
-
-    static fromVectorsArray(vectors: Matrix3X3Schema): Cell {
-        return new Cell({
-            a: vectors[0],
-            b: vectors[1],
-            c: vectors[2],
-        });
-    }
-
-    get _a() {
-        return new Cell.RoundedVector3DClassReference(this.a);
-    }
-
-    get _b() {
-        return new Cell.RoundedVector3DClassReference(this.b);
-    }
-
-    get _c() {
-        return new Cell.RoundedVector3DClassReference(this.c);
-    }
-
-    get vectorArrays(): Matrix3X3Schema {
-        return [this._a.value, this._b.value, this._c.value];
-    }
-
-    get vectorArraysRounded(): Matrix3X3Schema {
-        return [this._a.valueRounded, this._b.valueRounded, this._c.valueRounded];
-    }
-
-    get volume(): number {
-        return Utils.math.det(this.vectorArrays);
-    }
-
-    get volumeRounded(): number {
-        return Utils.math.roundArrayOrNumber(this.volume, Cell.roundPrecision) as number;
-    }
-
-    clone(): Cell {
-        return new Cell({ a: this.a, b: this.b, c: this.c });
-    }
-
-    cloneAndScaleByMatrix(matrix: Matrix3X3Schema) {
-        const newCell = this.clone();
-        newCell.scaleByMatrix(matrix);
-        return newCell;
-    }
-
-    convertPointToCartesian(point: Coordinate3DSchema): Coordinate3DSchema {
-        return MULT(point, this.vectorArrays) as unknown as Coordinate3DSchema;
-    }
-
-    convertPointToCrystal(point: Coordinate3DSchema): Coordinate3DSchema {
-        return MULT(point, INV(this.vectorArrays)) as unknown as Coordinate3DSchema;
-    }
-
-    isPointInsideCellCartesian(point: Coordinate3DSchema): boolean {
-        const { tolerance } = this.constructor as typeof Cell;
-        return (
-            this.convertPointToCrystal(point)
-                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
-                // @ts-ignore
-                .reduce((a: boolean, b: boolean): boolean => a && b)
-        );
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    isPointInsideCellCrystal(point: Coordinate3DSchema): boolean {
-        const { tolerance } = this.constructor as typeof Cell;
-        return (
-            point
-                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
-                // @ts-ignore
-                .reduce((a: boolean, b: boolean): boolean => a && b)
-        );
-    }
-
-    isPointInsideCell(point: Coordinate3DSchema, useCrystal = false): boolean {
-        if (useCrystal) {
-            return this.isPointInsideCellCrystal(point);
-        }
-        return this.isPointInsideCellCartesian(point);
-    }
-
-    getMostCollinearVectorIndex(testVector: Vector3DSchema): number {
-        const angles = this.vectorArrays.map((v) => Utils.math.angleUpTo90(v, testVector, "deg"));
-        return angles.findIndex((el: number) => el === Utils.math.min(angles));
-    }
-
-    scaleByMatrix(matrix: number[][]) {
-        // @ts-ignore - mathjs v12 multiply return type is broader than runtime
-        [this.a, this.b, this.c] = MATRIX_MULT(matrix, this.vectorArrays);
-    }
-
-    toJSON(): CellSchema {
-        return {
-            a: this._a.toJSON(),
-            b: this._b.toJSON(),
-            c: this._c.toJSON(),
-            alat: this.alat,
-            units: this.units,
-        };
-    }
-}

package/src/js/cell/conventional_cell.ts

@@ -1,86 +0,0 @@
-import { LatticeSchema, LatticeTypeEnum, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
-
-/**
- * Routines for calculating conventional cell vectors from primitive cell Bravais parameters.
- * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
- */
-
-const unitMatrix: Matrix3X3Schema = [
-    [1, 0, 0],
-    [0, 1, 0],
-    [0, 0, 1],
-];
-
-// (Conventional cellVectors) = (Primitive cellVectors) * (PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIER matrix)
-export const PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS: Record<string, Matrix3X3Schema> = {
-    // PRIMITIVE    =>  CONVENTIONAL
-    CUB: unitMatrix,
-    FCC: [
-        [-1, 1, 1],
-        [1, -1, 1],
-        [1, 1, -1],
-    ],
-    BCC: [
-        [0, 1, 1],
-        [1, 0, 1],
-        [1, 1, 0],
-    ],
-    TET: unitMatrix,
-    BCT: [
-        [0, 1, 1],
-        [1, 0, 1],
-        [1, 1, 0],
-    ],
-    ORC: unitMatrix,
-    ORCF: [
-        [-1, 1, 1],
-        [1, -1, 1],
-        [1, 1, -1],
-    ],
-    ORCI: [
-        [0, 1, 1],
-        [1, 0, 1],
-        [1, 1, 0],
-    ],
-    ORCC: [
-        [1, -1, 0],
-        [1, 1, 0],
-        [0, 0, 1],
-    ],
-    HEX: unitMatrix,
-    RHL: unitMatrix,
-    MCL: unitMatrix,
-    MCLC: [
-        [1, -1, 0],
-        [1, 1, 0],
-        [0, 0, 1],
-    ],
-    TRI: unitMatrix,
-};
-
-export const PRIMITIVE_TO_CONVENTIONAL_CELL_LATTICE_TYPES: {
-    [key in LatticeTypeEnum]: LatticeTypeEnum;
-} = {
-    // PRIMITIVE    =>  CONVENTIONAL
-    CUB: "CUB",
-    FCC: "CUB",
-    BCC: "CUB",
-    TET: "TET",
-    BCT: "TET",
-    ORC: "ORC",
-    ORCF: "ORC",
-    ORCI: "ORC",
-    ORCC: "ORC",
-    HEX: "HEX",
-    RHL: "RHL",
-    MCL: "MCL",
-    MCLC: "MCL",
-    TRI: "TRI",
-};
-
-export function isConventionalCellSameAsPrimitiveForLatticeType(
-    latticeType: LatticeSchema["type"],
-): boolean {
-    const multiplier = PRIMITIVE_TO_CONVENTIONAL_CELL_MULTIPLIERS[latticeType || "TRI"];
-    return multiplier === unitMatrix;
-}

package/src/js/cell/primitive_cell.ts

@@ -1,166 +0,0 @@
-import { LatticeSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
-import { Utils } from "@mat3ra/utils";
-
-/**
- * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
- * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
- */
-const PRIMITIVE_CELLS = {
-    CUB: ({ a }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [a, 0, 0],
-            [0, a, 0],
-            [0, 0, a],
-        ];
-    },
-
-    FCC: ({ a }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [0.0, a / 2, a / 2],
-            [a / 2, 0.0, a / 2],
-            [a / 2, a / 2, 0.0],
-        ];
-    },
-
-    BCC: ({ a }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [-a / 2, a / 2, a / 2],
-            [a / 2, -a / 2, a / 2],
-            [a / 2, a / 2, -a / 2],
-        ];
-    },
-
-    TET: ({ a, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [a, 0, 0],
-            [0, a, 0],
-            [0, 0, c],
-        ];
-    },
-
-    BCT: ({ a, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [-a / 2, a / 2, c / 2],
-            [a / 2, -a / 2, c / 2],
-            [a / 2, a / 2, -c / 2],
-        ];
-    },
-
-    ORC: ({ a, b, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [a, 0, 0],
-            [0, b, 0],
-            [0, 0, c],
-        ];
-    },
-
-    ORCF: ({ a, b, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [0, b / 2, c / 2],
-            [a / 2, 0, c / 2],
-            [a / 2, b / 2, 0],
-        ];
-    },
-
-    ORCI: ({ a, b, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [-a / 2, b / 2, c / 2],
-            [a / 2, -b / 2, c / 2],
-            [a / 2, b / 2, -c / 2],
-        ];
-    },
-
-    ORCC: ({ a, b, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [a / 2, b / 2, 0],
-            [-a / 2, b / 2, 0],
-            [0, 0, c],
-        ];
-    },
-
-    HEX: ({ a, c }: LatticeSchema): Matrix3X3Schema => {
-        return [
-            [a / 2, (-a * Number(Utils.math.sqrt(3))) / 2, 0],
-            [a / 2, (a * Number(Utils.math.sqrt(3))) / 2, 0],
-            [0, 0, c],
-        ];
-    },
-
-    RHL: ({ a, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
-        const cosHalfAlpha = Number(Utils.math.sqrt((1 / 2) * (1 + cosAlpha)));
-        const sinHalfAlpha = Number(Utils.math.sqrt((1 / 2) * (1 - cosAlpha)));
-        return [
-            [a * cosHalfAlpha, -a * sinHalfAlpha, 0.0],
-            [a * cosHalfAlpha, a * sinHalfAlpha, 0.0],
-            [
-                (a * cosAlpha) / cosHalfAlpha,
-                0.0,
-                a *
-                    Number(
-                        Utils.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
-                    ),
-            ],
-        ];
-    },
-
-    MCL: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
-        return [
-            [a, 0, 0],
-            [0, b, 0],
-            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
-        ];
-    },
-
-    MCLC: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
-        return [
-            [a / 2, b / 2, 0],
-            [-a / 2, b / 2, 0],
-            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
-        ];
-    },
-
-    // Algorithm from http://pymatgen.org/_modules/pymatgen/core/lattice.html (from_params)
-    TRI: ({ a, b, c, alpha, beta, gamma }: LatticeSchema): Matrix3X3Schema => {
-        // convert angles to Radians
-        // eslint-disable-next-line no-param-reassign
-        [alpha, beta, gamma] = [alpha, beta, gamma].map((x) =>
-            Number(Utils.math.unit(x, "degree").to("rad").value),
-        );
-
-        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) =>
-            Number(Utils.math.cos(x)),
-        );
-        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => Number(Utils.math.sin(x)));
-        let acosArg = (cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta);
-        if (acosArg < -1) {
-            acosArg = -1;
-        } else if (acosArg > 1) {
-            acosArg = 1;
-        }
-        const gammaStar = Number(Utils.math.acos(acosArg));
-        const cosGammaStar = Number(Utils.math.cos(gammaStar));
-        const sinGammaStar = Number(Utils.math.sin(gammaStar));
-
-        return [
-            [a * sinBeta, 0.0, a * cosBeta],
-            [-b * sinAlpha * cosGammaStar, b * sinAlpha * sinGammaStar, b * cosAlpha],
-            [0.0, 0.0, c],
-        ];
-    },
-};
-
-/**
- * Returns lattice vectors for a primitive cell for a lattice.
- * @param latticeConfig - Lattice config.
- * @return Cell.vectorsAsArray
- */
-export function getPrimitiveLatticeVectorsFromConfig(
-    latticeConfig: LatticeSchema,
-): Matrix3X3Schema {
-    const primitiveCellGenerator = PRIMITIVE_CELLS[latticeConfig.type || "TRI"];
-    const [vectorA, vectorB, vectorC] = primitiveCellGenerator(latticeConfig);
-    return [vectorA, vectorB, vectorC];
-}

package/src/js/constants/molecule.ts

@@ -1,18 +0,0 @@
-/**
- * Constants for molecule handling and precision.
- * Source of truth: /constants.json at repository root
- *
- * These values are duplicated here for TypeScript compilation.
- * When updating these, also update constants.json.
- */
-
-export const defaultNonPeriodicMinimumLatticeSize = 3.0;
-export const diatomicLatticePaddingFactor = 3.0;
-export const molecularLatticePaddingFactor = 2.0;
-
-export const PRECISION_MAP = {
-    coordinatesCrystal: 9,
-    coordinatesCartesian: 6,
-    latticeLengths: 6,
-    latticeAngles: 4,
-};

package/src/js/constants.ts

@@ -1,4 +0,0 @@
-// TODO: adjust the imports and remove the need for re-exporting
-export * from "@mat3ra/code/dist/js/constants";
-// eslint-disable-next-line no-restricted-exports
-export { default } from "@mat3ra/code/dist/js/constants";