@mat3ra/prode 2025.11.25-0

package/dist/js/properties/non-scalar/PotentialProfileProperty.d.ts

@@ -0,0 +1,38 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PotentialProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { PotentialProfilePropertySchemaMixin } from "../../generated/PotentialProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+type Schema = PotentialProfilePropertySchema;
+export declare class PotentialProfileConfig extends TwoDimensionalHighChartConfigMixin {
+    readonly tooltipXAxisName: string;
+    readonly tooltipYAxisName: string;
+    get series(): {
+        animation: boolean;
+        name: string;
+        data: [number, number][];
+    }[];
+    get overrideConfig(): {
+        legend: {
+            layout: string;
+            align: string;
+            verticalAlign: string;
+            borderWidth: number;
+        };
+    };
+}
+type Base = typeof Property<Schema> & Constructor<PotentialProfilePropertySchemaMixin>;
+declare const PotentialProfileProperty_base: Base;
+declare class PotentialProfileProperty extends PotentialProfileProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.potential_profile;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export default PotentialProfileProperty;

package/dist/js/properties/non-scalar/PotentialProfileProperty.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PotentialProfileConfig = void 0;
+const zip_1 = __importDefault(require("lodash/zip"));
+const PotentialProfilePropertySchemaMixin_1 = require("../../generated/PotentialProfilePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const _2d_plot_1 = require("../include/mixins/2d_plot");
+const NAMES = {
+    0: "averageVHartree",
+    1: "averageVLocal",
+    2: "averageVHartreePlusLocal",
+};
+class PotentialProfileConfig extends _2d_plot_1.TwoDimensionalHighChartConfigMixin {
+    constructor() {
+        super(...arguments);
+        this.tooltipXAxisName = "z coordinate";
+        this.tooltipYAxisName = "energy";
+    }
+    get series() {
+        return this.yDataSeries.map((item, index) => {
+            return {
+                animation: false,
+                name: NAMES[index],
+                data: (0, zip_1.default)(this.xDataArray, item),
+            };
+        });
+    }
+    get overrideConfig() {
+        return {
+            ...super.overrideConfig,
+            legend: {
+                layout: "horizontal",
+                align: "center",
+                verticalAlign: "bottom",
+                borderWidth: 0,
+            },
+        };
+    }
+}
+exports.PotentialProfileConfig = PotentialProfileConfig;
+class PotentialProfileProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: PotentialProfileProperty.propertyName });
+        this.subtitle = "Potential Profile";
+        this.yAxisTitle = `Energy (${this.yAxis.units})`;
+        this.xAxisTitle = "Z Coordinate";
+        this.chartConfig = new PotentialProfileConfig(this).config;
+    }
+}
+PotentialProfileProperty.isRefined = true;
+PotentialProfileProperty.propertyName = settings_1.PropertyName.potential_profile;
+PotentialProfileProperty.propertyType = settings_1.PropertyType.non_scalar;
+(0, PotentialProfilePropertySchemaMixin_1.potentialProfilePropertySchemaMixin)(PotentialProfileProperty.prototype);
+exports.default = PotentialProfileProperty;

package/dist/js/properties/non-scalar/ReactionEnergyProfileProperty.d.ts

@@ -0,0 +1,25 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ReactionEnergyProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { ReactionEnergyProfilePropertySchemaMixin } from "../../generated/ReactionEnergyProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+type Schema = ReactionEnergyProfilePropertySchema;
+export declare class ReactionEnergyProfileConfig extends TwoDimensionalHighChartConfigMixin {
+    readonly tooltipXAxisName: string;
+    readonly tooltipYAxisName: string;
+}
+type Base = typeof Property<Schema> & Constructor<ReactionEnergyProfilePropertySchemaMixin>;
+declare const ReactionEnergyProfileProperty_base: Base;
+declare class ReactionEnergyProfileProperty extends ReactionEnergyProfileProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.reaction_energy_profile;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export default ReactionEnergyProfileProperty;

package/dist/js/properties/non-scalar/ReactionEnergyProfileProperty.js

