@mat3ra/prode 2025.11.25-0

package/dist/js/holders/mixins/ProtoPropertyHolderMixin.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 });
+exports.protoPropertyHolderMixin = protoPropertyHolderMixin;
+const ProtoPropertyHolderSchemaMixin_1 = require("../../generated/ProtoPropertyHolderSchemaMixin");
+const PropertyFactory_1 = __importDefault(require("../../PropertyFactory"));
+function protoPropertyHolderMixin(item) {
+    // @ts-expect-error - this is a workaround to allow the protoPropertyMixin to be used with any type of entity
+    const properties = {
+        get property() {
+            return PropertyFactory_1.default.createProtoProperty(this.data);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    (0, ProtoPropertyHolderSchemaMixin_1.protoPropertyHolderSchemaMixin)(item);
+}

package/dist/js/index.d.ts

@@ -0,0 +1,20 @@
+export { default as PropertyFactory } from "./PropertyFactory";
+export { PropertyName, PropertyType } from "./settings";
+export { default as Property } from "./Property";
+export { default as MetaProperty } from "./MetaProperty";
+export { default as PseudopotentialMetaProperty } from "./meta_properties/PseudopotentialMetaProperty";
+export { default as FinalStructureProperty } from "./properties/non-scalar/FinalStructureProperty";
+export { default as BandGapsProperty } from "./properties/non-scalar/BandGapsProperty";
+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 SurfaceEnergyProperty } from "./properties/scalar/SurfaceEnergyProperty";
+export { default as TotalEnergyProperty } from "./properties/scalar/TotalEnergyProperty";
+export { default as BandStructureProperty } from "./properties/non-scalar/BandStructureProperty";
+export { default as ChargeDensityProfileProperty } from "./properties/non-scalar/ChargeDensityProfileProperty";
+export { default as PotentialProfileProperty } from "./properties/non-scalar/PotentialProfileProperty";
+export { default as ReactionEnergyProfileProperty } from "./properties/non-scalar/ReactionEnergyProfileProperty";
+export { protoPropertyHolderMixin } from "./holders/mixins/ProtoPropertyHolderMixin";
+export { propertyHolderMixin } from "./holders/mixins/PropertyHolderMixin";
+export { metaPropertyHolderMixin } from "./holders/mixins/MetaPropertyHolderMixin";
+export * from "./types";

package/dist/js/index.js

@@ -0,0 +1,60 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaPropertyHolderMixin = exports.propertyHolderMixin = exports.protoPropertyHolderMixin = exports.ReactionEnergyProfileProperty = exports.PotentialProfileProperty = exports.ChargeDensityProfileProperty = exports.BandStructureProperty = exports.TotalEnergyProperty = exports.SurfaceEnergyProperty = exports.ReactionEnergyBarrierProperty = exports.PressureProperty = exports.IsRelaxedProperty = exports.BandGapsProperty = exports.FinalStructureProperty = exports.PseudopotentialMetaProperty = exports.MetaProperty = exports.Property = exports.PropertyType = exports.PropertyName = exports.PropertyFactory = void 0;
+var PropertyFactory_1 = require("./PropertyFactory");
+Object.defineProperty(exports, "PropertyFactory", { enumerable: true, get: function () { return __importDefault(PropertyFactory_1).default; } });
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "PropertyName", { enumerable: true, get: function () { return settings_1.PropertyName; } });
+Object.defineProperty(exports, "PropertyType", { enumerable: true, get: function () { return settings_1.PropertyType; } });
+var Property_1 = require("./Property");
+Object.defineProperty(exports, "Property", { enumerable: true, get: function () { return __importDefault(Property_1).default; } });
+var MetaProperty_1 = require("./MetaProperty");
+Object.defineProperty(exports, "MetaProperty", { enumerable: true, get: function () { return __importDefault(MetaProperty_1).default; } });
+var PseudopotentialMetaProperty_1 = require("./meta_properties/PseudopotentialMetaProperty");
+Object.defineProperty(exports, "PseudopotentialMetaProperty", { enumerable: true, get: function () { return __importDefault(PseudopotentialMetaProperty_1).default; } });
+var FinalStructureProperty_1 = require("./properties/non-scalar/FinalStructureProperty");
+Object.defineProperty(exports, "FinalStructureProperty", { enumerable: true, get: function () { return __importDefault(FinalStructureProperty_1).default; } });
+var BandGapsProperty_1 = require("./properties/non-scalar/BandGapsProperty");
+Object.defineProperty(exports, "BandGapsProperty", { enumerable: true, get: function () { return __importDefault(BandGapsProperty_1).default; } });
+var IsRelaxedProperty_1 = require("./properties/non-scalar/IsRelaxedProperty");
+Object.defineProperty(exports, "IsRelaxedProperty", { enumerable: true, get: function () { return __importDefault(IsRelaxedProperty_1).default; } });
+var PressureProperty_1 = require("./properties/scalar/PressureProperty");
+Object.defineProperty(exports, "PressureProperty", { enumerable: true, get: function () { return __importDefault(PressureProperty_1).default; } });
+var ReactionEnergyBarrierProperty_1 = require("./properties/scalar/ReactionEnergyBarrierProperty");
+Object.defineProperty(exports, "ReactionEnergyBarrierProperty", { enumerable: true, get: function () { return __importDefault(ReactionEnergyBarrierProperty_1).default; } });
+var SurfaceEnergyProperty_1 = require("./properties/scalar/SurfaceEnergyProperty");
+Object.defineProperty(exports, "SurfaceEnergyProperty", { enumerable: true, get: function () { return __importDefault(SurfaceEnergyProperty_1).default; } });
+var TotalEnergyProperty_1 = require("./properties/scalar/TotalEnergyProperty");
+Object.defineProperty(exports, "TotalEnergyProperty", { enumerable: true, get: function () { return __importDefault(TotalEnergyProperty_1).default; } });
+var BandStructureProperty_1 = require("./properties/non-scalar/BandStructureProperty");
+Object.defineProperty(exports, "BandStructureProperty", { enumerable: true, get: function () { return __importDefault(BandStructureProperty_1).default; } });
+var ChargeDensityProfileProperty_1 = require("./properties/non-scalar/ChargeDensityProfileProperty");
+Object.defineProperty(exports, "ChargeDensityProfileProperty", { enumerable: true, get: function () { return __importDefault(ChargeDensityProfileProperty_1).default; } });
+var PotentialProfileProperty_1 = require("./properties/non-scalar/PotentialProfileProperty");
+Object.defineProperty(exports, "PotentialProfileProperty", { enumerable: true, get: function () { return __importDefault(PotentialProfileProperty_1).default; } });
+var ReactionEnergyProfileProperty_1 = require("./properties/non-scalar/ReactionEnergyProfileProperty");
+Object.defineProperty(exports, "ReactionEnergyProfileProperty", { enumerable: true, get: function () { return __importDefault(ReactionEnergyProfileProperty_1).default; } });
+var ProtoPropertyHolderMixin_1 = require("./holders/mixins/ProtoPropertyHolderMixin");
+Object.defineProperty(exports, "protoPropertyHolderMixin", { enumerable: true, get: function () { return ProtoPropertyHolderMixin_1.protoPropertyHolderMixin; } });
+var PropertyHolderMixin_1 = require("./holders/mixins/PropertyHolderMixin");
+Object.defineProperty(exports, "propertyHolderMixin", { enumerable: true, get: function () { return PropertyHolderMixin_1.propertyHolderMixin; } });
+var MetaPropertyHolderMixin_1 = require("./holders/mixins/MetaPropertyHolderMixin");
+Object.defineProperty(exports, "metaPropertyHolderMixin", { enumerable: true, get: function () { return MetaPropertyHolderMixin_1.metaPropertyHolderMixin; } });
+__exportStar(require("./types"), exports);

