@mat3ra/mode 2026.3.4-0 → 2026.5.28-0

package/src/js/modelConversionHandler.ts

@@ -1,14 +1,19 @@
-import { CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import {
+    type AnyModelSchema,
+    type DFTModelSchema,
+    type MLModelSchema,
+    CategorizedModel,
+    SlugifiedEntryOrSlug,
+} from "@mat3ra/esse/dist/js/types";
 
-import * as tree from "./tree";
-import type { ModelConfig, SimplifiedCategorizedModel } from "./types";
+import type { DFTModelConfig, SimplifiedCategorizedModel, UnknownModelConfig } from "./types";
 
 export function safelyGetSlug(slugObj: SlugifiedEntryOrSlug): string {
     return typeof slugObj === "string" ? slugObj : slugObj.slug;
 }
 
 export class ModelConversionHandler {
-    static convertToSimple(categorizedModel: CategorizedModel | undefined): ModelConfig {
+    static convertToSimple(categorizedModel?: CategorizedModel) {
         if (!categorizedModel) return this.convertUnknownToSimple();
         switch (categorizedModel.categories.tier3) {
             case "dft":
@@ -20,39 +25,46 @@ export class ModelConversionHandler {
         }
     }
 
-    static convertDftToSimple(categorizedModel: CategorizedModel): ModelConfig {
-        if (!categorizedModel.categories?.subtype) return this.convertUnknownToSimple();
-        const subtypeCategory = categorizedModel.categories.subtype as SlugifiedEntryOrSlug;
-        const subtype = safelyGetSlug(subtypeCategory);
-        const functionalParam = (categorizedModel.parameters as any)?.functional;
-        const functionalSlug = functionalParam
-            ? safelyGetSlug(functionalParam as SlugifiedEntryOrSlug)
-            : "";
+    static convertDftToSimple(
+        categorizedModel: CategorizedModel,
+    ): DFTModelConfig | UnknownModelConfig {
+        if (!categorizedModel.categories?.subtype) {
+            return this.convertUnknownToSimple();
+        }
+
+        const model = categorizedModel as {
+            categories: { subtype: SlugifiedEntryOrSlug };
+            parameters: { functional?: SlugifiedEntryOrSlug };
+        };
+
+        const subtype = safelyGetSlug(model.categories.subtype) as DFTModelConfig["subtype"];
+        const functionalParam = model.parameters.functional;
+        const functional = functionalParam
+            ? (safelyGetSlug(functionalParam) as DFTModelConfig["functional"])
+            : undefined;
+
         return {
             type: "dft",
             subtype,
-            functional: tree.treeSlugToNamedObject(functionalSlug),
-        };
+            functional, // old: tree.treeSlugToNamedObject(functional),
+        } as const;
     }
 
-    static convertMlToSimple(): ModelConfig {
+    static convertMlToSimple() {
         return {
             type: "ml",
             subtype: "re",
-        };
+        } as const;
     }
 
-    static convertUnknownToSimple(): ModelConfig {
+    static convertUnknownToSimple() {
         return {
             type: "unknown",
             subtype: "unknown",
-        };
+        } as const;
     }
 
-    static convertToCategorized(
-        simpleModel: ModelConfig | undefined,
-        allModels: CategorizedModel[] = [],
-    ): SimplifiedCategorizedModel | undefined {
+    static convertToCategorized(simpleModel?: AnyModelSchema, allModels?: CategorizedModel[]) {
         switch (simpleModel?.type) {
             case "dft":
                 return this.convertDftToCategorized(simpleModel, allModels);
@@ -66,7 +78,7 @@ export class ModelConversionHandler {
     }
 
     static convertDftToCategorized(
-        simpleModel: ModelConfig,
+        simpleModel: DFTModelSchema,
         allModels: CategorizedModel[] = [],
     ): SimplifiedCategorizedModel | undefined {
         const { subtype, functional: functionalStringOrObject } = simpleModel;
@@ -79,14 +91,16 @@ export class ModelConversionHandler {
         if (!functionalStringOrObject) {
             functional = defaultFunctionals[subtype as string];
         } else {
-            functional = safelyGetSlug(functionalStringOrObject as SlugifiedEntryOrSlug);
+            functional = safelyGetSlug(functionalStringOrObject);
         }
         const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+
         return allModels.find((categorized) => categorized.path === path);
     }
 
-    static convertMlToCategorized(simpleModel: ModelConfig): SimplifiedCategorizedModel {
-        const subtype = safelyGetSlug(simpleModel.subtype as SlugifiedEntryOrSlug);
+    static convertMlToCategorized(simpleModel: MLModelSchema) {
+        const subtype = safelyGetSlug(simpleModel.subtype);
+
         return {
             name: "Regression",
             path: "/st/det/ml/re/none",
@@ -97,6 +111,6 @@ export class ModelConversionHandler {
                 type: subtype,
             },
             parameters: {},
-        };
+        } as const;
     }
 }

package/src/js/models/dft.ts

@@ -1,6 +1,10 @@
 import { safeMakeArray } from "@mat3ra/code/dist/js/utils";
-import { SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
-import _ from "underscore";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import {
+    type DFTModelSchema,
+    SlugifiedEntry,
+    SlugifiedEntryOrSlug,
+} from "@mat3ra/esse/dist/js/types";
 
 import { MethodFactory } from "../methods/factory";
 import { Model } from "../model";
@@ -11,57 +15,64 @@ export class DFTModel extends Model {
     constructor(config: ModelConfig & { MethodFactory?: typeof MethodFactory }) {
         super(config);
         this._MethodFactory = config.MethodFactory || MethodFactory;
+        this.functional =
+            this.prop<DFTModelSchema["functional"]>("functional") || this.defaultFunctional.slug;
     }
 
+    declare type: DFTModelSchema["type"];
+
+    declare subtype: DFTModelSchema["subtype"];
+
     get groupSlug(): string {
-        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 = [
             this._application?.shortName,
             this.type,
             this.subtype,
-            functionalSlug,
+            this.functional,
             refinersSlug,
             modifiersSlug,
         ].filter(Boolean);
         return slugs.join(":");
     }
 
-    get defaultFunctional(): SlugifiedEntry {
+    private get defaultFunctional() {
         const [slug] = this.treeBranchForSubType.functionals || [];
-        return treeSlugToNamedObject(slug);
+        return treeSlugToNamedObject(slug as DFTModelSchema["functional"]);
     }
 
-    // eslint-disable-next-line class-methods-use-this
-    get defaultRefiners(): SlugifiedEntry[] {
-        return [];
+    readonly defaultRefiners: SlugifiedEntry[] = [];
+
+    readonly defaultModifiers: SlugifiedEntry[] = [];
+
+    get slugifiedFunctional() {
+        return this._stringToSlugifiedObject(this.functional);
     }
 
-    // eslint-disable-next-line class-methods-use-this
-    get defaultModifiers(): SlugifiedEntry[] {
-        return [];
+    get functional() {
+        return this.requiredProp<DFTModelSchema["functional"]>("functional");
     }
 
-    get functional(): SlugifiedEntry {
-        return this.prop<SlugifiedEntry>("functional", this.defaultFunctional);
+    set functional(functional) {
+        this.setProp("functional", functional);
     }
 
-    get refiners(): SlugifiedEntry[] {
+    get refiners() {
         return this.prop<SlugifiedEntry[]>("refiners", this.defaultRefiners);
     }
 
-    get modifiers(): SlugifiedEntry[] {
+    get modifiers() {
         return this.prop<SlugifiedEntry[]>("modifiers", this.defaultModifiers);
     }
 
     setSubtype(subtype: SlugifiedEntryOrSlug): void {
         this.setProp("subtype", subtype);
-        this.setFunctional(this.defaultFunctional);
+        this.setFunctional(this.defaultFunctional.slug);
     }
 
-    setFunctional(functional: SlugifiedEntryOrSlug): void {
-        this.setProp("functional", this._stringToSlugifiedObject(functional));
+    setFunctional(functional: string): void {
+        this.setProp("functional", functional);
         this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
     }
 
@@ -82,22 +93,24 @@ export class DFTModel extends Model {
         this._setArrayProp("modifiers", modifiers);
     }
 
-    toJSON(): Record<string, unknown> {
-        const pickSlugFromObject = (item: SlugifiedEntry) => _.pick(item, "slug");
+    declare _json: DFTModelSchema & AnyObject;
+
+    toJSON(): DFTModelSchema & AnyObject {
         const baseJson = super.toJSON();
         const keysToExclude = ["type", "subtype", "functional", "refiners", "modifiers", "method"];
         const restJson = Object.fromEntries(
             Object.entries(baseJson).filter(([key]) => !keysToExclude.includes(key)),
         );
+
         return {
             type: this.type,
             subtype: this.subtype,
             method: this.Method.toJSONWithCleanData(),
-            functional: pickSlugFromObject(this.functional),
+            functional: this.functional,
             refiners: this.refiners,
             modifiers: this.modifiers,
             ...restJson,
-        };
+        } as DFTModelSchema;
     }
 
     get allFunctionals(): SlugifiedEntry[] {

package/src/js/models/factory.ts

@@ -1,10 +1,9 @@
 import { Model } from "../model";
 import {
-    getDefaultModelSubtypeForApplicationAndType,
-    getDefaultModelTypeForApplication,
+    getDefaultModelTypeSubtypeForApplication,
     getTreeByApplicationNameAndVersion,
 } from "../tree";
-import type { ModelConfig } from "../types";
+import type { ModelConfig, RequireFields } from "../types";
 import { DFTModel } from "./dft";
 
 export class ModelFactory {
@@ -21,20 +20,19 @@ export class ModelFactory {
         }
     }
 
-    static createFromApplication(config: ModelConfig): Model {
+    static createFromApplication(config: RequireFields<ModelConfig, "application">): Model {
         const { application } = config;
         if (!application) {
             throw new Error("ModelFactory.createFromApplication: application is required");
         }
 
         const tree = getTreeByApplicationNameAndVersion(application);
-        if (Object.keys(tree).length === 0) {
+        if (!tree || Object.keys(tree).length === 0) {
             return this.create({ ...config, type: "unknown", subtype: "unknown" });
         }
 
-        const type = getDefaultModelTypeForApplication(application);
-        const subtype = getDefaultModelSubtypeForApplicationAndType(application, type) || "unknown";
+        const typeSubtype = getDefaultModelTypeSubtypeForApplication(application);
 
-        return this.create({ ...config, type, subtype });
+        return this.create({ ...config, ...typeSubtype });
     }
 }

package/src/js/tree.ts

@@ -1,4 +1,9 @@
-import { ApplicationSchemaBase, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import {
+    type DFTModelSchema,
+    type MLModelSchema,
+    type UnknownModelSchema,
+    ApplicationSchema,
+} from "@mat3ra/esse/dist/js/types";
 import MODELS_TREE_CONFIG_BY_APPLICATION from "@mat3ra/standata/dist/js/runtime_data/models/modelsTreeConfigByApplication.json";
 import MODEL_TREE_DATA from "@mat3ra/standata/dist/js/runtime_data/models/modelTree.json";
 import lodash from "lodash";
@@ -14,7 +19,7 @@ export const METHODS = {
 } as const;
 
 export const getPseudopotentialTypesFromTree = (): string[] => {
-    const dftTree = MODEL_TREE.dft as Record<string, any>;
+    const dftTree = MODEL_TREE.dft;
     const firstBranch = Object.values(dftTree)[0];
     return firstBranch?.methods?.pseudopotential || [];
 };
@@ -23,36 +28,49 @@ export const getDFTFunctionalsFromTree = (): string[] => {
     return Object.keys(MODEL_TREE.dft);
 };
 
-export const getDFTFunctionalsByApproximation = (approximation: string): string[] | undefined => {
-    const dftTree = MODEL_TREE.dft as Record<string, any>;
+export const getDFTFunctionalsByApproximation = (
+    approximation: "gga" | "lda" | "hybrid" | "other",
+): string[] | undefined => {
+    const dftTree = MODEL_TREE.dft;
     const branch = dftTree[approximation];
     return branch?.functionals;
 };
 
-export const treeSlugToNamedObject = (modelSlug: string): SlugifiedEntry => {
+export function treeSlugToNamedObject<T extends string>(modelSlug: T) {
     return {
         slug: modelSlug,
-        name: lodash.get(MODEL_NAMES, modelSlug, modelSlug),
-    };
-};
+        name: lodash.get(MODEL_NAMES, modelSlug, modelSlug) as string,
+    } as const;
+}
 
 export const getTreeByApplicationNameAndVersion = ({
     name,
-}: Pick<ApplicationSchemaBase, "name" | "version">): ModelTree => {
+}: Pick<ApplicationSchema, "name" | "version">): ModelTree | undefined => {
     // TODO: add logic to filter by version when necessary
-    // @ts-ignore
-    return MODELS_TREE_CONFIG_BY_APPLICATION[name] || {};
-};
-
-export const getDefaultModelTypeForApplication = (application: ApplicationSchemaBase): string => {
-    return Object.keys(getTreeByApplicationNameAndVersion(application))[0];
+    if (!(name in MODELS_TREE_CONFIG_BY_APPLICATION)) {
+        return undefined;
+    }
+    return MODELS_TREE_CONFIG_BY_APPLICATION[
+        name as keyof typeof MODELS_TREE_CONFIG_BY_APPLICATION
+    ];
 };
 
-export const getDefaultModelSubtypeForApplicationAndType = (
-    application: ApplicationSchemaBase,
-    type: string,
-): string | undefined => {
+export function getDefaultModelTypeSubtypeForApplication(
+    application: Pick<ApplicationSchema, "name" | "version">,
+) {
     const tree = getTreeByApplicationNameAndVersion(application);
-    const subtypes = Object.keys(tree[type] || {});
-    return subtypes[0];
-};
+
+    if (!tree) {
+        throw new Error(
+            `getDefaultModelTypeForApplication: tree not found for application ${application.name}`,
+        );
+    }
+
+    const type = Object.keys(tree)[0];
+    const subtype = Object.keys(tree[type] || {})[0] || "unknown";
+
+    return { type, subtype } as
+        | Pick<DFTModelSchema, "type" | "subtype">
+        | Pick<MLModelSchema, "type" | "subtype">
+        | Pick<UnknownModelSchema, "type" | "subtype">;
+}

package/src/js/types/index.ts

@@ -1,15 +1,28 @@
 import type {
-    ApplicationSchemaBase,
-    BaseModel,
+    ApplicationSchema,
     CategorizedMethod,
     CategorizedModel,
     CategorizedUnitMethod,
+    DFTModelSchema,
+    MLModelSchema,
+    UnknownModelSchema,
 } from "@mat3ra/esse/dist/js/types";
 
-export type ModelConfig = Pick<BaseModel, "type" | "subtype"> &
-    Partial<Omit<BaseModel, "type" | "subtype">> & {
-        application?: ApplicationSchemaBase;
-    };
+/**
+ * Makes specified fields required and all others optional
+ * TODO: consider moving to code.js
+ */
+export type RequireFields<T, K extends keyof T> = Required<Pick<T, K>> & Partial<Omit<T, K>>;
+
+type ModelRequiredFields = "type" | "subtype";
+
+export type DFTModelConfig = RequireFields<DFTModelSchema, ModelRequiredFields>;
+export type MLModelConfig = RequireFields<MLModelSchema, ModelRequiredFields>;
+export type UnknownModelConfig = RequireFields<UnknownModelSchema, ModelRequiredFields>;
+
+export type ModelConfig = (DFTModelConfig | MLModelConfig | UnknownModelConfig) & {
+    application?: ApplicationSchema;
+};
 
 export type SimplifiedCategorizedModel = Pick<
     CategorizedModel,
@@ -20,13 +33,6 @@ 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[];