@@ -0,0 +1,34 @@
+"use strict";
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactionEnergyProfileConfig = void 0;
+const ReactionEnergyProfilePropertySchemaMixin_1 = require("../../generated/ReactionEnergyProfilePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const _2d_plot_1 = require("../include/mixins/2d_plot");
+class ReactionEnergyProfileConfig extends _2d_plot_1.TwoDimensionalHighChartConfigMixin {
+    constructor() {
+        super(...arguments);
+        this.tooltipXAxisName = "reaction coordinate";
+        this.tooltipYAxisName = "energy";
+    }
+}
+exports.ReactionEnergyProfileConfig = ReactionEnergyProfileConfig;
+class ReactionEnergyProfileProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: ReactionEnergyProfileProperty.propertyName });
+        this.subtitle = "Reaction Energy Profile";
+        this.yAxisTitle = `Energy (${this.yAxis.units})`;
+        this.xAxisTitle = "Reaction Coordinate";
+        this.chartConfig = new ReactionEnergyProfileConfig(this).config;
+    }
+}
+ReactionEnergyProfileProperty.isRefined = true;
+ReactionEnergyProfileProperty.propertyName = settings_1.PropertyName.reaction_energy_profile;
+ReactionEnergyProfileProperty.propertyType = settings_1.PropertyType.non_scalar;
+(0, ReactionEnergyProfilePropertySchemaMixin_1.reactionEnergyProfilePropertySchemaMixin)(ReactionEnergyProfileProperty.prototype);
+exports.default = ReactionEnergyProfileProperty;

package/dist/js/properties/non-scalar/WorkflowProperty.d.ts

@@ -0,0 +1,14 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { WorkflowPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { WorkflowPropertySchemaMixin } from "../../generated/WorkflowPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = WorkflowPropertySchema;
+type Base = typeof Property<Schema> & Constructor<WorkflowPropertySchemaMixin>;
+declare const WorkflowProperty_base: Base;
+export default class WorkflowProperty extends WorkflowProperty_base implements Schema {
+    static readonly propertyName = PropertyName.workflow_pyml_predict;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/non-scalar/WorkflowProperty.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkflowPropertySchemaMixin_1 = require("../../generated/WorkflowPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class WorkflowProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: WorkflowProperty.propertyName });
+    }
+}
+WorkflowProperty.propertyName = settings_1.PropertyName.workflow_pyml_predict;
+WorkflowProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = WorkflowProperty;
+(0, WorkflowPropertySchemaMixin_1.workflowPropertySchemaMixin)(WorkflowProperty.prototype);

package/dist/js/properties/non-scalar/convergence/ConvergenceElectronicProperty.d.ts

@@ -0,0 +1,17 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ConvergenceElectronicPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { ConvergenceElectronicPropertySchemaMixin } from "../../../generated/ConvergenceElectronicPropertySchemaMixin";
+import Property from "../../../Property";
+import { PropertyName, PropertyType } from "../../../settings";
+type Schema = ConvergenceElectronicPropertySchema;
+type Base = typeof Property<Schema> & Constructor<ConvergenceElectronicPropertySchemaMixin>;
+declare const ConvergenceElectronicProperty_base: Base;
+declare class ConvergenceElectronicProperty extends ConvergenceElectronicProperty_base implements Schema {
+    static readonly propertyName = PropertyName.convergence_electronic;
+    static readonly propertyType = PropertyType.non_scalar;
+    static readonly isConvergence = true;
+    readonly chartConfig: Options;
+    constructor(config: Omit<Schema, "name">);
+}
+export default ConvergenceElectronicProperty;

package/dist/js/properties/non-scalar/convergence/ConvergenceElectronicProperty.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const highcharts_1 = require("../../../charts/highcharts");
+const ConvergenceElectronicPropertySchemaMixin_1 = require("../../../generated/ConvergenceElectronicPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../../Property"));
+const settings_1 = require("../../../settings");
+class ConvergenceElectronicConfig extends highcharts_1.HighChartsConfig {
+    constructor(monitor) {
+        let iteration = 1;
+        const series = monitor.data.map((values, index) => {
+            const name = parseInt(index.toString(), 10) + 1;
+            return {
+                name: `step-${name}`,
+                data: values.map((value) => {
+                    // give points unique xAxis value to show multiple series properly in highCharts
+                    const point = [iteration, Math.abs(value)];
+                    iteration += 1;
+                    return point;
+                }),
+            };
+        });
+        super({
+            subtitle: "Convergence Electronic",
+            yAxisTitle: `Convergence Electronic (${monitor.units})`,
+            xAxisTitle: "Iterations",
+            yAxisType: "logarithmic",
+            series,
+            legend: series.length > 1,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    tooltipFormatter() {
+        // note 'this' below refers to Highcharts tooltip scope
+        // eslint-disable-next-line func-names
+        return function () {
+            return "<b>iteration:</b> " + this.key + "<br><b>Δ E:</b> " + this.y.toExponential(1);
+        };
+    }
+    yAxis() {
+        return {
+            ...super.yAxis(),
+            labels: {
+                formatter() {
+                    return this.value.toExponential();
+                },
+            },
+        };
+    }
+}
+class ConvergenceElectronicProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: ConvergenceElectronicProperty.propertyName });
+        this.chartConfig = new ConvergenceElectronicConfig(this).config;
+    }
+}
+ConvergenceElectronicProperty.propertyName = settings_1.PropertyName.convergence_electronic;
+ConvergenceElectronicProperty.propertyType = settings_1.PropertyType.non_scalar;
+ConvergenceElectronicProperty.isConvergence = true;
+(0, ConvergenceElectronicPropertySchemaMixin_1.convergenceElectronicPropertySchemaMixin)(ConvergenceElectronicProperty.prototype);
+exports.default = ConvergenceElectronicProperty;

