@mat3ra/mode 2026.3.4-0 → 2026.5.28-0

package/dist/js/default_methods.d.ts

@@ -1,6 +1,29 @@
-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;
+import { BaseModel, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+export declare const PseudopotentialMethodConfig: {
+    readonly type: "pseudopotential";
+    readonly subtype: "us";
+};
+export declare const LocalOrbitalMethodConfig: {
+    readonly type: "localorbital";
+    readonly subtype: "pople";
+};
+export declare const UnknownMethodConfig: {
+    readonly type: "unknown";
+    readonly subtype: "unknown";
+};
+export declare const methodConfigs: {
+    readonly pseudopotential: {
+        readonly type: "pseudopotential";
+        readonly subtype: "us";
+    };
+    readonly localorbital: {
+        readonly type: "localorbital";
+        readonly subtype: "pople";
+    };
+    readonly unknown: {
+        readonly type: "unknown";
+        readonly subtype: "unknown";
+    };
+};
 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

@@ -3,7 +3,7 @@ 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.methodConfigs = exports.UnknownMethodConfig = exports.LocalOrbitalMethodConfig = exports.PseudopotentialMethodConfig = void 0;
 exports.allowedTypes = allowedTypes;
 exports.allowedSubtypes = allowedSubtypes;
 const lodash_1 = __importDefault(require("lodash"));
@@ -20,6 +20,11 @@ exports.UnknownMethodConfig = {
     type: "unknown",
     subtype: "unknown",
 };
+exports.methodConfigs = {
+    pseudopotential: exports.PseudopotentialMethodConfig,
+    localorbital: exports.LocalOrbitalMethodConfig,
+    unknown: exports.UnknownMethodConfig,
+};
 const mapSlugToNamedObject = (slug) => {
     return {
         slug,

package/dist/js/default_models.d.ts

@@ -1,3 +1,8 @@
-import type { ModelConfig } from "./types";
-export declare const DFTModelConfig: ModelConfig;
-export declare const UnknownModelConfig: ModelConfig;
+export declare const DFTModelConfig: {
+    readonly type: "dft";
+    readonly subtype: "gga";
+};
+export declare const UnknownModelConfig: {
+    readonly type: "unknown";
+    readonly subtype: "unknown";
+};

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

@@ -2,4 +2,4 @@ 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;
+export declare function methodSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & MethodSchemaMixin;

package/dist/js/generated/MethodSchemaMixin.js

@@ -7,15 +7,27 @@ function methodSchemaMixin(item) {
         get type() {
             return this.requiredProp("type");
         },
+        set type(value) {
+            this.setProp("type", value);
+        },
         get subtype() {
             return this.requiredProp("subtype");
         },
+        set subtype(value) {
+            this.setProp("subtype", value);
+        },
         get precision() {
             return this.prop("precision");
         },
+        set precision(value) {
+            this.setProp("precision", value);
+        },
         get data() {
             return this.prop("data");
         },
+        set data(value) {
+            this.setProp("data", value);
+        },
     };
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }

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

@@ -2,4 +2,4 @@ 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;
+export declare function modelSchemaMixin<T extends InMemoryEntity>(item: InMemoryEntity): asserts item is T & ModelSchemaMixin;

package/dist/js/generated/ModelSchemaMixin.js

@@ -7,12 +7,21 @@ function modelSchemaMixin(item) {
         get type() {
             return this.requiredProp("type");
         },
+        set type(value) {
+            this.setProp("type", value);
+        },
         get subtype() {
             return this.requiredProp("subtype");
         },
+        set subtype(value) {
+            this.setProp("subtype", value);
+        },
         get method() {
             return this.requiredProp("method");
         },
+        set method(value) {
+            this.setProp("method", value);
+        },
     };
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 }

package/dist/js/method.d.ts

@@ -1,5 +1,6 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import type { BaseMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
 import { type MethodSchemaMixin } from "./generated/MethodSchemaMixin";
 type Base = typeof InMemoryEntity & Constructor<MethodSchemaMixin>;
@@ -9,9 +10,13 @@ interface MethodData extends Record<string, unknown> {
 declare const Method_base: Base;
 export declare class Method extends Method_base implements BaseMethod {
     constructor(config: BaseMethod);
+    toJSON: () => BaseMethod & AnyObject;
     cloneWithoutData(): Method;
     setSubtype(subtype: SlugifiedEntry): void;
-    static get defaultConfig(): BaseMethod;
+    static get defaultConfig(): {
+        readonly type: "pseudopotential";
+        readonly subtype: "us";
+    };
     get searchText(): string;
     setSearchText(searchText: string): void;
     setData(data?: MethodData): void;

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

@@ -1,21 +1,22 @@
-import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import { type BaseMethod, type FileDataItem } from "@mat3ra/esse/dist/js/types";
+import { PseudopotentialFilter, PseudopotentialMetaProperty } from "@mat3ra/prode";
 import { Method } from "../method";
-import type { PseudopotentialCtor, PseudopotentialLike } from "../types";
+export type ExchangeCorrelation = {
+    approximation: string;
+    functional: string;
+};
 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;
-    };
+    toJSON: () => BaseMethod & AnyObject;
+    get pseudo(): FileDataItem[];
+    get allPseudo(): FileDataItem[];
+    get pseudopotentials(): PseudopotentialMetaProperty[];
+    get allPseudopotentials(): PseudopotentialMetaProperty[];
     hasPseudopotentialFor(element: string): boolean;
-    setPseudopotentialPerElement(pseudo: PseudopotentialLike | undefined): void;
-    addToAllPseudos(pseudos: PseudopotentialLike | PseudopotentialLike[]): void;
-    setPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
-    setAllPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
+    setPseudopotentialPerElement(pseudo?: PseudopotentialMetaProperty): void;
+    addToAllPseudos(pseudos: PseudopotentialMetaProperty | PseudopotentialMetaProperty[]): void;
+    setPseudopotentials(pseudopotentials: PseudopotentialMetaProperty[]): void;
+    setAllPseudopotentials(pseudopotentials: PseudopotentialMetaProperty[]): void;
     toJSONWithCleanData(exclude?: string[]): BaseMethod;
+    updateMethodDataByApplicationAndMaterials(methodDataItems: PseudopotentialMetaProperty[], pseudoFilter: Pick<PseudopotentialFilter, "elements" | "appName" | "exchangeCorrelation">): this;
 }

package/dist/js/methods/pseudopotential.js

@@ -4,14 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudopotentialMethod = void 0;
-const utils_1 = require("@mat3ra/code/dist/js/utils");
+const prode_1 = require("@mat3ra/prode");
 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", []);
     }
@@ -19,24 +15,10 @@ class PseudopotentialMethod extends method_1.Method {
         return this.prop("data.allPseudo", []);
     }
     get pseudopotentials() {
-        if (!this.PseudopotentialCls)
-            return [];
-        return this.pseudo.map((config) => new this.PseudopotentialCls(config));
+        return this.pseudo.map((config) => new prode_1.PseudopotentialMetaProperty(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 || "",
-        };
+        return this.allPseudo.map((config) => new prode_1.PseudopotentialMetaProperty(config));
     }
     hasPseudopotentialFor(element) {
         return Boolean(this.pseudopotentials.find((pseudo) => pseudo.element === element));
@@ -47,14 +29,11 @@ class PseudopotentialMethod extends method_1.Method {
             return;
         }
         const filtered = this.pseudopotentials.filter((item) => item.element !== pseudo.element);
-        filtered.push(pseudo);
-        this.setPseudopotentials(filtered);
+        this.setPseudopotentials([...filtered, pseudo]);
     }
     addToAllPseudos(pseudos) {
-        const list = (0, utils_1.safeMakeArray)(pseudos);
-        const all = this.allPseudopotentials;
-        all.push(...list);
-        this.setAllPseudopotentials(all);
+        const list = Array.isArray(pseudos) ? pseudos : [pseudos];
+        this.setAllPseudopotentials([...this.allPseudopotentials, ...list]);
     }
     setPseudopotentials(pseudopotentials) {
         this.setData({
@@ -71,5 +50,40 @@ class PseudopotentialMethod extends method_1.Method {
     toJSONWithCleanData(exclude = []) {
         return super.toJSONWithCleanData(exclude.concat(["allPseudo"]));
     }
+    updateMethodDataByApplicationAndMaterials(methodDataItems, pseudoFilter) {
+        var _a;
+        const typeFilter = { type: this.subtype };
+        let pseudos = prode_1.PseudopotentialMetaProperty.applyPseudoFilters(methodDataItems, {
+            ...pseudoFilter,
+            ...typeFilter,
+        });
+        // sorting pseudos, this is very hacky! TODO: find better approach for default pseudos per application
+        if (this.subtype === "us") {
+            pseudos = prode_1.PseudopotentialMetaProperty.sortPseudosByPattern(pseudos);
+        }
+        pseudos = prode_1.PseudopotentialMetaProperty.sortByPathApplicationSpecific(pseudos, pseudoFilter.appName);
+        pseudos = prode_1.PseudopotentialMetaProperty.filterUnique(pseudos);
+        this.setAllPseudopotentials(pseudos);
+        this.setSearchText(this.searchText);
+        // if searchText is present => use it to filter the pseudos before selecting one per element
+        pseudos = prode_1.PseudopotentialMetaProperty.safelyFilterRawDataBySearchText(pseudos, this.searchText);
+        const newFilter = {
+            elements: pseudoFilter.elements,
+            appName: pseudoFilter.appName,
+            exchangeCorrelation: pseudoFilter.exchangeCorrelation,
+            searchText: this.searchText,
+            ...typeFilter,
+        };
+        // try to keep previously selected pseudos
+        // TODO: rework creating/updating method data items once methodData has been removed from store
+        const filteredSelected = prode_1.PseudopotentialMetaProperty.applyPseudoFilters(this.pseudopotentials, newFilter);
+        // set first pseudopotentials as selected per element, prioritize already selected
+        (_a = pseudoFilter.elements) === null || _a === void 0 ? void 0 : _a.forEach((el) => {
+            const selected = filteredSelected.find((p) => p.element === el);
+            const pseudo = selected || pseudos.find((p) => p.element === el);
+            this.setPseudopotentialPerElement(pseudo);
+        });
+        return this;
+    }
 }
 exports.PseudopotentialMethod = PseudopotentialMethod;

package/dist/js/model.d.ts

@@ -1,6 +1,7 @@
 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 { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { AnyModelSchema, ApplicationSchema, 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";
@@ -8,7 +9,7 @@ import type { MethodTreeBranch, ModelConfig, 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 _application?: ApplicationSchema;
     protected _MethodFactory: typeof MethodFactory;
     protected _method?: Method;
     constructor(config: ModelConfig);
@@ -28,9 +29,17 @@ export declare class Model extends Model_base implements BaseModel {
     get methodTypes(): SlugifiedEntry[];
     get methodSubtypes(): SlugifiedEntry[];
     get defaultMethodConfig(): BaseMethod;
-    static get defaultConfig(): ModelConfig;
+    static get defaultConfig(): {
+        method: {
+            readonly type: "pseudopotential";
+            readonly subtype: "us";
+        };
+        type: "dft";
+        subtype: "gga";
+    };
     static get allTypes(): SlugifiedEntry[];
-    toJSON(): Record<string, unknown>;
+    _json: AnyModelSchema & AnyObject;
+    toJSON(): AnyModelSchema & AnyObject;
     protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry;
     get isUnknown(): boolean;
     protected get subtypeSlug(): string;

package/dist/js/model.js

@@ -19,11 +19,10 @@ class Model extends entity_1.InMemoryEntity {
         super(entityConfig);
         this._application = application;
         this._MethodFactory = factory_1.MethodFactory;
-        if (method) {
-            this.setProp("method", method);
-        }
+        this.method = method || this.method;
     }
     setSubtype(subtype) {
+        // TODO-question: subtype is a string, but we're setting it to a SlugifiedEntryOrSlug
         this.setProp("subtype", subtype);
         this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
     }
@@ -109,9 +108,8 @@ class Model extends entity_1.InMemoryEntity {
         return Object.keys(tree_1.MODEL_TREE).map((modelSlug) => (0, tree_1.treeSlugToNamedObject)(modelSlug));
     }
     toJSON() {
-        const json = super.toJSON();
         return {
-            ...json,
+            ...super.toJSON(),
             type: this.type,
             subtype: this.subtype,
             method: this.Method.toJSONWithCleanData(),

package/dist/js/modelConversionHandler.d.ts

@@ -1,12 +1,44 @@
-import { CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
-import type { ModelConfig, SimplifiedCategorizedModel } from "./types";
+import { type AnyModelSchema, type DFTModelSchema, type MLModelSchema, CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import type { DFTModelConfig, SimplifiedCategorizedModel, UnknownModelConfig } 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;
+    static convertToSimple(categorizedModel?: CategorizedModel): DFTModelConfig | {
+        readonly type: "unknown";
+        readonly subtype: "unknown";
+    } | {
+        readonly type: "ml";
+        readonly subtype: "re";
+    };
+    static convertDftToSimple(categorizedModel: CategorizedModel): DFTModelConfig | UnknownModelConfig;
+    static convertMlToSimple(): {
+        readonly type: "ml";
+        readonly subtype: "re";
+    };
+    static convertUnknownToSimple(): {
+        readonly type: "unknown";
+        readonly subtype: "unknown";
+    };
+    static convertToCategorized(simpleModel?: AnyModelSchema, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | {
+        readonly name: "Regression";
+        readonly path: "/st/det/ml/re/none";
+        readonly categories: {
+            readonly tier1: "st";
+            readonly tier2: "det";
+            readonly tier3: "ml";
+            readonly type: string;
+        };
+        readonly parameters: {};
+    } | undefined;
+    static convertDftToCategorized(simpleModel: DFTModelSchema, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | undefined;
+    static convertMlToCategorized(simpleModel: MLModelSchema): {
+        readonly name: "Regression";
+        readonly path: "/st/det/ml/re/none";
+        readonly categories: {
+            readonly tier1: "st";
+            readonly tier2: "det";
+            readonly tier3: "ml";
+            readonly type: string;
+        };
+        readonly parameters: {};
+    };
 }

package/dist/js/modelConversionHandler.js

@@ -1,41 +1,7 @@
 "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;
 }
@@ -53,19 +19,20 @@ class ModelConversionHandler {
         }
     }
     static convertDftToSimple(categorizedModel) {
-        var _a, _b;
-        if (!((_a = categorizedModel.categories) === null || _a === void 0 ? void 0 : _a.subtype))
+        var _a;
+        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
+        }
+        const model = categorizedModel;
+        const subtype = safelyGetSlug(model.categories.subtype);
+        const functionalParam = model.parameters.functional;
+        const functional = functionalParam
             ? safelyGetSlug(functionalParam)
-            : "";
+            : undefined;
         return {
             type: "dft",
             subtype,
-            functional: tree.treeSlugToNamedObject(functionalSlug),
+            functional, // old: tree.treeSlugToNamedObject(functional),
         };
     }
     static convertMlToSimple() {
@@ -80,7 +47,7 @@ class ModelConversionHandler {
             subtype: "unknown",
         };
     }
-    static convertToCategorized(simpleModel, allModels = []) {
+    static convertToCategorized(simpleModel, allModels) {
         switch (simpleModel === null || simpleModel === void 0 ? void 0 : simpleModel.type) {
             case "dft":
                 return this.convertDftToCategorized(simpleModel, allModels);

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

@@ -1,4 +1,5 @@
-import { SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+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";
 import type { ModelConfig } from "../types";
@@ -6,19 +7,24 @@ export declare class DFTModel extends Model {
     constructor(config: ModelConfig & {
         MethodFactory?: typeof MethodFactory;
     });
+    type: DFTModelSchema["type"];
+    subtype: DFTModelSchema["subtype"];
     get groupSlug(): string;
-    get defaultFunctional(): SlugifiedEntry;
-    get defaultRefiners(): SlugifiedEntry[];
-    get defaultModifiers(): SlugifiedEntry[];
-    get functional(): SlugifiedEntry;
+    private get defaultFunctional();
+    readonly defaultRefiners: SlugifiedEntry[];
+    readonly defaultModifiers: SlugifiedEntry[];
+    get slugifiedFunctional(): SlugifiedEntry;
+    get functional(): "pz" | "pw" | "vwn" | "other" | "pbe" | "pbesol" | "pw91" | "b3lyp" | "hse06";
+    set functional(functional: "pz" | "pw" | "vwn" | "other" | "pbe" | "pbesol" | "pw91" | "b3lyp" | "hse06");
     get refiners(): SlugifiedEntry[];
     get modifiers(): SlugifiedEntry[];
     setSubtype(subtype: SlugifiedEntryOrSlug): void;
-    setFunctional(functional: SlugifiedEntryOrSlug): void;
+    setFunctional(functional: string): void;
     private _setArrayProp;
     setRefiners(refiners: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
     setModifiers(modifiers: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
-    toJSON(): Record<string, unknown>;
+    _json: DFTModelSchema & AnyObject;
+    toJSON(): DFTModelSchema & AnyObject;
     get allFunctionals(): SlugifiedEntry[];
     get allRefiners(): SlugifiedEntry[];
     get allModifiers(): SlugifiedEntry[];

package/dist/js/models/dft.js

@@ -1,29 +1,28 @@
 "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.defaultRefiners = [];
+        this.defaultModifiers = [];
         this._MethodFactory = config.MethodFactory || factory_1.MethodFactory;
+        this.functional =
+            this.prop("functional") || this.defaultFunctional.slug;
     }
     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,
+            this.functional,
             refinersSlug,
             modifiersSlug,
         ].filter(Boolean);
@@ -33,16 +32,14 @@ class DFTModel extends model_1.Model {
         const [slug] = this.treeBranchForSubType.functionals || [];
         return (0, tree_1.treeSlugToNamedObject)(slug);
     }
-    // eslint-disable-next-line class-methods-use-this
-    get defaultRefiners() {
-        return [];
-    }
-    // eslint-disable-next-line class-methods-use-this
-    get defaultModifiers() {
-        return [];
+    get slugifiedFunctional() {
+        return this._stringToSlugifiedObject(this.functional);
     }
     get functional() {
-        return this.prop("functional", this.defaultFunctional);
+        return this.requiredProp("functional");
+    }
+    set functional(functional) {
+        this.setProp("functional", functional);
     }
     get refiners() {
         return this.prop("refiners", this.defaultRefiners);
@@ -52,10 +49,10 @@ class DFTModel extends model_1.Model {
     }
     setSubtype(subtype) {
         this.setProp("subtype", subtype);
-        this.setFunctional(this.defaultFunctional);
+        this.setFunctional(this.defaultFunctional.slug);
     }
     setFunctional(functional) {
-        this.setProp("functional", this._stringToSlugifiedObject(functional));
+        this.setProp("functional", functional);
         this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
     }
     _setArrayProp(name, data) {
@@ -70,7 +67,6 @@ class DFTModel extends model_1.Model {
         this._setArrayProp("modifiers", modifiers);
     }
     toJSON() {
-        const pickSlugFromObject = (item) => underscore_1.default.pick(item, "slug");
         const baseJson = super.toJSON();
         const keysToExclude = ["type", "subtype", "functional", "refiners", "modifiers", "method"];
         const restJson = Object.fromEntries(Object.entries(baseJson).filter(([key]) => !keysToExclude.includes(key)));
@@ -78,7 +74,7 @@ class DFTModel extends model_1.Model {
             type: this.type,
             subtype: this.subtype,
             method: this.Method.toJSONWithCleanData(),
-            functional: pickSlugFromObject(this.functional),
+            functional: this.functional,
             refiners: this.refiners,
             modifiers: this.modifiers,
             ...restJson,

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

@@ -1,9 +1,9 @@
 import { Model } from "../model";
-import type { ModelConfig } from "../types";
+import type { ModelConfig, RequireFields } 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;
+    static createFromApplication(config: RequireFields<ModelConfig, "application">): Model;
 }

package/dist/js/models/factory.js

@@ -19,12 +19,11 @@ class ModelFactory {
             throw new Error("ModelFactory.createFromApplication: application is required");
         }
         const tree = (0, tree_1.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 = (0, tree_1.getDefaultModelTypeForApplication)(application);
-        const subtype = (0, tree_1.getDefaultModelSubtypeForApplicationAndType)(application, type) || "unknown";
-        return this.create({ ...config, type, subtype });
+        const typeSubtype = (0, tree_1.getDefaultModelTypeSubtypeForApplication)(application);
+        return this.create({ ...config, ...typeSubtype });
     }
 }
 exports.ModelFactory = ModelFactory;