@mat3ra/prode 2025.11.25-0

package/src/js/PropertyFactory.ts

@@ -0,0 +1,208 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type {
+    MetaPropertyHolderSchema,
+    PropertyHolderSchema,
+    ProtoPropertyHolderSchema,
+} from "@mat3ra/esse/dist/js/types";
+
+import PseudopotentialProperty from "./meta_properties/PseudopotentialMetaProperty";
+import type MetaProperty from "./MetaProperty";
+import AveragePotentialProfileProperty from "./properties/non-scalar/AveragePotentialProfileProperty";
+import BandGapsProperty from "./properties/non-scalar/BandGapsProperty";
+import BandStructureProperty from "./properties/non-scalar/BandStructureProperty";
+import ChargeDensityProfileProperty from "./properties/non-scalar/ChargeDensityProfileProperty";
+import ConvergenceElectronicProperty from "./properties/non-scalar/convergence/ConvergenceElectronicProperty";
+import ConvergenceIonicProperty from "./properties/non-scalar/convergence/ConvergenceIonicProperty";
+import DensityOfStatesProperty from "./properties/non-scalar/DensityOfStatesProperty";
+import DielectricTensorProperty from "./properties/non-scalar/DielectricTensorProperty";
+import FileContentProperty from "./properties/non-scalar/FileContentProperty";
+import FinalStructureProperty from "./properties/non-scalar/FinalStructureProperty";
+import HubbardUProperty from "./properties/non-scalar/HubbardUProperty";
+import HubbardVNNProperty from "./properties/non-scalar/HubbardVNNProperty";
+import HubbardVProperty from "./properties/non-scalar/HubbardVProperty";
+import IsRelaxedProperty from "./properties/non-scalar/IsRelaxedProperty";
+import JupyterNotebookEndpointProperty from "./properties/non-scalar/JupyterNotebookEndpointProperty";
+import PhononDispersionsProperty from "./properties/non-scalar/PhononDispersionsProperty";
+import PhononDOSProperty from "./properties/non-scalar/PhononDOSProperty";
+import PotentialProfileProperty from "./properties/non-scalar/PotentialProfileProperty";
+import ReactionEnergyProfileProperty from "./properties/non-scalar/ReactionEnergyProfileProperty";
+import WorkflowProperty from "./properties/non-scalar/WorkflowProperty";
+import TotalEnergyContributionsProperty from "./properties/object/TotalEnergyContributionsProperty";
+import FermiEnergyProperty from "./properties/scalar/FermiEnergyProperty";
+import IonizationPotentialElementalProperty from "./properties/scalar/IonizationPotentialElementalProperty";
+import PressureProperty from "./properties/scalar/PressureProperty";
+import ReactionEnergyBarrierProperty from "./properties/scalar/ReactionEnergyBarrierProperty";
+import SurfaceEnergyProperty from "./properties/scalar/SurfaceEnergyProperty";
+import TotalEnergyProperty from "./properties/scalar/TotalEnergyProperty";
+import TotalForcesProperty from "./properties/scalar/TotalForceProperty";
+import ValenceBandOffsetProperty from "./properties/scalar/ValenceBandOffsetProperty";
+import ZeroPointEnergyProperty from "./properties/scalar/ZeroPointEnergyProperty";
+import AtomicForcesProperty from "./properties/tensor/AtomicForcesProperty";
+import MagneticMomentsProperty from "./properties/tensor/MagneticMomentsProperty";
+import StressTensorProperty from "./properties/tensor/StressTensorProperty";
+import type Property from "./Property";
+import AtomicConstraintsProperty from "./proto_properties/AtomicConstraintsProperty";
+import BoundaryConditionsProperty from "./proto_properties/BoundaryConditionsProperty";
+import { PropertyName, PropertyType } from "./settings";
+
+type AnyProperty = PropertyHolderSchema["data"];
+type AnyMetaProperty = MetaPropertyHolderSchema["data"];
+type AnyProtoProperty = ProtoPropertyHolderSchema["data"];
+
+type PropertyClassMap = {
+    [key in PropertyHolderSchema["data"]["name"]]:
+        | Constructor<PressureProperty>
+        | Constructor<TotalForcesProperty>
+        | Constructor<TotalEnergyProperty>
+        | Constructor<SurfaceEnergyProperty>
+        | Constructor<ConvergenceElectronicProperty>
+        | Constructor<ConvergenceIonicProperty>
+        | Constructor<FermiEnergyProperty>
+        | Constructor<ZeroPointEnergyProperty>
+        | Constructor<TotalEnergyContributionsProperty>
+        | Constructor<AtomicForcesProperty>
+        | Constructor<StressTensorProperty>
+        | Constructor<DensityOfStatesProperty>
+        | Constructor<BandStructureProperty>
+        | Constructor<BandGapsProperty>
+        | Constructor<PhononDispersionsProperty>
+        | Constructor<PhononDOSProperty>
+        | Constructor<FinalStructureProperty>
+        | Constructor<IsRelaxedProperty>
+        | Constructor<WorkflowProperty>
+        | Constructor<MagneticMomentsProperty>
+        | Constructor<ReactionEnergyBarrierProperty>
+        | Constructor<ReactionEnergyProfileProperty>
+        | Constructor<PotentialProfileProperty>
+        | Constructor<ChargeDensityProfileProperty>
+        | Constructor<AveragePotentialProfileProperty>
+        | Constructor<ValenceBandOffsetProperty>
+        | Constructor<IonizationPotentialElementalProperty>
+        | Constructor<FileContentProperty>
+        | Constructor<DielectricTensorProperty>
+        | Constructor<HubbardUProperty>
+        | Constructor<HubbardVNNProperty>
+        | Constructor<HubbardVProperty>
+        | Constructor<JupyterNotebookEndpointProperty>;
+};
+
+type MetaPropertyClassMap = {
+    [key in MetaPropertyHolderSchema["data"]["name"]]: Constructor<PseudopotentialProperty>;
+};
+
+type ProtoPropertyClassMap = {
+    [key in ProtoPropertyHolderSchema["data"]["name"]]:
+        | Constructor<BoundaryConditionsProperty>
+        | Constructor<AtomicConstraintsProperty>;
+};
+
+const PROPERTY_CLASS_MAP: PropertyClassMap = {
+    [PressureProperty.propertyName]: PressureProperty,
+    [TotalForcesProperty.propertyName]: TotalForcesProperty,
+    [TotalEnergyProperty.propertyName]: TotalEnergyProperty,
+    [SurfaceEnergyProperty.propertyName]: SurfaceEnergyProperty,
+    [ConvergenceElectronicProperty.propertyName]: ConvergenceElectronicProperty,
+    [ConvergenceIonicProperty.propertyName]: ConvergenceIonicProperty,
+    [FermiEnergyProperty.propertyName]: FermiEnergyProperty,
+    [ZeroPointEnergyProperty.propertyName]: ZeroPointEnergyProperty,
+    [TotalEnergyContributionsProperty.propertyName]: TotalEnergyContributionsProperty,
+    [AtomicForcesProperty.propertyName]: AtomicForcesProperty,
+    [StressTensorProperty.propertyName]: StressTensorProperty,
+    [DensityOfStatesProperty.propertyName]: DensityOfStatesProperty,
+    [BandStructureProperty.propertyName]: BandStructureProperty,
+    [BandGapsProperty.propertyName]: BandGapsProperty,
+    [PhononDispersionsProperty.propertyName]: PhononDispersionsProperty,
+    [PhononDOSProperty.propertyName]: PhononDOSProperty,
+    [FinalStructureProperty.propertyName]: FinalStructureProperty,
+    [IsRelaxedProperty.propertyName]: IsRelaxedProperty,
+    [WorkflowProperty.propertyName]: WorkflowProperty,
+    [MagneticMomentsProperty.propertyName]: MagneticMomentsProperty,
+    [ReactionEnergyBarrierProperty.propertyName]: ReactionEnergyBarrierProperty,
+    [ReactionEnergyProfileProperty.propertyName]: ReactionEnergyProfileProperty,
+    [PotentialProfileProperty.propertyName]: PotentialProfileProperty,
+    [ChargeDensityProfileProperty.propertyName]: ChargeDensityProfileProperty,
+    [AveragePotentialProfileProperty.propertyName]: AveragePotentialProfileProperty,
+    [ValenceBandOffsetProperty.propertyName]: ValenceBandOffsetProperty,
+    [IonizationPotentialElementalProperty.propertyName]: IonizationPotentialElementalProperty,
+    [FileContentProperty.propertyName]: FileContentProperty,
+    [DielectricTensorProperty.propertyName]: DielectricTensorProperty,
+    [HubbardUProperty.propertyName]: HubbardUProperty,
+    [HubbardVNNProperty.propertyName]: HubbardVNNProperty,
+    [HubbardVProperty.propertyName]: HubbardVProperty,
+    [JupyterNotebookEndpointProperty.propertyName]: JupyterNotebookEndpointProperty,
+};
+
+const META_PROPERTY_CLASS_MAP: MetaPropertyClassMap = {
+    [PseudopotentialProperty.propertyName]: PseudopotentialProperty,
+};
+
+const PROTO_PROPERTY_CLASS_MAP: ProtoPropertyClassMap = {
+    [BoundaryConditionsProperty.propertyName]: BoundaryConditionsProperty,
+    [AtomicConstraintsProperty.propertyName]: AtomicConstraintsProperty,
+};
+
+export default class PropertyFactory {
+    static methodsTree: Record<string, () => void> = {};
+
+    static getRefinedPropertyNames(): PropertyName[] {
+        return this.filterPropertyNames((PropertyClass) => {
+            return (PropertyClass as typeof Property).isRefined;
+        });
+    }
+
+    static getConvergencePropertyNames(): PropertyName[] {
+        return this.filterPropertyNames((PropertyClass) => {
+            return (PropertyClass as typeof Property).isConvergence;
+        });
+    }
+
+    static getMultipleResultsPropertyNames(): PropertyName[] {
+        return this.filterPropertyNames((PropertyClass) => {
+            return (PropertyClass as typeof Property).isAbleToReturnMultipleResults;
+        });
+    }
+
+    static getScalarPropertyNames(): PropertyName[] {
+        return this.filterPropertyNames((PropertyClass) => {
+            return (PropertyClass as typeof Property).propertyType === PropertyType.scalar;
+        });
+    }
+
+    static getNonScalarPropertyNames(): PropertyName[] {
+        return this.filterPropertyNames((PropertyClass) => {
+            return (PropertyClass as typeof Property).propertyType === PropertyType.non_scalar;
+        });
+    }
+
+    private static filterPropertyNames(
+        filterFn: (PropertyClass: Constructor<Property>) => boolean,
+    ): PropertyName[] {
+        const properties = Object.values({
+            ...PROPERTY_CLASS_MAP,
+            ...META_PROPERTY_CLASS_MAP,
+            ...PROTO_PROPERTY_CLASS_MAP,
+        });
+
+        return properties.filter(filterFn).map((PropertyClass: Constructor<Property>) => {
+            return (PropertyClass as typeof Property).propertyName;
+        });
+    }
+
+    static createProperty(config: AnyProperty) {
+        const PropertyClass = PROPERTY_CLASS_MAP[config.name];
+
+        return new PropertyClass(config);
+    }
+
+    static createMetaProperty(config: AnyMetaProperty): MetaProperty {
+        const { name } = config;
+        const PropertyClass = META_PROPERTY_CLASS_MAP[name];
+        return new PropertyClass(config);
+    }
+
+    static createProtoProperty(config: AnyProtoProperty) {
+        const { name } = config;
+        const PropertyClass = PROTO_PROPERTY_CLASS_MAP[name];
+        return new PropertyClass(config);
+    }
+}