package/dist/js/meta_properties/PseudopotentialMetaProperty.d.ts

@@ -0,0 +1,78 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FileDataItem as Schema } from "@mat3ra/esse/dist/js/types";
+import { type PseudopotentialMetaPropertySchemaMixin } from "../generated/PseudopotentialMetaPropertySchemaMixin";
+import MetaProperty from "../MetaProperty";
+import { PropertyName, PropertyType } from "../settings";
+type RawDataObject = {
+    path: string;
+};
+declare enum CompatibleExchangeCorrelationKey {
+    hse06 = "hse06"
+}
+type Base = typeof MetaProperty & Constructor<PseudopotentialMetaPropertySchemaMixin>;
+declare const PseudopotentialMetaProperty_base: Base;
+export default class PseudopotentialMetaProperty extends PseudopotentialMetaProperty_base implements Schema {
+    static readonly propertyName = PropertyName.pseudopotential;
+    static readonly propertyType = PropertyType.non_scalar;
+    static readonly compatibleExchangeCorrelation: {
+        hse06: string[];
+    };
+    _json: Omit<Schema, "name">;
+    toJSON: () => Omit<Schema, "name">;
+    constructor(config: Omit<Schema, "name">);
+    get isCustom(): boolean;
+    /**
+     * @summary Attempts filtering raw data by search text, split by "," into multiple regular expressions,
+     *           splitting to multiple regexps allows to control the order of filtered items
+     *           if raw data is not empty but filtered data is, returns first element of raw data (assumed to be default)
+     * @note Filters by path!
+     */
+    static safelyFilterRawDataBySearchText(rawData: PseudopotentialMetaProperty[], searchText: string, separator?: string): PseudopotentialMetaProperty[];
+    static isCompatibleWithOther(functional: string): functional is CompatibleExchangeCorrelationKey;
+    /**
+     * @summary Exclusive filter of raw data by all fields of the passed object
+     */
+    static filterRawDataByExchangeCorrelation(rawData: PseudopotentialMetaProperty[], exchangeCorrelation: {
+        functional: string;
+        approximation: string;
+    }): PseudopotentialMetaProperty[];
+    static filterUnique(array: PseudopotentialMetaProperty[]): PseudopotentialMetaProperty[];
+    static filterUniqueByAppName(array: PseudopotentialMetaProperty[], appName: string): PseudopotentialMetaProperty[];
+    static filterRawDataByPath(rawData: RawDataObject[], pseudoPath?: string): RawDataObject[];
+    static filterByAppName(pseudos: PseudopotentialMetaProperty[], appName: string): PseudopotentialMetaProperty[];
+    static filterByElements(pseudos: PseudopotentialMetaProperty[], elements: string[]): PseudopotentialMetaProperty[];
+    /** Apply several filters at once.
+     * @example
+     * // filter object
+     * {
+     *     exchangeCorrelation: {
+     *         approximation: "gga",
+     *         functional: "pbe"
+     *     },
+     *     searchText: "gbrv",
+     *     appName: "vasp",
+     *     elements: ["Si", "Ne", "Fe"],
+     * }
+     */
+    static applyPseudoFilters(pseudos: PseudopotentialMetaProperty[], pseudoFilter: {
+        searchText?: string;
+        appName?: string;
+        type?: string;
+        exchangeCorrelation?: {
+            functional: keyof typeof PseudopotentialMetaProperty.compatibleExchangeCorrelation;
+            approximation: string;
+        };
+        elements?: string[];
+    }): PseudopotentialMetaProperty[];
+    /**
+     * Sorts pseudos by the given pattern.
+     * NOTE: This is currently used to prioritize gbrv pseudopotentials over norm-conserving ones for QE.
+     */
+    static sortPseudosByPattern(pseudos: PseudopotentialMetaProperty[], pattern?: string): PseudopotentialMetaProperty[];
+    /**
+     * Prioritizes pseudos with 'default' and '5.2' (version) in path (VASP)
+     */
+    static sortByPathVASP(pseudos: PseudopotentialMetaProperty[], version?: string): PseudopotentialMetaProperty[];
+    static filterByType(pseudos: PseudopotentialMetaProperty[], pseudoType?: string): PseudopotentialMetaProperty[];
+}
+export {};

