@mat3ra/mode 2025.11.5-0 → 2025.11.5-2

package/dist/js/default_methods.d.ts

@@ -0,0 +1,6 @@
+import { BaseMethod, BaseModel, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+export declare const PseudopotentialMethodConfig: BaseMethod;
+export declare const LocalOrbitalMethodConfig: BaseMethod;
+export declare const UnknownMethodConfig: BaseMethod;
+export declare function allowedTypes(model: Pick<BaseModel, "type" | "subtype">): SlugifiedEntry[];
+export declare function allowedSubtypes(model: Pick<BaseModel, "type" | "subtype">, type: string): SlugifiedEntry[];

package/dist/js/default_methods.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownMethodConfig = exports.LocalOrbitalMethodConfig = exports.PseudopotentialMethodConfig = void 0;
+exports.allowedTypes = allowedTypes;
+exports.allowedSubtypes = allowedSubtypes;
+const lodash_1 = __importDefault(require("lodash"));
+const tree_1 = require("./tree");
+exports.PseudopotentialMethodConfig = {
+    type: "pseudopotential",
+    subtype: "us",
+};
+exports.LocalOrbitalMethodConfig = {
+    type: "localorbital",
+    subtype: "pople",
+};
+exports.UnknownMethodConfig = {
+    type: "unknown",
+    subtype: "unknown",
+};
+const mapSlugToNamedObject = (slug) => {
+    return {
+        slug,
+        name: lodash_1.default.get(tree_1.MODEL_NAMES, slug, slug),
+    };
+};
+function allowedTypes(model) {
+    const branch = lodash_1.default.get(tree_1.MODEL_TREE, `${model.type}.${model.subtype}.methods`, {});
+    return lodash_1.default.keys(branch).map(mapSlugToNamedObject);
+}
+function allowedSubtypes(model, type) {
+    const branch = lodash_1.default.get(tree_1.MODEL_TREE, `${model.type}.${model.subtype}.methods.${type}`, []);
+    return branch.map(mapSlugToNamedObject);
+}

package/dist/js/default_models.d.ts

@@ -0,0 +1,3 @@
+import type { ModelConfig } from "./types";
+export declare const DFTModelConfig: ModelConfig;
+export declare const UnknownModelConfig: ModelConfig;

package/dist/js/default_models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownModelConfig = exports.DFTModelConfig = void 0;
+exports.DFTModelConfig = {
+    type: "dft",
+    subtype: "gga",
+};
+exports.UnknownModelConfig = {
+    type: "unknown",
+    subtype: "unknown",
+};

package/dist/js/generated/MethodSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BaseMethod } from "@mat3ra/esse/dist/js/types";
+export type MethodSchemaMixin = BaseMethod;
+export type MethodInMemoryEntity = InMemoryEntity & MethodSchemaMixin;
+export declare function methodSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/MethodSchemaMixin.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodSchemaMixin = methodSchemaMixin;
+function methodSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.requiredProp("type");
+        },
+        get subtype() {
+            return this.requiredProp("subtype");
+        },
+        get precision() {
+            return this.prop("precision");
+        },
+        get data() {
+            return this.prop("data");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ModelSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BaseModel } from "@mat3ra/esse/dist/js/types";
+export type ModelSchemaMixin = BaseModel;
+export type ModelInMemoryEntity = InMemoryEntity & ModelSchemaMixin;
+export declare function modelSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ModelSchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelSchemaMixin = modelSchemaMixin;
+function modelSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.requiredProp("type");
+        },
+        get subtype() {
+            return this.requiredProp("subtype");
+        },
+        get method() {
+            return this.requiredProp("method");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/index.d.ts

@@ -0,0 +1,12 @@
+import * as default_methods from "./default_methods";
+import * as default_models from "./default_models";
+import { Method } from "./method";
+import { MethodConversionHandler } from "./methodConversionHandler";
+import { MethodFactory } from "./methods/factory";
+import { PseudopotentialMethod } from "./methods/pseudopotential";
+import { Model } from "./model";
+import { ModelConversionHandler } from "./modelConversionHandler";
+import { DFTModel } from "./models/dft";
+import { ModelFactory } from "./models/factory";
+import * as tree from "./tree";
+export { Method, Model, MethodFactory, ModelFactory, PseudopotentialMethod, DFTModel, MethodConversionHandler, ModelConversionHandler, tree, default_models, default_methods, };

package/dist/js/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default_methods = exports.default_models = exports.tree = exports.ModelConversionHandler = exports.MethodConversionHandler = exports.DFTModel = exports.PseudopotentialMethod = exports.ModelFactory = exports.MethodFactory = exports.Model = exports.Method = void 0;
+const default_methods = __importStar(require("./default_methods"));
+exports.default_methods = default_methods;
+const default_models = __importStar(require("./default_models"));
+exports.default_models = default_models;
+const method_1 = require("./method");
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return method_1.Method; } });
+const methodConversionHandler_1 = require("./methodConversionHandler");
+Object.defineProperty(exports, "MethodConversionHandler", { enumerable: true, get: function () { return methodConversionHandler_1.MethodConversionHandler; } });
+const factory_1 = require("./methods/factory");
+Object.defineProperty(exports, "MethodFactory", { enumerable: true, get: function () { return factory_1.MethodFactory; } });
+const pseudopotential_1 = require("./methods/pseudopotential");
+Object.defineProperty(exports, "PseudopotentialMethod", { enumerable: true, get: function () { return pseudopotential_1.PseudopotentialMethod; } });
+const model_1 = require("./model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });
+const modelConversionHandler_1 = require("./modelConversionHandler");
+Object.defineProperty(exports, "ModelConversionHandler", { enumerable: true, get: function () { return modelConversionHandler_1.ModelConversionHandler; } });
+const dft_1 = require("./models/dft");
+Object.defineProperty(exports, "DFTModel", { enumerable: true, get: function () { return dft_1.DFTModel; } });
+const factory_2 = require("./models/factory");
+Object.defineProperty(exports, "ModelFactory", { enumerable: true, get: function () { return factory_2.ModelFactory; } });
+const tree = __importStar(require("./tree"));
+exports.tree = tree;

package/dist/js/method.d.ts

@@ -0,0 +1,22 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { BaseMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import { type MethodSchemaMixin } from "./generated/MethodSchemaMixin";
+type Base = typeof InMemoryEntity & Constructor<MethodSchemaMixin>;
+interface MethodData extends Record<string, unknown> {
+    searchText?: string;
+}
+declare const Method_base: Base;
+export declare class Method extends Method_base implements BaseMethod {
+    constructor(config: BaseMethod);
+    cloneWithoutData(): Method;
+    setSubtype(subtype: SlugifiedEntry): void;
+    static get defaultConfig(): BaseMethod;
+    get searchText(): string;
+    setSearchText(searchText: string): void;
+    setData(data?: MethodData): void;
+    get omitInHashCalculation(): boolean;
+    cleanData(fieldsToExclude?: string[]): MethodData;
+    toJSONWithCleanData(fieldsToExclude?: string[]): BaseMethod;
+}
+export {};

package/dist/js/method.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Method = void 0;
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const default_methods_1 = require("./default_methods");
+const MethodSchemaMixin_1 = require("./generated/MethodSchemaMixin");
+class Method extends entity_1.InMemoryEntity {
+    constructor(config) {
+        const data = config.data || {};
+        super({ ...config, data });
+    }
+    cloneWithoutData() {
+        const clone = this.clone();
+        clone.setData({});
+        return clone;
+    }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+    }
+    static get defaultConfig() {
+        return default_methods_1.PseudopotentialMethodConfig;
+    }
+    get searchText() {
+        return this.prop("data.searchText", "");
+    }
+    setSearchText(searchText) {
+        this.setData({ ...this.data, searchText });
+    }
+    setData(data = {}) {
+        this.setProp("data", data);
+    }
+    get omitInHashCalculation() {
+        const data = this.data;
+        return !(data === null || data === void 0 ? void 0 : data.searchText) && lodash_1.default.isEmpty(lodash_1.default.omit(data, "searchText"));
+    }
+    cleanData(fieldsToExclude = []) {
+        const filteredData = { ...this.data };
+        fieldsToExclude.forEach((field) => {
+            delete filteredData[field];
+        });
+        return filteredData;
+    }
+    toJSONWithCleanData(fieldsToExclude = []) {
+        const json = { ...this._json, data: this.cleanData(fieldsToExclude) };
+        return (0, utils_1.deepClone)(json);
+    }
+}
+exports.Method = Method;
+(0, MethodSchemaMixin_1.methodSchemaMixin)(Method.prototype);

package/dist/js/methodConversionHandler.d.ts

@@ -0,0 +1,14 @@
+import { BaseMethod, CategorizedMethod, CategorizedUnitMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import type { SimplifiedCategorizedMethod } from "./types";
+export declare function safelyGetSlug(slugObj: SlugifiedEntry | string): SlugifiedEntry["slug"];
+export declare class MethodConversionHandler {
+    static convertToSimple(categorizedMethod: CategorizedMethod | undefined): BaseMethod;
+    static convertUnknownToSimple(): BaseMethod;
+    static convertPspUnitsToSimple(units: CategorizedUnitMethod[]): BaseMethod;
+    static convertAoUnitToSimple(): BaseMethod;
+    static convertRegressionUnitToSimple(unit: CategorizedUnitMethod): BaseMethod;
+    static convertToCategorized(simpleMethod: BaseMethod | undefined, allMethods?: CategorizedMethod[]): SimplifiedCategorizedMethod | undefined;
+    static convertPspToCategorized(simpleMethod: BaseMethod, allMethods?: CategorizedMethod[]): SimplifiedCategorizedMethod | undefined;
+    static convertAoToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod;
+    static convertRegressionToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod;
+}

package/dist/js/methodConversionHandler.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+const default_methods_1 = require("./default_methods");
+function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+class MethodConversionHandler {
+    static convertToSimple(categorizedMethod) {
+        if (!categorizedMethod)
+            return this.convertUnknownToSimple();
+        const pspUnits = categorizedMethod.units.filter((unit) => { var _a; return ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.type) === "psp"; });
+        const aoUnit = categorizedMethod.units.find((unit) => { var _a; return ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.type) === "ao"; });
+        const regressionUnit = categorizedMethod.units.find((unit) => {
+            return unit.name && unit.name.includes("regression");
+        });
+        if (pspUnits.length)
+            return this.convertPspUnitsToSimple(pspUnits);
+        if (aoUnit)
+            return this.convertAoUnitToSimple();
+        if (regressionUnit)
+            return this.convertRegressionUnitToSimple(regressionUnit);
+        return this.convertUnknownToSimple();
+    }
+    static convertUnknownToSimple() {
+        return default_methods_1.UnknownMethodConfig;
+    }
+    static convertPspUnitsToSimple(units) {
+        var _a;
+        const [firstUnit, ...otherUnits] = units;
+        if (!firstUnit || !((_a = firstUnit.categories) === null || _a === void 0 ? void 0 : _a.subtype))
+            return this.convertUnknownToSimple();
+        const subtype = otherUnits.length ? "any" : safelyGetSlug(firstUnit.categories.subtype);
+        return {
+            type: "pseudopotential",
+            subtype,
+        };
+    }
+    static convertAoUnitToSimple() {
+        return default_methods_1.LocalOrbitalMethodConfig;
+    }
+    static convertRegressionUnitToSimple(unit) {
+        var _a, _b;
+        const type = ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.type) || "linear";
+        const subtype = ((_b = unit.categories) === null || _b === void 0 ? void 0 : _b.subtype) || "least_squares";
+        return {
+            type: safelyGetSlug(type),
+            subtype: safelyGetSlug(subtype),
+            precision: unit.precision,
+        };
+    }
+    static convertToCategorized(simpleMethod, allMethods = []) {
+        switch (simpleMethod === null || simpleMethod === void 0 ? void 0 : simpleMethod.type) {
+            case "pseudopotential":
+                return this.convertPspToCategorized(simpleMethod, allMethods);
+            case "localorbital":
+                return this.convertAoToCategorized(simpleMethod);
+            case "linear":
+            case "kernel_ridge":
+                return this.convertRegressionToCategorized(simpleMethod);
+            default:
+                return undefined;
+        }
+    }
+    static convertPspToCategorized(simpleMethod, allMethods = []) {
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        // the "any" subtype is equivalent to the method representing all planewave-pseudopotential
+        // methods. All other subtypes are equivalent to using a specific PW-PSP method.
+        const allPath = "/qm/wf/none/psp/us::/qm/wf/none/psp/nc::/qm/wf/none/psp/nc-fr::/qm/wf/none/psp/paw::/qm/wf/none/pw/none";
+        const path = subtype === "any"
+            ? allPath
+            : `/qm/wf/none/smearing/gaussian::/linalg/diag/none/davidson/none::/qm/wf/none/psp/${subtype}::/qm/wf/none/pw/none`;
+        return allMethods.find((categorized) => categorized.path === path);
+    }
+    static convertAoToCategorized(simpleMethod) {
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        return {
+            units: [
+                {
+                    parameters: {
+                        basisSlug: "6-31G",
+                    },
+                    categories: {
+                        tier1: "qm",
+                        tier2: "wf",
+                        type: "ao",
+                        subtype,
+                    },
+                    tags: ["atomic orbital"],
+                    name: "Wave function: LCAO - Pople basis set (6-31G)",
+                    path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+                },
+            ],
+            name: "Wave function: LCAO - Pople basis set (6-31G)",
+            path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+        };
+    }
+    static convertRegressionToCategorized(simpleMethod) {
+        const type = safelyGetSlug(simpleMethod.type);
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        const precision = simpleMethod.precision;
+        const path = `/none/none/none/${type}/${subtype}`;
+        const nameMap = {
+            kernel_ridge: "Kernel ridge",
+            linear: "Linear",
+            least_squares: "least squares",
+            ridge: "ridge",
+        };
+        const name = `${nameMap[type] || type} ${nameMap[subtype] || subtype} regression`;
+        return {
+            units: [
+                {
+                    categories: {
+                        type,
+                        subtype,
+                    },
+                    name,
+                    path,
+                    precision,
+                },
+            ],
+            name,
+            path,
+        };
+    }
+}
+exports.MethodConversionHandler = MethodConversionHandler;