package/src/js/ProtoProperty.ts

@@ -0,0 +1,6 @@
+import Property from "./Property";
+import { PropertyType } from "./settings";
+
+export default class ProtoProperty<TSchema extends object = object> extends Property<TSchema> {
+    static readonly propertyType = PropertyType.non_scalar;
+}

package/src/js/charts/highcharts.ts

@@ -0,0 +1,172 @@
+/* eslint-disable class-methods-use-this */
+
+import type { AxisOptions, IndividualSeriesOptions, Options, PlotLines } from "highcharts";
+
+import type { XDataArray } from "../properties/include/mixins/2d_plot";
+
+/**
+ * Callback JavaScript function to format the data label. Note that if a format is defined, the format takes
+ * precedence and the formatter is ignored.
+ * Available data are:
+ * - this.percentage Stacked series and pies only. The point's percentage of the total.
+ * - this.point      The point object. The point name, if defined, is available through this.point.name.
+ * - this.series     The series object. The series name is available through this.series.name.
+ * - this.total      Stacked series only. The total value at this point's x value.
+ * - this.x:         The x value.
+ * - this.y:         The y value.
+ */
+export type FormatterScope = {
+    percentage: number;
+    point: {
+        name: string;
+        index: number;
+    };
+    series: {
+        name: string;
+    };
+    total: number;
+    x: number;
+    y: number;
+    key: number;
+};
+
+export type Formatter = (this: FormatterScope) => string;
+
+export interface HighChartsConfigParams {
+    title?: string;
+    subtitle: string;
+    yAxisTitle?: string;
+    xAxisTitle?: string;
+    yAxisType: string;
+    series?: IndividualSeriesOptions[];
+    legend?: string[] | object[] | boolean;
+}
+
+/**
+ * @description Base class for Highcharts configuration
+ */
+export abstract class HighChartsConfig implements HighChartsConfigParams {
+    readonly title: HighChartsConfigParams["title"];
+
+    readonly subtitle: HighChartsConfigParams["subtitle"];
+
+    readonly yAxisTitle: HighChartsConfigParams["yAxisTitle"];
+
+    readonly xAxisTitle: HighChartsConfigParams["xAxisTitle"];
+
+    readonly yAxisType: HighChartsConfigParams["yAxisType"];
+
+    readonly legend: HighChartsConfigParams["legend"];
+
+    readonly _series: HighChartsConfigParams["series"];
+
+    constructor({
+        title,
+        subtitle,
+        yAxisTitle,
+        xAxisTitle,
+        yAxisType,
+        series,
+        legend,
+    }: HighChartsConfigParams) {
+        this.title = title;
+        this.subtitle = subtitle;
+        this.yAxisTitle = yAxisTitle;
+        this.xAxisTitle = xAxisTitle;
+        this.yAxisType = yAxisType;
+        this._series = series;
+        this.legend = legend;
+    }
+
+    yAxis(): AxisOptions {
+        return {
+            title: {
+                text: this.yAxisTitle,
+            },
+            type: this.yAxisType,
+            gridLineColor: "#eee",
+            plotLines: [
+                {
+                    value: 0,
+                    width: 1,
+                    color: "#808080",
+                },
+            ],
+        };
+    }
+
+    xAxis(): AxisOptions {
+        return {
+            title: {
+                text: this.xAxisTitle,
+            },
+            tickPixelInterval: 200,
+        };
+    }
+
+    // override in children
+    abstract tooltipFormatter(_xDataArray?: XDataArray): (this: FormatterScope) => string;
+
+    plotSingleLine({
+        value,
+        width = 1,
+        label,
+        color = "red",
+        dashStyle = "dash",
+    }: PlotLines): PlotLines[] {
+        return [
+            {
+                value,
+                width,
+                label,
+                color,
+                dashStyle,
+            },
+        ];
+    }
+
+    get series() {
+        return this._series;
+    }
+
+    get config(): Options {
+        return {
+            credits: {
+                enabled: false,
+            },
+            chart: {
+                animation: false,
+                zoomType: "xy",
+            },
+            title: {
+                text: "",
+                x: -20, // center
+            },
+            subtitle: {
+                text: this.subtitle,
+                x: -20,
+            },
+            yAxis: this.yAxis(),
+            xAxis: this.xAxis(),
+            tooltip: {
+                formatter: this.tooltipFormatter(),
+            },
+            plotOptions: {
+                series: {
+                    animation: false,
+                },
+            },
+            legend: {
+                enabled: Boolean(this.legend),
+                maxHeight: 70,
+            },
+            series: this.series,
+            ...this.overrideConfig,
+        };
+    }
+
+    // use in child classes to add/override default config props
+    get overrideConfig(): Options {
+        return {};
+    }
+}