package/dist/js/meta_properties/PseudopotentialMetaProperty.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const PseudopotentialMetaPropertySchemaMixin_1 = require("../generated/PseudopotentialMetaPropertySchemaMixin");
+const MetaProperty_1 = __importDefault(require("../MetaProperty"));
+const settings_1 = require("../settings");
+var CompatibleExchangeCorrelationKey;
+(function (CompatibleExchangeCorrelationKey) {
+    CompatibleExchangeCorrelationKey["hse06"] = "hse06";
+})(CompatibleExchangeCorrelationKey || (CompatibleExchangeCorrelationKey = {}));
+class PseudopotentialMetaProperty extends MetaProperty_1.default {
+    constructor(config) {
+        super({ ...config, name: PseudopotentialMetaProperty.propertyName });
+    }
+    get isCustom() {
+        return this.source === "user";
+    }
+    /**
+     * @summary Attempts filtering raw data by search text, split by "," into multiple regular expressions,
+     *           splitting to multiple regexps allows to control the order of filtered items
+     *           if raw data is not empty but filtered data is, returns first element of raw data (assumed to be default)
+     * @note Filters by path!
+     */
+    static safelyFilterRawDataBySearchText(rawData, searchText, separator = ",") {
+        if (!searchText)
+            return rawData;
+        const filteredData = [];
+        searchText.split(separator).forEach((txt) => {
+            const text = txt.trim(); // remove whitespace and do nothing if empty string
+            if (!text)
+                return;
+            try {
+                const regexp = new RegExp(text);
+                const filteredData_ = rawData.filter((el) => el.path.match(regexp));
+                filteredData.push(...filteredData_);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    console.error(e.message);
+                }
+            }
+        });
+        return filteredData.length ? filteredData : rawData.splice(0, 1);
+    }
+    static isCompatibleWithOther(functional) {
+        return Object.keys(this.compatibleExchangeCorrelation).includes(functional);
+    }
+    /**
+     * @summary Exclusive filter of raw data by all fields of the passed object
+     */
+    static filterRawDataByExchangeCorrelation(rawData, exchangeCorrelation) {
+        const { functional } = exchangeCorrelation;
+        return rawData.filter((item) => {
+            var _a, _b;
+            return this.isCompatibleWithOther(functional)
+                ? this.compatibleExchangeCorrelation[functional].includes(((_a = item.exchangeCorrelation) === null || _a === void 0 ? void 0 : _a.functional) || "")
+                : functional === ((_b = item.exchangeCorrelation) === null || _b === void 0 ? void 0 : _b.functional);
+        });
+    }
+    // filter unique (assuming that path is always unique)
+    static filterUnique(array) {
+        return (0, uniqBy_1.default)(array, (item) => item.path);
+    }
+    // filter unique by apps (assuming that path is always unique)
+    static filterUniqueByAppName(array, appName) {
+        return PseudopotentialMetaProperty.filterUnique(this.filterByAppName(array, appName));
+    }
+    static filterRawDataByPath(rawData, pseudoPath = "") {
+        const regexp = new RegExp(pseudoPath);
+        return rawData.filter((el) => el.path.match(regexp));
+    }
+    static filterByAppName(pseudos, appName) {
+        return pseudos.filter((pseudo) => pseudo.apps.includes(appName));
+    }
+    static filterByElements(pseudos, elements) {
+        return pseudos.filter((pseudo) => elements.includes(pseudo.element));
+    }
+    /** Apply several filters at once.
+     * @example
+     * // filter object
+     * {
+     *     exchangeCorrelation: {
+     *         approximation: "gga",
+     *         functional: "pbe"
+     *     },
+     *     searchText: "gbrv",
+     *     appName: "vasp",
+     *     elements: ["Si", "Ne", "Fe"],
+     * }
+     */
+    static applyPseudoFilters(pseudos, pseudoFilter) {
+        let filteredPseudos = [...pseudos];
+        Object.entries(pseudoFilter).forEach(([fKey, fValue]) => {
+            if (typeof fValue === "string") {
+                if (fKey === "searchText") {
+                    filteredPseudos = this.safelyFilterRawDataBySearchText(filteredPseudos, fValue);
+                }
+                else if (fKey === "appName") {
+                    filteredPseudos = this.filterByAppName(filteredPseudos, fValue);
+                }
+                else if (fKey === "type") {
+                    filteredPseudos = this.filterByType(filteredPseudos, fValue);
+                }
+            }
+            else if (typeof fValue === "object" &&
+                "functional" in fValue &&
+                "approximation" in fValue) {
+                filteredPseudos = this.filterRawDataByExchangeCorrelation(filteredPseudos, fValue);
+            }
+            else if (Array.isArray(fValue)) {
+                filteredPseudos = this.filterByElements(filteredPseudos, fValue);
+            }
+            else {
+                throw new Error(`Invalid filter value: ${fValue}`);
+            }
+        });
+        return filteredPseudos;
+    }
+    /**
+     * Sorts pseudos by the given pattern.
+     * NOTE: This is currently used to prioritize gbrv pseudopotentials over norm-conserving ones for QE.
+     */
+    static sortPseudosByPattern(pseudos, pattern = "/gbrv/") {
+        return pseudos.concat([]).sort((a, b) => {
+            return (b.path.includes(pattern) ? 1 : 0) - (a.path.includes(pattern) ? 1 : 0);
+        });
+    }
+    /**
+     * Prioritizes pseudos with 'default' and '5.2' (version) in path (VASP)
+     */
+    static sortByPathVASP(pseudos, version = "5.2") {
+        return pseudos.concat([]).sort((a, b) => {
+            if (a.path.includes("default") && a.path.includes(version)) {
+                return -1;
+            }
+            if (b.path.includes("default") && b.path.includes(version)) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    static filterByType(pseudos, pseudoType) {
+        if (pseudoType === undefined || pseudoType === "any")
+            return pseudos;
+        return pseudos.filter((pseudo) => pseudo.type.includes(pseudoType));
+    }
+}
+PseudopotentialMetaProperty.propertyName = settings_1.PropertyName.pseudopotential;
+PseudopotentialMetaProperty.propertyType = settings_1.PropertyType.non_scalar;
+PseudopotentialMetaProperty.compatibleExchangeCorrelation = {
+    hse06: ["pbe", "hse06"],
+};
+exports.default = PseudopotentialMetaProperty;
+(0, PseudopotentialMetaPropertySchemaMixin_1.pseudopotentialMetaPropertySchemaMixin)(PseudopotentialMetaProperty.prototype);

package/dist/js/properties/include/mixins/2d_plot.d.ts

@@ -0,0 +1,27 @@
+import type { DimensionPlotSchema } from "@mat3ra/esse/dist/js/types";
+import { type FormatterScope, type HighChartsConfigParams, HighChartsConfig } from "../../../charts/highcharts";
+export type XDataArray = DimensionPlotSchema["xDataArray"];
+export type XDataArraySimple = number[];
+export type XDataArrayNested = XDataArraySimple[];
+export type YDataSeries = DimensionPlotSchema["yDataSeries"];
+export type TwoDimensionalHighChartConfigMixinParams = {
+    subtitle: string;
+    yAxisTitle: string;
+    xAxisTitle: string;
+    xDataArray: XDataArray;
+    yDataSeries: YDataSeries;
+    legend?: HighChartsConfigParams["legend"];
+};
+export declare class TwoDimensionalHighChartConfigMixin extends HighChartsConfig {
+    readonly xDataArray: XDataArray;
+    readonly yDataSeries: YDataSeries;
+    readonly tooltipXAxisName: string;
+    readonly tooltipYAxisName: string;
+    constructor(property: TwoDimensionalHighChartConfigMixinParams);
+    get series(): {
+        animation: boolean;
+        data: [number, number][];
+    }[];
+    tooltipFormatter(xDataArray?: XDataArray): (this: FormatterScope) => string;
+    get overrideConfig(): object;
+}

package/dist/js/properties/include/mixins/2d_plot.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoDimensionalHighChartConfigMixin = void 0;
+const zip_1 = __importDefault(require("lodash/zip"));
+const highcharts_1 = require("../../../charts/highcharts");
+class TwoDimensionalHighChartConfigMixin extends highcharts_1.HighChartsConfig {
+    constructor(property) {
+        super({
+            subtitle: property.subtitle,
+            yAxisTitle: property.yAxisTitle,
+            xAxisTitle: property.xAxisTitle,
+            yAxisType: "linear",
+            legend: property.legend || false,
+        });
+        // override upon inheritance
+        this.tooltipXAxisName = "";
+        // override upon inheritance
+        this.tooltipYAxisName = "";
+        this.xDataArray = property.xDataArray;
+        this.yDataSeries = property.yDataSeries;
+    }
+    get series() {
+        return this.yDataSeries.map((item) => {
+            return {
+                animation: false,
+                data: (0, zip_1.default)(this.xDataArray, item),
+            };
+        });
+    }
+    tooltipFormatter(xDataArray = []) {
+        const { tooltipXAxisName, tooltipYAxisName } = this;
+        // eslint-disable-next-line func-names
+        return function () {
+            const xValue = xDataArray[this.point.index];
+            return ("<b>" +
+                tooltipXAxisName +
+                "</b> " +
+                (Array.isArray(xValue) ? xValue.join(", ") : xValue.toFixed(4)) +
+                "<br><b>" +
+                tooltipYAxisName +
+                ": </b>  " +
+                this.y.toFixed(4));
+        };
+    }
+    get overrideConfig() {
+        const { xDataArray } = this;
+        return {
+            chart: {
+                animation: false,
+                type: "spline",
+                zoomType: "xy",
+            },
+            plotOptions: {
+                spline: {
+                    lineWidth: 2,
+                    states: {
+                        hover: {
+                            lineWidth: 6,
+                        },
+                    },
+                    marker: {
+                        enabled: false,
+                    },
+                },
+            },
+            tooltip: {
+                valueSuffix: "",
+                formatter: this.tooltipFormatter(xDataArray),
+            },
+            legend: {
+                enabled: false,
+            },
+        };
+    }
+}
+exports.TwoDimensionalHighChartConfigMixin = TwoDimensionalHighChartConfigMixin;

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

@@ -0,0 +1,38 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AveragePotentialProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { type AveragePotentialProfilePropertySchemaMixin } from "../../generated/AveragePotentialProfilePropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+export declare class AveragePotentialProfileConfig 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 Schema = AveragePotentialProfilePropertySchema;
+type Base = typeof Property<Schema> & Constructor<AveragePotentialProfilePropertySchemaMixin>;
+declare const AveragePotentialProfileProperty_base: Base;
+export default class AveragePotentialProfileProperty extends AveragePotentialProfileProperty_base implements Schema {
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    readonly chartConfig: Options;
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.average_potential_profile;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AveragePotentialProfileConfig = void 0;
+const zip_1 = __importDefault(require("lodash/zip"));
+const AveragePotentialProfilePropertySchemaMixin_1 = require("../../generated/AveragePotentialProfilePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const _2d_plot_1 = require("../include/mixins/2d_plot");
+const NAMES = ["planar average", "macroscopic average"];
+class AveragePotentialProfileConfig 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.AveragePotentialProfileConfig = AveragePotentialProfileConfig;
+class AveragePotentialProfileProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: AveragePotentialProfileProperty.propertyName });
+        this.subtitle = "Average Potential Profile";
+        this.yAxisTitle = `Energy (${this.yAxis.units})`;
+        this.xAxisTitle = `Coordinate (${this.xAxis.units})`;
+        this.chartConfig = new AveragePotentialProfileConfig(this).config;
+    }
+}
+AveragePotentialProfileProperty.isRefined = true;
+AveragePotentialProfileProperty.propertyName = settings_1.PropertyName.average_potential_profile;
+AveragePotentialProfileProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = AveragePotentialProfileProperty;
+(0, AveragePotentialProfilePropertySchemaMixin_1.averagePotentialProfilePropertySchemaMixin)(AveragePotentialProfileProperty.prototype);

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