package/dist/js/properties/non-scalar/convergence/ConvergenceIonicProperty.d.ts

@@ -0,0 +1,17 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ConvergenceIonicPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { ConvergenceIonicPropertySchemaMixin } from "../../../generated/ConvergenceIonicPropertySchemaMixin";
+import Property from "../../../Property";
+import { PropertyName, PropertyType } from "../../../settings";
+type Schema = ConvergenceIonicPropertySchema;
+type Base = typeof Property<Schema> & Constructor<ConvergenceIonicPropertySchemaMixin>;
+declare const ConvergenceIonicProperty_base: Base;
+declare class ConvergenceIonicProperty extends ConvergenceIonicProperty_base implements Schema {
+    static readonly propertyName = PropertyName.convergence_ionic;
+    static readonly propertyType = PropertyType.non_scalar;
+    static readonly isConvergence = true;
+    readonly chartConfig: Options;
+    constructor(config: Omit<Schema, "name">);
+}
+export default ConvergenceIonicProperty;

package/dist/js/properties/non-scalar/convergence/ConvergenceIonicProperty.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const highcharts_1 = require("../../../charts/highcharts");
+const ConvergenceIonicPropertySchemaMixin_1 = require("../../../generated/ConvergenceIonicPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../../Property"));
+const settings_1 = require("../../../settings");
+class ConvergenceIonicConfig extends highcharts_1.HighChartsConfig {
+    constructor(monitor) {
+        super({
+            subtitle: "Ionic Energy",
+            yAxisTitle: `Ionic Energy (${monitor.units})`,
+            xAxisTitle: "Steps",
+            yAxisType: "linear",
+            series: [
+                {
+                    data: monitor.data.map((value, index) => {
+                        return [Number(index) + 1, value.energy];
+                    }),
+                },
+            ],
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function () {
+            // eslint-disable-next-line no-useless-concat
+            return "<b>step:</b> " + this.key + "<br>" + "<b>Energy:</b> " + this.y.toFixed(4);
+        };
+    }
+}
+class ConvergenceIonicProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: ConvergenceIonicProperty.propertyName });
+        this.chartConfig = new ConvergenceIonicConfig(this).config;
+    }
+}
+ConvergenceIonicProperty.propertyName = settings_1.PropertyName.convergence_ionic;
+ConvergenceIonicProperty.propertyType = settings_1.PropertyType.non_scalar;
+ConvergenceIonicProperty.isConvergence = true;
+(0, ConvergenceIonicPropertySchemaMixin_1.convergenceIonicPropertySchemaMixin)(ConvergenceIonicProperty.prototype);
+exports.default = ConvergenceIonicProperty;

package/dist/js/properties/object/TotalEnergyContributionsProperty.d.ts