package/src/js/generated/AtomicConstraintsPropertySchemaMixin.ts

@@ -0,0 +1,24 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AtomicConstraintsPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type AtomicConstraintsPropertySchemaMixin = Omit<
+    AtomicConstraintsPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type AtomicConstraintsPropertyInMemoryEntity = InMemoryEntity &
+    AtomicConstraintsPropertySchemaMixin;
+
+export function atomicConstraintsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & AtomicConstraintsPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<AtomicConstraintsPropertySchema["name"]>("name");
+        },
+        get values() {
+            return this.requiredProp<AtomicConstraintsPropertySchema["values"]>("values");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/AtomicForcesPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AtomicForcesPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type AtomicForcesPropertySchemaMixin = Omit<
+    AtomicForcesPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type AtomicForcesPropertyInMemoryEntity = InMemoryEntity & AtomicForcesPropertySchemaMixin;
+
+export function atomicForcesPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & AtomicForcesPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<AtomicForcesPropertySchema["name"]>("name");
+        },
+        get values() {
+            return this.requiredProp<AtomicForcesPropertySchema["values"]>("values");
+        },
+        get units() {
+            return this.requiredProp<AtomicForcesPropertySchema["units"]>("units");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/AveragePotentialProfilePropertySchemaMixin.ts

@@ -0,0 +1,37 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AveragePotentialProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type AveragePotentialProfilePropertySchemaMixin = Omit<
+    AveragePotentialProfilePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type AveragePotentialProfilePropertyInMemoryEntity = InMemoryEntity &
+    AveragePotentialProfilePropertySchemaMixin;
+
+export function averagePotentialProfilePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & AveragePotentialProfilePropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<AveragePotentialProfilePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<AveragePotentialProfilePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<AveragePotentialProfilePropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<AveragePotentialProfilePropertySchema["xDataArray"]>(
+                "xDataArray",
+            );
+        },
+        get yDataSeries() {
+            return this.requiredProp<AveragePotentialProfilePropertySchema["yDataSeries"]>(
+                "yDataSeries",
+            );
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/BandGapsPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BandGapsPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type BandGapsPropertySchemaMixin = Omit<
+    BandGapsPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type BandGapsPropertyInMemoryEntity = InMemoryEntity & BandGapsPropertySchemaMixin;
+
+export function bandGapsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & BandGapsPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<BandGapsPropertySchema["name"]>("name");
+        },
+        get values() {
+            return this.requiredProp<BandGapsPropertySchema["values"]>("values");
+        },
+        get eigenvalues() {
+            return this.prop<BandGapsPropertySchema["eigenvalues"]>("eigenvalues");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/BandStructurePropertySchemaMixin.ts

@@ -0,0 +1,35 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BandStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type BandStructurePropertySchemaMixin = Omit<
+    BandStructurePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type BandStructurePropertyInMemoryEntity = InMemoryEntity & BandStructurePropertySchemaMixin;
+
+export function bandStructurePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & BandStructurePropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<BandStructurePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<BandStructurePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<BandStructurePropertySchema["name"]>("name");
+        },
+        get spin() {
+            return this.requiredProp<BandStructurePropertySchema["spin"]>("spin");
+        },
+        get xDataArray() {
+            return this.requiredProp<BandStructurePropertySchema["xDataArray"]>("xDataArray");
+        },
+        get yDataSeries() {
+            return this.requiredProp<BandStructurePropertySchema["yDataSeries"]>("yDataSeries");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/BoundaryConditionsPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BoundaryConditionsPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type BoundaryConditionsPropertySchemaMixin = Omit<
+    BoundaryConditionsPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type BoundaryConditionsPropertyInMemoryEntity = InMemoryEntity &
+    BoundaryConditionsPropertySchemaMixin;
+
+export function boundaryConditionsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & BoundaryConditionsPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<BoundaryConditionsPropertySchema["name"]>("name");
+        },
+        get type() {
+            return this.requiredProp<BoundaryConditionsPropertySchema["type"]>("type");
+        },
+        get offset() {
+            return this.requiredProp<BoundaryConditionsPropertySchema["offset"]>("offset");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ChargeDensityProfilePropertySchemaMixin.ts

@@ -0,0 +1,37 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ChargeDensityProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type ChargeDensityProfilePropertySchemaMixin = Omit<
+    ChargeDensityProfilePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type ChargeDensityProfilePropertyInMemoryEntity = InMemoryEntity &
+    ChargeDensityProfilePropertySchemaMixin;
+
+export function chargeDensityProfilePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ChargeDensityProfilePropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<ChargeDensityProfilePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<ChargeDensityProfilePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<ChargeDensityProfilePropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<ChargeDensityProfilePropertySchema["xDataArray"]>(
+                "xDataArray",
+            );
+        },
+        get yDataSeries() {
+            return this.requiredProp<ChargeDensityProfilePropertySchema["yDataSeries"]>(
+                "yDataSeries",
+            );
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ConvergenceElectronicPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ConvergenceElectronicPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type ConvergenceElectronicPropertySchemaMixin = Omit<
+    ConvergenceElectronicPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type ConvergenceElectronicPropertyInMemoryEntity = InMemoryEntity &
+    ConvergenceElectronicPropertySchemaMixin;
+
+export function convergenceElectronicPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ConvergenceElectronicPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<ConvergenceElectronicPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<ConvergenceElectronicPropertySchema["units"]>("units");
+        },
+        get data() {
+            return this.requiredProp<ConvergenceElectronicPropertySchema["data"]>("data");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ConvergenceIonicPropertySchemaMixin.ts

@@ -0,0 +1,30 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ConvergenceIonicPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type ConvergenceIonicPropertySchemaMixin = Omit<
+    ConvergenceIonicPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type ConvergenceIonicPropertyInMemoryEntity = InMemoryEntity &
+    ConvergenceIonicPropertySchemaMixin;
+
+export function convergenceIonicPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ConvergenceIonicPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<ConvergenceIonicPropertySchema["name"]>("name");
+        },
+        get tolerance() {
+            return this.prop<ConvergenceIonicPropertySchema["tolerance"]>("tolerance");
+        },
+        get units() {
+            return this.requiredProp<ConvergenceIonicPropertySchema["units"]>("units");
+        },
+        get data() {
+            return this.requiredProp<ConvergenceIonicPropertySchema["data"]>("data");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}