@@ -0,0 +1,59 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { BandGapsPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { type BandGapsPropertySchemaMixin } from "../../generated/BandGapsPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = BandGapsPropertySchema;
+type Base = typeof Property<Schema> & Constructor<BandGapsPropertySchemaMixin>;
+declare const BandGapsProperty_base: Base;
+export default class BandGapsProperty extends BandGapsProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.band_gaps;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+    toRowValues(group?: string): {
+        data: {
+            name: string;
+            kpointConduction?: [number, number, number];
+            kpointValence?: [number, number, number];
+            eigenvalueConduction?: number;
+            eigenvalueValence?: number;
+            spin?: number;
+            type?: "direct" | "indirect" | undefined;
+            units?: "kJ/mol" | "eV" | "J/mol" | "hartree" | "cm-1" | "Ry" | "eV/atom";
+            value?: number | undefined;
+        };
+        slug: string;
+        group: string | undefined;
+        name: "band_gaps";
+        values: {
+            kpointConduction?: [number, number, number];
+            kpointValence?: [number, number, number];
+            eigenvalueConduction?: number;
+            eigenvalueValence?: number;
+            spin?: number;
+            type: "direct" | "indirect";
+            units?: "kJ/mol" | "eV" | "J/mol" | "hartree" | "cm-1" | "Ry" | "eV/atom";
+            value: number;
+        }[];
+        eigenvalues?: {
+            kpoint?: [number, number, number];
+            weight?: number;
+            eigenvalues?: {
+                spin?: number;
+                energies?: unknown[];
+                occupations?: unknown[];
+            }[];
+        }[];
+    }[];
+    flattenProperties(): {
+        [x: string]: unknown;
+    }[];
+    /**
+     * @summary Gets specified band gap (direct/indirect) and returns it in simplified form (as pressure).
+     * Characteristic name will be `band_gaps:<type>`
+     * @param type {String}
+     */
+    private toJSONByType;
+}
+export {};

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

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const BandGapsPropertySchemaMixin_1 = require("../../generated/BandGapsPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class BandGapsProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: BandGapsProperty.propertyName });
+    }
+    toRowValues(group) {
+        return [this.toJSONByType("direct", group), this.toJSONByType("indirect", group)];
+    }
+    flattenProperties() {
+        return this.values
+            .map((x) => {
+            return {
+                name: `${this.name}:${x.type}`,
+                value: x.value,
+            };
+        })
+            .map((x) => (0, utils_1.flattenObject)(x));
+    }
+    /**
+     * @summary Gets specified band gap (direct/indirect) and returns it in simplified form (as pressure).
+     * Characteristic name will be `band_gaps:<type>`
+     * @param type {String}
+     */
+    toJSONByType(type, group) {
+        const ch = this.toJSON();
+        const bandGapByType = (0, utils_1.deepClone)(ch);
+        const directData = this.values.find((x) => x.type === type);
+        const name = `band_gaps:${type}`;
+        return {
+            ...bandGapByType,
+            data: {
+                ...directData,
+                name,
+            },
+            slug: name,
+            group,
+        };
+    }
+}
+BandGapsProperty.isRefined = true;
+BandGapsProperty.propertyName = settings_1.PropertyName.band_gaps;
+BandGapsProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = BandGapsProperty;
+(0, BandGapsPropertySchemaMixin_1.bandGapsPropertySchemaMixin)(BandGapsProperty.prototype);