@@ -0,0 +1,18 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { TotalEnergyContributionsPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { TotalEnergyContributionsPropertySchemaMixin } from "../../generated/TotalEnergyContributionsPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = TotalEnergyContributionsPropertySchema;
+type Base = typeof Property<Schema> & Constructor<TotalEnergyContributionsPropertySchemaMixin>;
+declare const TotalEnergyContributionsProperty_base: Base;
+export default class TotalEnergyContributionsProperty extends TotalEnergyContributionsProperty_base implements Schema {
+    static readonly propertyType = PropertyType.object;
+    static readonly propertyName = PropertyName.total_energy_contributions;
+    constructor(config: Omit<Schema, "name">);
+    get exchangeCorrelation(): {
+        name?: "exchange_correlation";
+        value: number;
+    } | undefined;
+}
+export {};

package/dist/js/properties/object/TotalEnergyContributionsProperty.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TotalEnergyContributionsPropertySchemaMixin_1 = require("../../generated/TotalEnergyContributionsPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class TotalEnergyContributionsProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: TotalEnergyContributionsProperty.propertyName });
+    }
+    get exchangeCorrelation() {
+        return this.exchange_correlation;
+    }
+}
+TotalEnergyContributionsProperty.propertyType = settings_1.PropertyType.object;
+TotalEnergyContributionsProperty.propertyName = settings_1.PropertyName.total_energy_contributions;
+exports.default = TotalEnergyContributionsProperty;
+(0, TotalEnergyContributionsPropertySchemaMixin_1.totalEnergyContributionsPropertySchemaMixin)(TotalEnergyContributionsProperty.prototype);

package/dist/js/properties/scalar/FermiEnergyProperty.d.ts

@@ -0,0 +1,14 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FermiEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { FermiEnergyPropertySchemaMixin } from "../../generated/FermiEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = FermiEnergyPropertySchema;
+type Base = typeof Property<Schema> & Constructor<FermiEnergyPropertySchemaMixin>;
+declare const FermiEnergyProperty_base: Base;
+export default class FermiEnergyProperty extends FermiEnergyProperty_base implements Schema {
+    static readonly propertyName = PropertyName.fermi_energy;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/FermiEnergyProperty.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FermiEnergyPropertySchemaMixin_1 = require("../../generated/FermiEnergyPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class FermiEnergyProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: FermiEnergyProperty.propertyName });
+    }
+}
+FermiEnergyProperty.propertyName = settings_1.PropertyName.fermi_energy;
+FermiEnergyProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = FermiEnergyProperty;
+(0, FermiEnergyPropertySchemaMixin_1.fermiEnergyPropertySchemaMixin)(FermiEnergyProperty.prototype);

package/dist/js/properties/scalar/IonizationPotentialElementalProperty.d.ts

@@ -0,0 +1,14 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { IonizationPotentialElementalPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { IonizationPotentialElementalPropertySchemaMixin } from "../../generated/IonizationPotentialElementalPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = IonizationPotentialElementalPropertySchema;
+type Base = typeof Property<Schema> & Constructor<IonizationPotentialElementalPropertySchemaMixin>;
+declare const IonizationPotentialElementalProperty_base: Base;
+declare class IonizationPotentialElementalProperty extends IonizationPotentialElementalProperty_base implements Schema {
+    static readonly propertyName = PropertyName.ionization_potential;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export default IonizationPotentialElementalProperty;

package/dist/js/properties/scalar/IonizationPotentialElementalProperty.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const IonizationPotentialElementalPropertySchemaMixin_1 = require("../../generated/IonizationPotentialElementalPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class IonizationPotentialElementalProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: IonizationPotentialElementalProperty.propertyName });
+    }
+}
+IonizationPotentialElementalProperty.propertyName = settings_1.PropertyName.ionization_potential;
+IonizationPotentialElementalProperty.propertyType = settings_1.PropertyType.scalar;
+(0, IonizationPotentialElementalPropertySchemaMixin_1.ionizationPotentialElementalPropertySchemaMixin)(IonizationPotentialElementalProperty.prototype);
+exports.default = IonizationPotentialElementalProperty;

package/dist/js/properties/scalar/PressureProperty.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PressurePropertySchema } from "@mat3ra/esse/dist/js/types";
+import { PressurePropertySchemaMixin } from "../../generated/PressurePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = PressurePropertySchema;
+type Base = typeof Property<Schema> & Constructor<PressurePropertySchemaMixin>;
+declare const PressureProperty_base: Base;
+export default class PressureProperty extends PressureProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.pressure;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/PressureProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PressurePropertySchemaMixin_1 = require("../../generated/PressurePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class PressureProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: PressureProperty.propertyName });
+    }
+}
+PressureProperty.isRefined = true;
+PressureProperty.propertyName = settings_1.PropertyName.pressure;
+PressureProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = PressureProperty;
+(0, PressurePropertySchemaMixin_1.pressurePropertySchemaMixin)(PressureProperty.prototype);