package/dist/js/methods/factory.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import { Method } from "../method";
+import { PseudopotentialMethod } from "./pseudopotential";
+export declare class MethodFactory {
+    static Method: typeof Method;
+    static PseudopotentialMethod: typeof PseudopotentialMethod;
+    static create(config: BaseMethod): Method;
+}

package/dist/js/methods/factory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodFactory = void 0;
+const method_1 = require("../method");
+const pseudopotential_1 = require("./pseudopotential");
+class MethodFactory {
+    static create(config) {
+        switch (config.type) {
+            case "pseudopotential":
+                return new this.PseudopotentialMethod(config);
+            default:
+                return new this.Method(config);
+        }
+    }
+}
+exports.MethodFactory = MethodFactory;
+MethodFactory.Method = method_1.Method;
+MethodFactory.PseudopotentialMethod = pseudopotential_1.PseudopotentialMethod;

package/dist/js/methods/pseudopotential.d.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import { Method } from "../method";
+import type { PseudopotentialCtor, PseudopotentialLike } from "../types";
+export declare class PseudopotentialMethod extends Method {
+    PseudopotentialCls: PseudopotentialCtor | null;
+    constructor(config: BaseMethod);
+    get pseudo(): Record<string, unknown>[];
+    get allPseudo(): Record<string, unknown>[];
+    get pseudopotentials(): PseudopotentialLike[];
+    get allPseudopotentials(): PseudopotentialLike[];
+    static extractExchangeCorrelationFromSubworkflow(subworkflow: any): {
+        approximation: string;
+        functional: string;
+    };
+    hasPseudopotentialFor(element: string): boolean;
+    setPseudopotentialPerElement(pseudo: PseudopotentialLike | undefined): void;
+    addToAllPseudos(pseudos: PseudopotentialLike | PseudopotentialLike[]): void;
+    setPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
+    setAllPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
+    toJSONWithCleanData(exclude?: string[]): BaseMethod;
+}

