@mat3ra/prode 2026.3.30-0 → 2026.6.5-0

package/src/js/generated/WorkflowPropertySchemaMixin.ts

@@ -8,41 +8,70 @@ export type WorkflowPropertySchemaMixin = Omit<
 
 export type WorkflowPropertyInMemoryEntity = InMemoryEntity & WorkflowPropertySchemaMixin;
 
-export function workflowPropertySchemaMixin(item: InMemoryEntity) {
+export function workflowPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & WorkflowPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & WorkflowPropertySchemaMixin = {
         get name() {
             return this.requiredProp<WorkflowPropertySchema["name"]>("name");
         },
-        get subworkflows() {
-            return this.requiredProp<WorkflowPropertySchema["subworkflows"]>("subworkflows");
+        set name(value: WorkflowPropertySchema["name"]) {
+            this.setProp("name", value);
         },
-        get units() {
-            return this.requiredProp<WorkflowPropertySchema["units"]>("units");
+        get workflows() {
+            return this.requiredProp<WorkflowPropertySchema["workflows"]>("workflows");
+        },
+        set workflows(value: WorkflowPropertySchema["workflows"]) {
+            this.setProp("workflows", value);
+        },
+        get metadata() {
+            return this.prop<WorkflowPropertySchema["metadata"]>("metadata");
+        },
+        set metadata(value: WorkflowPropertySchema["metadata"]) {
+            this.setProp("metadata", value);
         },
         get properties() {
-            return this.prop<WorkflowPropertySchema["properties"]>("properties");
+            return this.requiredProp<WorkflowPropertySchema["properties"]>("properties");
+        },
+        set properties(value: WorkflowPropertySchema["properties"]) {
+            this.setProp("properties", value);
         },
         get isUsingDataset() {
             return this.prop<WorkflowPropertySchema["isUsingDataset"]>("isUsingDataset");
         },
+        set isUsingDataset(value: WorkflowPropertySchema["isUsingDataset"]) {
+            this.setProp("isUsingDataset", value);
+        },
         get isMultiMaterial() {
             return this.prop<WorkflowPropertySchema["isMultiMaterial"]>("isMultiMaterial");
         },
-        get workflows() {
-            return this.prop<WorkflowPropertySchema["workflows"]>("workflows");
+        set isMultiMaterial(value: WorkflowPropertySchema["isMultiMaterial"]) {
+            this.setProp("isMultiMaterial", value);
+        },
+        get subworkflows() {
+            return this.requiredProp<WorkflowPropertySchema["subworkflows"]>("subworkflows");
+        },
+        set subworkflows(value: WorkflowPropertySchema["subworkflows"]) {
+            this.setProp("subworkflows", value);
+        },
+        get units() {
+            return this.requiredProp<WorkflowPropertySchema["units"]>("units");
+        },
+        set units(value: WorkflowPropertySchema["units"]) {
+            this.setProp("units", value);
         },
         get application() {
             return this.prop<WorkflowPropertySchema["application"]>("application");
         },
+        set application(value: WorkflowPropertySchema["application"]) {
+            this.setProp("application", value);
+        },
         get tags() {
             return this.prop<WorkflowPropertySchema["tags"]>("tags");
         },
-        get isDefault() {
-            return this.prop<WorkflowPropertySchema["isDefault"]>("isDefault");
-        },
-        get metadata() {
-            return this.prop<WorkflowPropertySchema["metadata"]>("metadata");
+        set tags(value: WorkflowPropertySchema["tags"]) {
+            this.setProp("tags", value);
         },
     };
 

package/src/js/generated/ZeroPointEnergyPropertySchemaMixin.ts

@@ -9,18 +9,29 @@ export type ZeroPointEnergyPropertySchemaMixin = Omit<
 export type ZeroPointEnergyPropertyInMemoryEntity = InMemoryEntity &
     ZeroPointEnergyPropertySchemaMixin;
 
-export function zeroPointEnergyPropertySchemaMixin(item: InMemoryEntity) {
+export function zeroPointEnergyPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ZeroPointEnergyPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ZeroPointEnergyPropertySchemaMixin = {
         get name() {
             return this.requiredProp<ZeroPointEnergyPropertySchema["name"]>("name");
         },
+        set name(value: ZeroPointEnergyPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get units() {
             return this.requiredProp<ZeroPointEnergyPropertySchema["units"]>("units");
         },
+        set units(value: ZeroPointEnergyPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
         get value() {
             return this.requiredProp<ZeroPointEnergyPropertySchema["value"]>("value");
         },
+        set value(value: ZeroPointEnergyPropertySchema["value"]) {
+            this.setProp("value", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/holders/MetaPropertyHolder.ts

@@ -1,5 +1,4 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
 
 import {
@@ -7,9 +6,10 @@ import {
     metaPropertyHolderMixin,
 } from "./mixins/MetaPropertyHolderMixin";
 
-type MetaPropertyBase = typeof InMemoryEntity & Constructor<MetaPropertyHolderMixin>;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface MetaPropertyHolder extends MetaPropertyHolderMixin {}
 
-export default class MetaPropertyHolder extends (InMemoryEntity as MetaPropertyBase) {
+class MetaPropertyHolder extends InMemoryEntity {
     // eslint-disable-next-line no-useless-constructor
     constructor(data: MetaPropertyHolderSchema) {
         super(data);
@@ -17,3 +17,5 @@ export default class MetaPropertyHolder extends (InMemoryEntity as MetaPropertyB
 }
 
 metaPropertyHolderMixin(MetaPropertyHolder.prototype);
+
+export default MetaPropertyHolder;

package/src/js/holders/PropertyHolder.ts

@@ -5,11 +5,13 @@ import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
 import type { PropertyHolderMixin } from "./mixins/PropertyHolderMixin";
 import { propertyHolderMixin } from "./mixins/PropertyHolderMixin";
 
-type PropertyHolderBase = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+type Schema = PropertyHolderSchema;
 
-export default class PropertyHolder extends (InMemoryEntity as PropertyHolderBase) {
+type Base = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+
+export default class PropertyHolder extends (InMemoryEntity as Base) implements Schema {
     // eslint-disable-next-line no-useless-constructor
-    constructor(data: PropertyHolderSchema) {
+    constructor(data: Schema) {
         super(data);
     }
 }

package/src/js/holders/mixins/MetaPropertyHolderMixin.ts

@@ -1,29 +1,28 @@
 import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import type { PseudopotentialMetaProperty } from "src/js";
 
 import {
     type MetaPropertyHolderSchemaMixin,
     metaPropertyHolderSchemaMixin,
 } from "../../generated/MetaPropertyHolderSchemaMixin";
-import type MetaProperty from "../../MetaProperty";
 import PropertyFactory from "../../PropertyFactory";
 
 export interface MetaPropertySchemaJSON extends MetaPropertyHolderSchema, AnyObject {}
 
 export type MetaPropertyHolderMixin = {
-    property: MetaProperty;
+    property: PseudopotentialMetaProperty;
 } & MetaPropertyHolderSchemaMixin;
 
 export type MetaPropertyInMemoryEntity = InMemoryEntity & MetaPropertyHolderMixin;
 
 export function metaPropertyHolderMixin(item: InMemoryEntity) {
-    // @ts-expect-error - this is a workaround to allow the metaPropertyMixin to be used with any type of entity
-    const properties: InMemoryEntity & MetaPropertyHolderMixin = {
-        get property() {
-            return PropertyFactory.createMetaProperty(this.data);
+    const properties = {
+        get property(): PseudopotentialMetaProperty {
+            return PropertyFactory.createMetaProperty(this.data) as PseudopotentialMetaProperty;
         },
-    };
+    } as InMemoryEntity & MetaPropertyHolderMixin;
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
 

package/src/js/index.ts

@@ -8,6 +8,7 @@ export { default as BandGapsProperty } from "./properties/non-scalar/BandGapsPro
 export { default as IsRelaxedProperty } from "./properties/non-scalar/IsRelaxedProperty";
 export { default as PressureProperty } from "./properties/scalar/PressureProperty";
 export { default as ReactionEnergyBarrierProperty } from "./properties/scalar/ReactionEnergyBarrierProperty";
+export { default as FormationEnergyProperty } from "./properties/scalar/FormationEnergyProperty";
 export { default as SurfaceEnergyProperty } from "./properties/scalar/SurfaceEnergyProperty";
 export { default as TotalEnergyProperty } from "./properties/scalar/TotalEnergyProperty";
 export { default as HOMOEnergyProperty } from "./properties/scalar/HOMOEnergyProperty";
@@ -22,5 +23,8 @@ export { default as ReactionEnergyProfileProperty } from "./properties/non-scala
 export { protoPropertyHolderMixin } from "./holders/mixins/ProtoPropertyHolderMixin";
 export { propertyHolderMixin } from "./holders/mixins/PropertyHolderMixin";
 export { metaPropertyHolderMixin } from "./holders/mixins/MetaPropertyHolderMixin";
+export { default as PropertyHolder } from "./holders/PropertyHolder";
+export { default as MetaPropertyHolder } from "./holders/MetaPropertyHolder";
+export { default as ProtoPropertyHolder } from "./holders/ProtoPropertyHolder";
 
 export * from "./types";

package/src/js/meta_properties/PseudopotentialMetaProperty.ts

@@ -19,6 +19,20 @@ enum CompatibleExchangeCorrelationKey {
 
 type Base = typeof MetaProperty & Constructor<PseudopotentialMetaPropertySchemaMixin>;
 
+export type ExchangeCorrelation = {
+    functional?: string;
+    approximation: string;
+};
+
+// TODO: move to esse schema
+export type PseudopotentialFilter = {
+    searchText?: string;
+    appName?: string;
+    type?: string;
+    exchangeCorrelation?: ExchangeCorrelation;
+    elements?: string[];
+};
+
 export default class PseudopotentialMetaProperty extends (MetaProperty as Base) implements Schema {
     static readonly propertyName = PropertyName.pseudopotential;
 
@@ -80,15 +94,12 @@ export default class PseudopotentialMetaProperty extends (MetaProperty as Base)
      */
     static filterRawDataByExchangeCorrelation(
         rawData: PseudopotentialMetaProperty[],
-        exchangeCorrelation: {
-            functional: string;
-            approximation: string;
-        },
+        exchangeCorrelation: ExchangeCorrelation,
     ) {
         const { functional } = exchangeCorrelation;
 
         return rawData.filter((item) => {
-            return this.isCompatibleWithOther(functional)
+            return functional && this.isCompatibleWithOther(functional)
                 ? this.compatibleExchangeCorrelation[functional].includes(
                       item.exchangeCorrelation?.functional || "",
                   )
@@ -134,16 +145,7 @@ export default class PseudopotentialMetaProperty extends (MetaProperty as Base)
      */
     static applyPseudoFilters(
         pseudos: PseudopotentialMetaProperty[],
-        pseudoFilter: {
-            searchText?: string;
-            appName?: string;
-            type?: string;
-            exchangeCorrelation?: {
-                functional: keyof typeof PseudopotentialMetaProperty.compatibleExchangeCorrelation;
-                approximation: string;
-            };
-            elements?: string[];
-        },
+        pseudoFilter: PseudopotentialFilter,
     ) {
         let filteredPseudos = [...pseudos];
 
@@ -197,6 +199,13 @@ export default class PseudopotentialMetaProperty extends (MetaProperty as Base)
         });
     }
 
+    static sortByPathApplicationSpecific(pseudos: PseudopotentialMetaProperty[], appName?: string) {
+        if (appName === "vasp") {
+            return this.sortByPathVASP(pseudos);
+        }
+        return pseudos;
+    }
+
     static filterByType(pseudos: PseudopotentialMetaProperty[], pseudoType?: string) {
         if (pseudoType === undefined || pseudoType === "any") return pseudos;
         return pseudos.filter((pseudo) => pseudo.type.includes(pseudoType));

package/src/js/properties/scalar/FormationEnergyProperty.ts

@@ -0,0 +1,27 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FormationEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    FormationEnergyPropertySchemaMixin,
+    formationEnergyPropertySchemaMixin,
+} from "../../generated/FormationEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+
+type Schema = FormationEnergyPropertySchema;
+
+type Base = typeof Property<Schema> & Constructor<FormationEnergyPropertySchemaMixin>;
+
+export default class FormationEnergyProperty extends (Property as Base) implements Schema {
+    static readonly isRefined = true;
+
+    static readonly propertyName = PropertyName.formation_energy;
+
+    static readonly propertyType = PropertyType.scalar;
+
+    constructor(config: Omit<Schema, "name">) {
+        super({ ...config, name: FormationEnergyProperty.propertyName });
+    }
+}
+
+formationEnergyPropertySchemaMixin(FormationEnergyProperty.prototype);

package/src/js/properties/scalar/ThermalCorrectionToEnergyProperty.ts

@@ -1,4 +1,3 @@
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { ThermalCorrectionToEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
 
 import {
@@ -10,18 +9,23 @@ import { PropertyName, PropertyType } from "../../settings";
 
 type Schema = ThermalCorrectionToEnergyPropertySchema;
 
-type Base = typeof Property<Schema> & Constructor<ThermalCorrectionToEnergyPropertySchemaMixin>;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface ThermalCorrectionToEnergyProperty extends ThermalCorrectionToEnergyPropertySchemaMixin {}
 
-export default class ThermalCorrectionToEnergyProperty extends (Property as Base) implements Schema {
+class ThermalCorrectionToEnergyProperty extends Property<Schema> implements Schema {
     static readonly propertyType = PropertyType.scalar;
 
     static readonly propertyName = PropertyName.thermal_correction_to_energy;
 
     static readonly isRefined = true;
 
+    declare name: Schema["name"];
+
     constructor(config: Omit<Schema, "name">) {
         super({ ...config, name: ThermalCorrectionToEnergyProperty.propertyName });
     }
 }
 
 thermalCorrectionToEnergyPropertySchemaMixin(ThermalCorrectionToEnergyProperty.prototype);
+
+export default ThermalCorrectionToEnergyProperty;

package/src/js/properties/scalar/ThermalCorrectionToEnthalpyProperty.ts

@@ -1,4 +1,3 @@
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { ThermalCorrectionToEnthalpyPropertySchema } from "@mat3ra/esse/dist/js/types";
 
 import {
@@ -10,18 +9,24 @@ import { PropertyName, PropertyType } from "../../settings";
 
 type Schema = ThermalCorrectionToEnthalpyPropertySchema;
 
-type Base = typeof Property<Schema> & Constructor<ThermalCorrectionToEnthalpyPropertySchemaMixin>;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface ThermalCorrectionToEnthalpyProperty
+    extends ThermalCorrectionToEnthalpyPropertySchemaMixin {}
 
-export default class ThermalCorrectionToEnthalpyProperty extends (Property as Base) implements Schema {
+class ThermalCorrectionToEnthalpyProperty extends Property<Schema> implements Schema {
     static readonly propertyType = PropertyType.scalar;
 
     static readonly propertyName = PropertyName.thermal_correction_to_enthalpy;
 
     static readonly isRefined = true;
 
+    declare name: Schema["name"];
+
     constructor(config: Omit<Schema, "name">) {
         super({ ...config, name: ThermalCorrectionToEnthalpyProperty.propertyName });
     }
 }
 
 thermalCorrectionToEnthalpyPropertySchemaMixin(ThermalCorrectionToEnthalpyProperty.prototype);
+
+export default ThermalCorrectionToEnthalpyProperty;

package/src/js/settings.ts

@@ -19,6 +19,7 @@ export enum PropertyName {
     homo_energy = "homo_energy",
     lumo_energy = "lumo_energy",
     surface_energy = "surface_energy",
+    formation_energy = "formation_energy",
     convergence_electronic = "convergence_electronic",
     convergence_ionic = "convergence_ionic",
     fermi_energy = "fermi_energy",

package/src/js/types.ts

@@ -22,3 +22,7 @@ export type { default as DensityOfStatesProperty } from "./properties/non-scalar
 export type { default as DielectricTensorProperty } from "./properties/non-scalar/DielectricTensorProperty";
 export type { default as PhononDispersionsProperty } from "./properties/non-scalar/PhononDispersionsProperty";
 export type { default as PhononDOSProperty } from "./properties/non-scalar/PhononDOSProperty";
+export type {
+    PseudopotentialFilter,
+    ExchangeCorrelation,
+} from "./meta_properties/PseudopotentialMetaProperty";