package/dist/js/properties/scalar/ReactionEnergyBarrierProperty.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ReactionEnergyBarrierPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { ReactionEnergyBarrierPropertySchemaMixin } from "../../generated/ReactionEnergyBarrierPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = ReactionEnergyBarrierPropertySchema;
+type Base = typeof Property<Schema> & Constructor<ReactionEnergyBarrierPropertySchemaMixin>;
+declare const ReactionEnergyBarrierProperty_base: Base;
+declare class ReactionEnergyBarrierProperty extends ReactionEnergyBarrierProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.reaction_energy_barrier;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export default ReactionEnergyBarrierProperty;

package/dist/js/properties/scalar/ReactionEnergyBarrierProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReactionEnergyBarrierPropertySchemaMixin_1 = require("../../generated/ReactionEnergyBarrierPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class ReactionEnergyBarrierProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: ReactionEnergyBarrierProperty.propertyName });
+    }
+}
+ReactionEnergyBarrierProperty.isRefined = true;
+ReactionEnergyBarrierProperty.propertyName = settings_1.PropertyName.reaction_energy_barrier;
+ReactionEnergyBarrierProperty.propertyType = settings_1.PropertyType.scalar;
+(0, ReactionEnergyBarrierPropertySchemaMixin_1.reactionEnergyBarrierPropertySchemaMixin)(ReactionEnergyBarrierProperty.prototype);
+exports.default = ReactionEnergyBarrierProperty;

package/dist/js/properties/scalar/SurfaceEnergyProperty.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { SurfaceEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { SurfaceEnergyPropertySchemaMixin } from "../../generated/SurfaceEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = SurfaceEnergyPropertySchema;
+type Base = typeof Property<Schema> & Constructor<SurfaceEnergyPropertySchemaMixin>;
+declare const SurfaceEnergyProperty_base: Base;
+export default class SurfaceEnergyProperty extends SurfaceEnergyProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.surface_energy;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/SurfaceEnergyProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SurfaceEnergyPropertySchemaMixin_1 = require("../../generated/SurfaceEnergyPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class SurfaceEnergyProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: SurfaceEnergyProperty.propertyName });
+    }
+}
+SurfaceEnergyProperty.isRefined = true;
+SurfaceEnergyProperty.propertyName = settings_1.PropertyName.surface_energy;
+SurfaceEnergyProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = SurfaceEnergyProperty;
+(0, SurfaceEnergyPropertySchemaMixin_1.surfaceEnergyPropertySchemaMixin)(SurfaceEnergyProperty.prototype);

package/dist/js/properties/scalar/TotalEnergyProperty.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { TotalEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { TotalEnergyPropertySchemaMixin } from "../../generated/TotalEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = TotalEnergyPropertySchema;
+type Base = typeof Property<Schema> & Constructor<TotalEnergyPropertySchemaMixin>;
+declare const TotalEnergyProperty_base: Base;
+export default class TotalEnergyProperty extends TotalEnergyProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.total_energy;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/TotalEnergyProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TotalEnergyPropertySchemaMixin_1 = require("../../generated/TotalEnergyPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class TotalEnergyProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: TotalEnergyProperty.propertyName });
+    }
+}
+TotalEnergyProperty.isRefined = true;
+TotalEnergyProperty.propertyName = settings_1.PropertyName.total_energy;
+TotalEnergyProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = TotalEnergyProperty;
+(0, TotalEnergyPropertySchemaMixin_1.totalEnergyPropertySchemaMixin)(TotalEnergyProperty.prototype);

package/dist/js/properties/scalar/TotalForceProperty.d.ts

@@ -0,0 +1,14 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { TotalForcesPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { TotalForcePropertySchemaMixin } from "../../generated/TotalForcePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = TotalForcesPropertySchema;
+type Base = typeof Property<Schema> & Constructor<TotalForcePropertySchemaMixin>;
+declare const TotalForceProperty_base: Base;
+export default class TotalForceProperty extends TotalForceProperty_base implements Schema {
+    static readonly propertyName = PropertyName.total_force;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/TotalForceProperty.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TotalForcePropertySchemaMixin_1 = require("../../generated/TotalForcePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class TotalForceProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: TotalForceProperty.propertyName });
+    }
+}
+TotalForceProperty.propertyName = settings_1.PropertyName.total_force;
+TotalForceProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = TotalForceProperty;
+(0, TotalForcePropertySchemaMixin_1.totalForcePropertySchemaMixin)(TotalForceProperty.prototype);