package/dist/js/methods/pseudopotential.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudopotentialMethod = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const underscore_1 = __importDefault(require("underscore"));
+const method_1 = require("../method");
+class PseudopotentialMethod extends method_1.Method {
+    constructor(config) {
+        super(config);
+        this.PseudopotentialCls = null;
+    }
+    get pseudo() {
+        return this.prop("data.pseudo", []);
+    }
+    get allPseudo() {
+        return this.prop("data.allPseudo", []);
+    }
+    get pseudopotentials() {
+        if (!this.PseudopotentialCls)
+            return [];
+        return this.pseudo.map((config) => new this.PseudopotentialCls(config));
+    }
+    get allPseudopotentials() {
+        if (!this.PseudopotentialCls)
+            return [];
+        return this.allPseudo.map((config) => new this.PseudopotentialCls(config));
+    }
+    static extractExchangeCorrelationFromSubworkflow(subworkflow) {
+        const { model } = subworkflow;
+        const approximation = model.subtype;
+        const functionalValue = model.functional;
+        const functional = functionalValue && (functionalValue.slug || functionalValue);
+        return {
+            approximation,
+            functional: functional || "",
+        };
+    }
+    hasPseudopotentialFor(element) {
+        return Boolean(this.pseudopotentials.find((pseudo) => pseudo.element === element));
+    }
+    setPseudopotentialPerElement(pseudo) {
+        if (!pseudo) {
+            this.setPseudopotentials([]);
+            return;
+        }
+        const filtered = this.pseudopotentials.filter((item) => item.element !== pseudo.element);
+        filtered.push(pseudo);
+        this.setPseudopotentials(filtered);
+    }
+    addToAllPseudos(pseudos) {
+        const list = (0, utils_1.safeMakeArray)(pseudos);
+        const all = this.allPseudopotentials;
+        all.push(...list);
+        this.setAllPseudopotentials(all);
+    }
+    setPseudopotentials(pseudopotentials) {
+        this.setData({
+            ...this.data,
+            pseudo: underscore_1.default.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+    setAllPseudopotentials(pseudopotentials) {
+        this.setData({
+            ...this.data,
+            allPseudo: underscore_1.default.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+    toJSONWithCleanData(exclude = []) {
+        return super.toJSONWithCleanData(exclude.concat(["allPseudo"]));
+    }
+}
+exports.PseudopotentialMethod = PseudopotentialMethod;

package/dist/js/model.d.ts

@@ -0,0 +1,38 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ApplicationSchemaBase, BaseMethod, BaseModel, SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import { type ModelSchemaMixin } from "./generated/ModelSchemaMixin";
+import { Method } from "./method";
+import { MethodFactory } from "./methods/factory";
+import type { ModelConfig, MethodTreeBranch, ModelTree } from "./types";
+type Base = typeof InMemoryEntity & Constructor<ModelSchemaMixin>;
+declare const Model_base: Base;
+export declare class Model extends Model_base implements BaseModel {
+    protected _application?: ApplicationSchemaBase;
+    protected _MethodFactory: typeof MethodFactory;
+    protected _method?: Method;
+    constructor(config: ModelConfig);
+    setSubtype(subtype: SlugifiedEntryOrSlug): void;
+    get allowedTypes(): SlugifiedEntry[];
+    get allowedSubtypes(): SlugifiedEntry[];
+    get defaultType(): string;
+    get defaultSubtype(): string;
+    get tree(): ModelTree;
+    get treeBranchForType(): Record<string, MethodTreeBranch>;
+    get treeBranchForSubType(): MethodTreeBranch;
+    get treeByApplicationNameAndVersion(): ModelTree | undefined;
+    get groupSlug(): string;
+    get Method(): Method;
+    setMethod(method: Method): void;
+    get methodsFromTree(): Record<string, string[]>;
+    get methodTypes(): SlugifiedEntry[];
+    get methodSubtypes(): SlugifiedEntry[];
+    get defaultMethodConfig(): BaseMethod;
+    static get defaultConfig(): ModelConfig;
+    static get allTypes(): SlugifiedEntry[];
+    toJSON(): Record<string, unknown>;
+    protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry;
+    get isUnknown(): boolean;
+    protected get subtypeSlug(): string;
+}
+export {};

package/dist/js/model.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const lodash_1 = __importDefault(require("lodash"));
+const default_models_1 = require("./default_models");
+const ModelSchemaMixin_1 = require("./generated/ModelSchemaMixin");
+const method_1 = require("./method");
+const factory_1 = require("./methods/factory");
+const tree_1 = require("./tree");
+const EMPTY_BRANCH = { methods: {} };
+class Model extends entity_1.InMemoryEntity {
+    constructor(config) {
+        const { application, ...entityConfig } = config;
+        super(entityConfig);
+        this._application = application;
+        this._MethodFactory = factory_1.MethodFactory;
+    }
+    // get type(): string {
+    //     return this.prop<string>("type", this.defaultType);
+    // }
+    // get subtype(): StringOrNamedSlug {
+    //     return this.prop<StringOrNamedSlug>("subtype", this.defaultSubtype);
+    // }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+    get allowedTypes() {
+        return Object.keys(this.tree).map((modelSlug) => (0, tree_1.treeSlugToNamedObject)(modelSlug));
+    }
+    get allowedSubtypes() {
+        return Object.keys(this.treeBranchForType).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get defaultType() {
+        var _a;
+        return ((_a = this.allowedTypes[0]) === null || _a === void 0 ? void 0 : _a.slug) || "";
+    }
+    get defaultSubtype() {
+        var _a;
+        return ((_a = this.allowedSubtypes[0]) === null || _a === void 0 ? void 0 : _a.slug) || "";
+    }
+    get tree() {
+        if (this._application) {
+            const treeByApplication = this.treeByApplicationNameAndVersion;
+            if (treeByApplication)
+                return treeByApplication;
+        }
+        return tree_1.MODEL_TREE;
+    }
+    get treeBranchForType() {
+        return this.tree[this.type] || {};
+    }
+    get treeBranchForSubType() {
+        return this.treeBranchForType[this.subtypeSlug] || EMPTY_BRANCH;
+    }
+    get treeByApplicationNameAndVersion() {
+        if (!this._application)
+            return undefined;
+        const { name, version } = this._application;
+        return (0, tree_1.getTreeByApplicationNameAndVersion)({ name, version });
+    }
+    get groupSlug() {
+        const subtype = this.subtypeSlug;
+        if (!this._application)
+            return `${this.type}:${subtype}`;
+        return `${this._application.shortName}:${this.type}:${subtype}`;
+    }
+    get Method() {
+        if (!this._method) {
+            const methodOrConfig = this.method;
+            const config = methodOrConfig || this.defaultMethodConfig;
+            this._method = this._MethodFactory.create(config);
+        }
+        return this._method;
+    }
+    setMethod(method) {
+        this._method = method;
+    }
+    get methodsFromTree() {
+        return this.treeBranchForSubType.methods || {};
+    }
+    get methodTypes() {
+        return Object.keys(this.methodsFromTree).map((type) => (0, tree_1.treeSlugToNamedObject)(type));
+    }
+    get methodSubtypes() {
+        const { type } = this.method;
+        const subtypes = this.methodsFromTree[type] || [];
+        return subtypes.map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get defaultMethodConfig() {
+        var _a;
+        const methodTypes = Object.keys(this.methodsFromTree);
+        const type = methodTypes[0];
+        if (!type)
+            return method_1.Method.defaultConfig;
+        const subtype = (_a = this.methodsFromTree[type]) === null || _a === void 0 ? void 0 : _a[0];
+        if (!subtype)
+            return method_1.Method.defaultConfig;
+        return { type, subtype };
+    }
+    static get defaultConfig() {
+        return {
+            ...default_models_1.DFTModelConfig,
+            method: method_1.Method.defaultConfig,
+        };
+    }
+    static get allTypes() {
+        return Object.keys(tree_1.MODEL_TREE).map((modelSlug) => (0, tree_1.treeSlugToNamedObject)(modelSlug));
+    }
+    toJSON() {
+        const json = super.toJSON();
+        return {
+            ...json,
+            type: this.type,
+            subtype: this.subtype,
+            method: this.Method.toJSONWithCleanData(),
+        };
+    }
+    _stringToSlugifiedObject(slug) {
+        if (lodash_1.default.isString(slug)) {
+            return { slug };
+        }
+        return slug;
+    }
+    get isUnknown() {
+        return this.type === "unknown";
+    }
+    get subtypeSlug() {
+        const subtype = this.subtype;
+        return typeof subtype === "string" ? subtype : subtype.slug;
+    }
+}
+exports.Model = Model;
+(0, ModelSchemaMixin_1.modelSchemaMixin)(Model.prototype);

package/dist/js/modelConversionHandler.d.ts

@@ -0,0 +1,12 @@
+import { CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import type { ModelConfig, SimplifiedCategorizedModel } from "./types";
+export declare function safelyGetSlug(slugObj: SlugifiedEntryOrSlug): string;
+export declare class ModelConversionHandler {
+    static convertToSimple(categorizedModel: CategorizedModel | undefined): ModelConfig;
+    static convertDftToSimple(categorizedModel: CategorizedModel): ModelConfig;
+    static convertMlToSimple(): ModelConfig;
+    static convertUnknownToSimple(): ModelConfig;
+    static convertToCategorized(simpleModel: ModelConfig | undefined, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | undefined;
+    static convertDftToCategorized(simpleModel: ModelConfig, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | undefined;
+    static convertMlToCategorized(simpleModel: ModelConfig): SimplifiedCategorizedModel;
+}

package/dist/js/modelConversionHandler.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+const tree = __importStar(require("./tree"));
+function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+class ModelConversionHandler {
+    static convertToSimple(categorizedModel) {
+        if (!categorizedModel)
+            return this.convertUnknownToSimple();
+        switch (categorizedModel.categories.tier3) {
+            case "dft":
+                return this.convertDftToSimple(categorizedModel);
+            case "ml":
+                return this.convertMlToSimple();
+            default:
+                return this.convertUnknownToSimple();
+        }
+    }
+    static convertDftToSimple(categorizedModel) {
+        var _a, _b;
+        if (!((_a = categorizedModel.categories) === null || _a === void 0 ? void 0 : _a.subtype))
+            return this.convertUnknownToSimple();
+        const subtypeCategory = categorizedModel.categories.subtype;
+        const subtype = safelyGetSlug(subtypeCategory);
+        const functionalParam = (_b = categorizedModel.parameters) === null || _b === void 0 ? void 0 : _b.functional;
+        const functionalSlug = functionalParam
+            ? safelyGetSlug(functionalParam)
+            : "";
+        return {
+            type: "dft",
+            subtype,
+            functional: tree.treeSlugToNamedObject(functionalSlug),
+        };
+    }
+    static convertMlToSimple() {
+        return {
+            type: "ml",
+            subtype: "re",
+        };
+    }
+    static convertUnknownToSimple() {
+        return {
+            type: "unknown",
+            subtype: "unknown",
+        };
+    }
+    static convertToCategorized(simpleModel, allModels = []) {
+        switch (simpleModel === null || simpleModel === void 0 ? void 0 : simpleModel.type) {
+            case "dft":
+                return this.convertDftToCategorized(simpleModel, allModels);
+            case "ml":
+                return this.convertMlToCategorized(simpleModel);
+            case "unknown":
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    static convertDftToCategorized(simpleModel, allModels = []) {
+        const { subtype, functional: functionalStringOrObject } = simpleModel;
+        const defaultFunctionals = {
+            lda: "pz",
+            gga: "pbe",
+            hybrid: "b3lyp",
+        };
+        let functional;
+        if (!functionalStringOrObject) {
+            functional = defaultFunctionals[subtype];
+        }
+        else {
+            functional = safelyGetSlug(functionalStringOrObject);
+        }
+        const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+        return allModels.find((categorized) => categorized.path === path);
+    }
+    static convertMlToCategorized(simpleModel) {
+        const subtype = safelyGetSlug(simpleModel.subtype);
+        return {
+            name: "Regression",
+            path: "/st/det/ml/re/none",
+            categories: {
+                tier1: "st",
+                tier2: "det",
+                tier3: "ml",
+                type: subtype,
+            },
+            parameters: {},
+        };
+    }
+}
+exports.ModelConversionHandler = ModelConversionHandler;

package/dist/js/models/dft.d.ts

@@ -0,0 +1,25 @@
+import { SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import { MethodFactory } from "../methods/factory";
+import { Model } from "../model";
+import type { ModelConfig } from "../types";
+export declare class DFTModel extends Model {
+    constructor(config: ModelConfig & {
+        MethodFactory?: typeof MethodFactory;
+    });
+    get groupSlug(): string;
+    get defaultFunctional(): SlugifiedEntry;
+    get defaultRefiners(): SlugifiedEntry[];
+    get defaultModifiers(): SlugifiedEntry[];
+    get functional(): SlugifiedEntry;
+    get refiners(): SlugifiedEntry[];
+    get modifiers(): SlugifiedEntry[];
+    setSubtype(subtype: SlugifiedEntryOrSlug): void;
+    setFunctional(functional: SlugifiedEntryOrSlug): void;
+    private _setArrayProp;
+    setRefiners(refiners: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
+    setModifiers(modifiers: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
+    toJSON(): Record<string, unknown>;
+    get allFunctionals(): SlugifiedEntry[];
+    get allRefiners(): SlugifiedEntry[];
+    get allModifiers(): SlugifiedEntry[];
+}

package/dist/js/models/dft.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DFTModel = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const underscore_1 = __importDefault(require("underscore"));
+const factory_1 = require("../methods/factory");
+const model_1 = require("../model");
+const tree_1 = require("../tree");
+class DFTModel extends model_1.Model {
+    constructor(config) {
+        super(config);
+        this._MethodFactory = config.MethodFactory || factory_1.MethodFactory;
+    }
+    get groupSlug() {
+        var _a;
+        const functionalSlug = this.functional.slug;
+        const refinersSlug = this.refiners.map((o) => o.slug).join("+");
+        const modifiersSlug = this.modifiers.map((o) => o.slug).join("+");
+        const slugs = [
+            (_a = this._application) === null || _a === void 0 ? void 0 : _a.shortName,
+            this.type,
+            this.subtype,
+            functionalSlug,
+            refinersSlug,
+            modifiersSlug,
+        ].filter(Boolean);
+        return slugs.join(":");
+    }
+    get defaultFunctional() {
+        const [slug] = this.treeBranchForSubType.functionals || [];
+        return (0, tree_1.treeSlugToNamedObject)(slug);
+    }
+    get defaultRefiners() {
+        return [];
+    }
+    get defaultModifiers() {
+        return [];
+    }
+    get functional() {
+        return this.prop("functional", this.defaultFunctional);
+    }
+    get refiners() {
+        return this.prop("refiners", this.defaultRefiners);
+    }
+    get modifiers() {
+        return this.prop("modifiers", this.defaultModifiers);
+    }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+        this.setFunctional(this.defaultFunctional);
+    }
+    setFunctional(functional) {
+        this.setProp("functional", this._stringToSlugifiedObject(functional));
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+    _setArrayProp(name, data) {
+        const normalized = (0, utils_1.safeMakeArray)(data).map((item) => this._stringToSlugifiedObject(item));
+        this.setProp(name, normalized);
+        this[`_${name}`] = normalized;
+    }
+    setRefiners(refiners) {
+        this._setArrayProp("refiners", refiners);
+    }
+    setModifiers(modifiers) {
+        this._setArrayProp("modifiers", modifiers);
+    }
+    toJSON() {
+        const pickSlugFromObject = (item) => underscore_1.default.pick(item, "slug");
+        return {
+            ...super.toJSON(),
+            functional: pickSlugFromObject(this.functional),
+            refiners: this.refiners,
+            modifiers: this.modifiers,
+        };
+    }
+    get allFunctionals() {
+        return (this.treeBranchForSubType.functionals || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get allRefiners() {
+        return (this.treeBranchForSubType.refiners || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get allModifiers() {
+        return (this.treeBranchForSubType.modifiers || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+}
+exports.DFTModel = DFTModel;

package/dist/js/models/factory.d.ts

@@ -0,0 +1,9 @@
+import { Model } from "../model";
+import type { ModelConfig } from "../types";
+import { DFTModel } from "./dft";
+export declare class ModelFactory {
+    static DFTModel: typeof DFTModel;
+    static Model: typeof Model;
+    static create(config: ModelConfig): Model;
+    static createFromApplication(config: ModelConfig): Model;
+}

package/dist/js/models/factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelFactory = void 0;
+const model_1 = require("../model");
+const tree_1 = require("../tree");
+const dft_1 = require("./dft");
+class ModelFactory {
+    static create(config) {
+        switch (config.type) {
+            case "dft":
+                return new this.DFTModel(config);
+            default:
+                return new this.Model(config);
+        }
+    }
+    static createFromApplication(config) {
+        const { application } = config;
+        if (!application) {
+            throw new Error("ModelFactory.createFromApplication: application is required");
+        }
+        const type = (0, tree_1.getDefaultModelTypeForApplication)(application);
+        if (!type) {
+            throw new Error(`ModelFactory.createFromApplication: cannot determine model type: ${type}`);
+        }
+        return this.create({ ...config, type });
+    }
+}
+exports.ModelFactory = ModelFactory;
+ModelFactory.DFTModel = dft_1.DFTModel;
+ModelFactory.Model = model_1.Model;

package/dist/js/tree.d.ts

@@ -0,0 +1,15 @@
+import { ApplicationSchemaBase, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import type { ModelTree } from "./types";
+export declare const METHODS: {
+    readonly pseudopotential: "pseudopotential";
+    readonly localorbital: "localorbital";
+    readonly unknown: "unknown";
+};
+export declare const getPseudopotentialTypesFromTree: () => string[];
+export declare const getDFTFunctionalsFromTree: () => string[];
+export declare const getDFTFunctionalsByApproximation: (approximation: string) => string[] | undefined;
+export declare const MODEL_TREE: ModelTree;
+export declare const MODEL_NAMES: Record<string, string>;
+export declare const treeSlugToNamedObject: (modelSlug: string) => SlugifiedEntry;
+export declare const getTreeByApplicationNameAndVersion: ({ name, }: Pick<ApplicationSchemaBase, "name" | "version">) => ModelTree;
+export declare const getDefaultModelTypeForApplication: (application: ApplicationSchemaBase) => string;

package/dist/js/tree.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultModelTypeForApplication = exports.getTreeByApplicationNameAndVersion = exports.treeSlugToNamedObject = exports.MODEL_NAMES = exports.MODEL_TREE = exports.getDFTFunctionalsByApproximation = exports.getDFTFunctionalsFromTree = exports.getPseudopotentialTypesFromTree = exports.METHODS = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const underscore_1 = __importDefault(require("underscore"));
+// TODO: migrate to use manifest instead
+exports.METHODS = {
+    pseudopotential: "pseudopotential",
+    localorbital: "localorbital",
+    unknown: "unknown",
+};
+const methods = {
+    [exports.METHODS.pseudopotential]: ["paw", "nc", "nc-fr", "us"],
+    // TODO: Add additional basis set options, once user choice of specific (i.e 3-21G vs cc-pVDZ) is implemented.
+    [exports.METHODS.localorbital]: ["pople"],
+    [exports.METHODS.unknown]: ["unknown"],
+};
+const getPseudopotentialTypesFromTree = () => methods[exports.METHODS.pseudopotential];
+exports.getPseudopotentialTypesFromTree = getPseudopotentialTypesFromTree;
+// DFT-specific
+const DFTModelRefiners = ["hse", "g0w0"];
+const DFTModelModifiers = ["soc", "magn"];
+const DFTModelTree = {
+    gga: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pbe", "pbesol", "pw91", "other"],
+    },
+    lda: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pz", "pw", "vwn", "other"],
+    },
+    hybrid: {
+        methods,
+        functionals: ["b3lyp", "hse06"],
+    },
+    other: {
+        methods,
+        functionals: ["other"],
+    },
+};
+const getDFTFunctionalsFromTree = () => Object.keys(DFTModelTree);
+exports.getDFTFunctionalsFromTree = getDFTFunctionalsFromTree;
+const getDFTFunctionalsByApproximation = (approximation) => {
+    const branch = DFTModelTree[approximation];
+    return branch && branch.functionals;
+};
+exports.getDFTFunctionalsByApproximation = getDFTFunctionalsByApproximation;
+// GENERAL
+exports.MODEL_TREE = {
+    dft: DFTModelTree,
+    ml: {
+        re: {
+            methods: {
+                linear: ["least_squares", "ridge"],
+                kernel_ridge: ["least_squares"],
+            },
+        },
+    },
+    unknown: {
+        unknown: {
+            methods: {
+                unknown: ["unknown"],
+            },
+        },
+    },
+};
+exports.MODEL_NAMES = {
+    dft: "density functional theory",
+    lda: "local density approximation",
+    gga: "generalized gradient approximation",
+    hybrid: "hybrid functional",
+    ml: "machine learning",
+    re: "regression",
+};
+const treeSlugToNamedObject = (modelSlug) => {
+    return {
+        slug: modelSlug,
+        name: lodash_1.default.get(exports.MODEL_NAMES, modelSlug, modelSlug),
+    };
+};
+exports.treeSlugToNamedObject = treeSlugToNamedObject;
+const VASP_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+const ESPRESSO_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+const NWCHEM_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+["gga", "lda"].forEach((approximation) => {
+    // pick "paw" for vasp
+    VASP_MODELS_TREE.dft[approximation].methods.pseudopotential = VASP_MODELS_TREE.dft[approximation].methods.pseudopotential.splice(0, 1);
+    // assert "us" is the first option
+    ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential =
+        ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential.reverse();
+});
+const UNKNOWN_MODELS_TREE = underscore_1.default.pick(exports.MODEL_TREE, "unknown");
+// const ML_MODELS_TREE = _.pick(MODEL_TREE, "ml");
+const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION = [
+    {
+        name: "vasp",
+        tree: VASP_MODELS_TREE,
+    },
+    {
+        name: "espresso",
+        tree: ESPRESSO_MODELS_TREE,
+    },
+    {
+        name: "python",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "shell",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "jupyterLab",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "nwchem",
+        tree: NWCHEM_MODELS_TREE,
+    },
+    {
+        name: "deepmd",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+];
+const getTreeByApplicationNameAndVersion = ({ name, }) => {
+    // TODO: add logic to filter by version when necessary
+    const cfgs = MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION.filter((cfg) => cfg.name === name).map((cfg) => cfg.tree);
+    return Object.assign({}, ...cfgs);
+};
+exports.getTreeByApplicationNameAndVersion = getTreeByApplicationNameAndVersion;
+const getDefaultModelTypeForApplication = (application) => {
+    return Object.keys((0, exports.getTreeByApplicationNameAndVersion)(application))[0];
+};
+exports.getDefaultModelTypeForApplication = getDefaultModelTypeForApplication;

package/dist/js/types/index.d.ts

@@ -0,0 +1,20 @@
+import type { ApplicationSchemaBase, BaseModel, CategorizedMethod, CategorizedModel, CategorizedUnitMethod } from "@mat3ra/esse/dist/js/types";
+export type ModelConfig = Pick<BaseModel, "type" | "subtype"> & Partial<Omit<BaseModel, "type" | "subtype">> & {
+    application?: ApplicationSchemaBase;
+};
+export type SimplifiedCategorizedModel = Pick<CategorizedModel, "name" | "path" | "categories" | "parameters">;
+export type SimplifiedCategorizedMethod = Pick<CategorizedMethod, "name" | "path"> & {
+    units: CategorizedUnitMethod[];
+};
+export interface PseudopotentialLike {
+    element?: string;
+    toJSON(): Record<string, unknown>;
+}
+export type PseudopotentialCtor = new (config: Record<string, unknown>) => PseudopotentialLike;
+export interface MethodTreeBranch {
+    methods: Record<string, string[]>;
+    functionals?: string[];
+    refiners?: string[];
+    modifiers?: string[];
+}
+export type ModelTree = Record<string, Record<string, MethodTreeBranch>>;

package/dist/js/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,29 +1,27 @@
 {
     "name": "@mat3ra/mode",
-    "version": "2025.11.5-0",
+    "version": "2025.11.5-2",
     "description": "MOdel and method DEfinitions",
     "scripts": {
         "test": "nyc --reporter=text mocha --extension ts --recursive --bail --require ts-node/register/transpile-only \"tests/**/*.test.ts\"",
         "pretest": "npm run transpile",
         "lint": "eslint src tests && prettier --write src tests",
         "lint:fix": "eslint --fix --cache src tests && prettier --write src tests",
-        "transpile": "npm run transpile:js && npm run transpile:ts",
-        "transpile:js": "babel --out-dir dist src",
-        "transpile:ts": "tsc --project tsconfig.json",
+        "transpile": "tsc --project tsconfig.json",
         "prettier": "prettier --check src tests",
         "prepare": "husky install || exit 0",
-        "prepublishOnly": "rm -rf dist; npm run transpile",
+        "prepublishOnly": "rm -rf dist && npm run transpile",
         "generate-mixins": "ts-node scripts/generate-mixins.ts"
     },
     "repository": {
         "type": "git",
         "url": "https://github.com/Exabyte-io/mode.git"
     },
-    "main": "dist/index.js",
+    "main": "dist/js/index.js",
     "types": "dist/js/index.d.ts",
     "files": [
         "/dist",
-        "/src",
+        "/src/js",
         "tsconfig.json"
     ],
     "author": "Exabyte Inc.",

package/src/js/model.ts

@@ -144,7 +144,7 @@ export class Model extends (InMemoryEntity as Base) implements BaseModel {
             ...json,
             type: this.type,
             subtype: this.subtype,
-            method: (this.method as any).toJSONWithCleanData(),
+            method: this.Method.toJSONWithCleanData(),
         };
     }
 

package/tsconfig.json

@@ -1,3 +1,3 @@
 {
-    "extends": "@mat3ra/tsconfig/tsconfig-js-py-dev.json"
+    "extends": "@mat3ra/tsconfig/tsconfig-js-py-transpile.json"
 }