@mat3ra/prode 2025.11.25-0

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DensityOfStatesConfig = void 0;
+const zip_1 = __importDefault(require("lodash/zip"));
+const highcharts_1 = require("../../charts/highcharts");
+const DensityOfStatesPropertySchemaMixin_1 = require("../../generated/DensityOfStatesPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class DensityOfStatesConfig extends highcharts_1.HighChartsConfig {
+    get overrideConfig() {
+        return {
+            colors: [
+                "#7cb5ec",
+                "#90ed7d",
+                "#f7a35c",
+                "#8085e9",
+                "#f15c80",
+                "#e4d354",
+                "#2b908f",
+                "#f45b5b",
+                "#91e8e1",
+            ],
+            credits: {
+                enabled: false,
+            },
+            chart: {
+                type: "spline",
+                zoomType: "xy",
+                animation: false,
+            },
+            legend: {
+                layout: "horizontal",
+                align: "center",
+                verticalAlign: "bottom",
+                borderWidth: 0,
+            },
+        };
+    }
+    constructor(property, chartConfig) {
+        var _a;
+        super({
+            subtitle: property.subtitle,
+            yAxisTitle: property.yAxisTitle,
+            xAxisTitle: property.xAxisTitle,
+            yAxisType: "linear",
+        });
+        this.yDataSeries = property.yDataSeries;
+        this.legends = property.legend || [];
+        this.fermiEnergy = (_a = chartConfig === null || chartConfig === void 0 ? void 0 : chartConfig.fermiEnergy) !== null && _a !== void 0 ? _a : 0;
+        this.xDataArray = this.cleanXDataArray(property.xDataArray);
+    }
+    // shifting values wrt fermi energy here
+    cleanXDataArray(rawData) {
+        return rawData.flat().map((x) => {
+            const value = this.fermiEnergy ? x - this.fermiEnergy : x;
+            return Number(value.toPrecision(4));
+        });
+    }
+    get series() {
+        return this.yDataSeries.map((item, index) => {
+            const legend = this.legends[index];
+            const spinText = (legend === null || legend === void 0 ? void 0 : legend.spin) ? ` ${legend.spin > 0 ? "↑" : "↓"}` : "";
+            const name = (legend === null || legend === void 0 ? void 0 : legend.element)
+                ? `${legend.element} ${legend.electronicState}${spinText}`
+                : "Total";
+            return {
+                data: (0, zip_1.default)(this.xDataArray, item.map((x) => Number(Number(x).toPrecision(4)))),
+                name,
+                color: name === "Total" ? "#000000" : undefined,
+                animation: false,
+            };
+        });
+    }
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function () {
+            return ("<b>state:</b> " +
+                this.series.name +
+                "<br>" +
+                "<b>energy:</b> " +
+                this.key.toFixed(4) +
+                "<br>" +
+                "<b>value: </b>  " +
+                this.y.toFixed(4));
+        };
+    }
+    xAxis() {
+        return {
+            ...super.xAxis(),
+            plotLines: this.fermiEnergy
+                ? this.plotSingleLine({
+                    value: 0.0,
+                    label: {
+                        text: "E_F",
+                        style: {
+                            color: "red",
+                        },
+                        y: 15,
+                        x: 5,
+                        rotation: 0,
+                    },
+                })
+                : [],
+        };
+    }
+}
+exports.DensityOfStatesConfig = DensityOfStatesConfig;
+class DensityOfStatesProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: DensityOfStatesProperty.propertyName });
+        this.subtitle = "Density Of States";
+        this.yAxisTitle = `Density Of States (${this.yAxis.units})`;
+        this.xAxisTitle = `Energy (${this.xAxis.units})`;
+        this.chartConfig = new DensityOfStatesConfig(this, {
+            fermiEnergy: config.fermiEnergy,
+        }).config;
+    }
+}
+DensityOfStatesProperty.isRefined = true;
+DensityOfStatesProperty.propertyName = settings_1.PropertyName.density_of_states;
+DensityOfStatesProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = DensityOfStatesProperty;
+(0, DensityOfStatesPropertySchemaMixin_1.densityOfStatesPropertySchemaMixin)(DensityOfStatesProperty.prototype);

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

@@ -0,0 +1,49 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { DielectricTensorPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import type { FormatterScope } from "src/js/charts/highcharts";
+import { type DielectricTensorPropertySchemaMixin } from "../../generated/DielectricTensorPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+import { TwoDimensionalHighChartConfigMixin } from "../include/mixins/2d_plot";
+type Schema = DielectricTensorPropertySchema;
+export declare class DielectricTensorConfig extends TwoDimensionalHighChartConfigMixin {
+    get series(): {
+        animation: boolean;
+        name: string | object;
+        data: [number, number][];
+    }[];
+    tooltipFormatter(): (this: FormatterScope) => string;
+    get overrideConfig(): {
+        colors: string[];
+        credits: {
+            enabled: boolean;
+        };
+        chart: {
+            type: string;
+            zoomType: string;
+            animation: boolean;
+        };
+        legend: {
+            layout: string;
+            align: string;
+            verticalAlign: string;
+            borderWidth: number;
+        };
+    };
+}
+type Base = typeof Property<Schema> & Constructor<DielectricTensorPropertySchemaMixin>;
+declare const DielectricTensorProperty_base: Base;
+export default class DielectricTensorProperty extends DielectricTensorProperty_base implements Schema {
+    readonly subtitle = "Dielectric Tensor";
+    readonly yAxisTitle = "Dielectric Tensor Component";
+    readonly xAxisTitle = "Frequency (eV)";
+    readonly chartConfig: Options[];
+    static readonly propertyName = PropertyName.dielectric_tensor;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+    private rowMajorToColumnMajor;
+    private getComplementaryPairs;
+    private getAllChartConfigs;
+}
+export {};

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DielectricTensorConfig = void 0;
+const zip_1 = __importDefault(require("lodash/zip"));
+const DielectricTensorPropertySchemaMixin_1 = require("../../generated/DielectricTensorPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const _2d_plot_1 = require("../include/mixins/2d_plot");
+class DielectricTensorConfig extends _2d_plot_1.TwoDimensionalHighChartConfigMixin {
+    get series() {
+        return this.yDataSeries.map((item, index) => {
+            return {
+                animation: false,
+                name: Array.isArray(this.legend) ? this.legend[index] : "",
+                data: (0, zip_1.default)(this.xDataArray, item),
+            };
+        });
+    }
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function () {
+            return ("<b>part:</b> " +
+                this.series.name +
+                "<br>" +
+                "<b>frequency:</b> " +
+                this.key.toFixed(4) +
+                "<br>" +
+                "<b>epsilon: </b>  " +
+                this.y.toFixed(4));
+        };
+    }
+    get overrideConfig() {
+        return {
+            ...super.overrideConfig,
+            colors: [
+                "#7cb5ec",
+                "#90ed7d",
+                "#f7a35c",
+                "#8085e9",
+                "#f15c80",
+                "#e4d354",
+                "#2b908f",
+                "#f45b5b",
+                "#91e8e1",
+            ],
+            credits: {
+                enabled: false,
+            },
+            chart: {
+                type: "spline",
+                zoomType: "xy",
+                animation: false,
+            },
+            legend: {
+                layout: "horizontal",
+                align: "center",
+                verticalAlign: "bottom",
+                borderWidth: 0,
+            },
+        };
+    }
+}
+exports.DielectricTensorConfig = DielectricTensorConfig;
+class DielectricTensorProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: DielectricTensorProperty.propertyName });
+        this.subtitle = "Dielectric Tensor";
+        this.yAxisTitle = "Dielectric Tensor Component";
+        this.xAxisTitle = "Frequency (eV)";
+        this.chartConfig = this.getAllChartConfigs().map((chartConfig) => {
+            const cfg = new DielectricTensorConfig(chartConfig);
+            return cfg.config;
+        });
+    }
+    rowMajorToColumnMajor(matrix) {
+        return matrix.reduce((accumulator, item) => {
+            const [x, y, z] = item;
+            accumulator[0].push(x);
+            accumulator[1].push(y);
+            accumulator[2].push(z);
+            return accumulator;
+        }, [[], [], []]);
+    }
+    getComplementaryPairs(precision = 3) {
+        const groupedBySpin = {};
+        this.values.forEach((item) => {
+            // Round the spin value to mitigate floating-point precision issues
+            const spinValue = item.spin !== undefined ? item.spin.toFixed(precision) : "undefined";
+            groupedBySpin[spinValue] = groupedBySpin[spinValue] || [];
+            groupedBySpin[spinValue].push(item);
+        });
+        return Object.values(groupedBySpin).filter((group) => group.length === 2 &&
+            group.find((item) => item.part === "real") &&
+            group.find((item) => item.part === "imaginary"));
+    }
+    getAllChartConfigs() {
+        const complementaryPairs = this.getComplementaryPairs();
+        return complementaryPairs.map((pair) => {
+            const xDataArray = pair[0].frequencies;
+            const spinChannel = pair[0].spin ? ` - spin(${pair[0].spin})` : "";
+            return {
+                subtitle: `${this.subtitle}${spinChannel}`,
+                xAxisTitle: this.xAxisTitle,
+                yAxisTitle: this.yAxisTitle,
+                yAxisType: "linear",
+                xDataArray,
+                yDataSeries: pair.flatMap((p) => this.rowMajorToColumnMajor(p.components)),
+                legend: pair.flatMap((p) => [..."xyz"].map((char) => `eps_${char} (${p.part})`)),
+            };
+        });
+    }
+}
+DielectricTensorProperty.propertyName = settings_1.PropertyName.dielectric_tensor;
+DielectricTensorProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = DielectricTensorProperty;
+(0, DielectricTensorPropertySchemaMixin_1.dielectricTensorPropertySchemaMixin)(DielectricTensorProperty.prototype);

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

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FileContentPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { type FileContentPropertySchemaMixin } from "../../generated/FileContentPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = FileContentPropertySchema;
+type Base = typeof Property<Schema> & Constructor<FileContentPropertySchemaMixin>;
+declare const FileContentProperty_base: Base;
+export default class FileContentProperty extends FileContentProperty_base implements Schema {
+    static readonly isAbleToReturnMultipleResults = true;
+    static readonly propertyName = PropertyName.file_content;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/non-scalar/FileContentProperty.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 FileContentPropertySchemaMixin_1 = require("../../generated/FileContentPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class FileContentProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: FileContentProperty.propertyName });
+    }
+}
+FileContentProperty.isAbleToReturnMultipleResults = true;
+FileContentProperty.propertyName = settings_1.PropertyName.file_content;
+FileContentProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = FileContentProperty;
+(0, FileContentPropertySchemaMixin_1.fileContentPropertySchemaMixin)(FileContentProperty.prototype);

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

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

package/dist/js/properties/non-scalar/FinalStructureProperty.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 FinalStructurePropertySchemaMixin_1 = require("../../generated/FinalStructurePropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class FinalStructureProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: FinalStructureProperty.propertyName });
+    }
+}
+FinalStructureProperty.propertyName = settings_1.PropertyName.final_structure;
+FinalStructureProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = FinalStructureProperty;
+(0, FinalStructurePropertySchemaMixin_1.finalStructurePropertySchemaMixin)(FinalStructureProperty.prototype);

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

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

package/dist/js/properties/non-scalar/HubbardUProperty.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 HubbardUPropertySchemaMixin_1 = require("../../generated/HubbardUPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class HubbardUProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: HubbardUProperty.propertyName });
+    }
+}
+HubbardUProperty.propertyName = settings_1.PropertyName.hubbard_u;
+HubbardUProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = HubbardUProperty;
+(0, HubbardUPropertySchemaMixin_1.hubbardUPropertySchemaMixin)(HubbardUProperty.prototype);

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

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

package/dist/js/properties/non-scalar/HubbardVNNProperty.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 HubbardVNNPropertySchemaMixin_1 = require("../../generated/HubbardVNNPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class HubbardVNNProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: HubbardVNNProperty.propertyName });
+    }
+}
+HubbardVNNProperty.propertyName = settings_1.PropertyName.hubbard_v_nn;
+HubbardVNNProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = HubbardVNNProperty;
+(0, HubbardVNNPropertySchemaMixin_1.hubbardVNNPropertySchemaMixin)(HubbardVNNProperty.prototype);

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

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

package/dist/js/properties/non-scalar/HubbardVProperty.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 HubbardVPropertySchemaMixin_1 = require("../../generated/HubbardVPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class HubbardVProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: HubbardVProperty.propertyName });
+    }
+}
+HubbardVProperty.propertyName = settings_1.PropertyName.hubbard_v;
+HubbardVProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = HubbardVProperty;
+(0, HubbardVPropertySchemaMixin_1.hubbardVPropertySchemaMixin)(HubbardVProperty.prototype);

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

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

package/dist/js/properties/non-scalar/IsRelaxedProperty.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 IsRelaxedPropertySchemaMixin_1 = require("../../generated/IsRelaxedPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class IsRelaxedProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: IsRelaxedProperty.propertyName });
+    }
+}
+IsRelaxedProperty.isRefined = true;
+IsRelaxedProperty.propertyName = settings_1.PropertyName.is_relaxed;
+IsRelaxedProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = IsRelaxedProperty;
+(0, IsRelaxedPropertySchemaMixin_1.isRelaxedPropertySchemaMixin)(IsRelaxedProperty.prototype);

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

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

package/dist/js/properties/non-scalar/JupyterNotebookEndpointProperty.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 JupyterNotebookEndpointPropertySchemaMixin_1 = require("../../generated/JupyterNotebookEndpointPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class JupyterNotebookEndpointProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: JupyterNotebookEndpointProperty.propertyName });
+    }
+}
+JupyterNotebookEndpointProperty.propertyName = settings_1.PropertyName.jupyter_notebook_endpoint;
+JupyterNotebookEndpointProperty.propertyType = settings_1.PropertyType.non_scalar;
+(0, JupyterNotebookEndpointPropertySchemaMixin_1.jupyterNotebookEndpointPropertySchemaMixin)(JupyterNotebookEndpointProperty.prototype);
+exports.default = JupyterNotebookEndpointProperty;

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

@@ -0,0 +1,19 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PhononDensityOfStatesPropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { Options } from "highcharts";
+import { PhononDOSPropertySchemaMixin } from "../../generated/PhononDOSPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = PhononDensityOfStatesPropertySchema;
+type Base = typeof Property<Schema> & Constructor<PhononDOSPropertySchemaMixin>;
+declare const PhononDOSProperty_base: Base;
+export default class PhononDOSProperty extends PhononDOSProperty_base implements Schema {
+    readonly chartConfig: Options;
+    readonly subtitle: string;
+    readonly yAxisTitle: string;
+    readonly xAxisTitle: string;
+    static readonly propertyName = PropertyName.phonon_dos;
+    static readonly propertyType = PropertyType.non_scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

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

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PhononDOSPropertySchemaMixin_1 = require("../../generated/PhononDOSPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const DensityOfStatesProperty_1 = require("./DensityOfStatesProperty");
+class PhononDOSConfig extends DensityOfStatesProperty_1.DensityOfStatesConfig {
+    tooltipFormatter() {
+        // eslint-disable-next-line func-names
+        return function () {
+            return ("<b>state:</b> " +
+                this.series.name +
+                "<br>" +
+                "<b>energy:</b> " +
+                this.key.toFixed(4) +
+                "<br>" +
+                "<b>value: </b>  " +
+                this.y.toFixed(4));
+        };
+    }
+}
+class PhononDOSProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: PhononDOSProperty.propertyName });
+        this.subtitle = "Phonon Density Of States";
+        this.yAxisTitle = `Density Of States (${this.yAxis.units})`;
+        this.xAxisTitle = `Frequency (${this.xAxis.units})`;
+        this.chartConfig = new PhononDOSConfig(this).config;
+    }
+}
+PhononDOSProperty.propertyName = settings_1.PropertyName.phonon_dos;
+PhononDOSProperty.propertyType = settings_1.PropertyType.non_scalar;
+exports.default = PhononDOSProperty;
+(0, PhononDOSPropertySchemaMixin_1.phononDOSPropertySchemaMixin)(PhononDOSProperty.prototype);

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

@@ -0,0 +1,21 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PhononBandStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+import type { KPointPath } from "@mat3ra/made/dist/js/lattice/reciprocal/lattice_reciprocal";
+import type { Options } from "highcharts";
+import { PhononDispersionsPropertySchemaMixin } from "../../generated/PhononDispersionsPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = PhononBandStructurePropertySchema;
+type Base = typeof Property<Schema> & Constructor<PhononDispersionsPropertySchemaMixin>;
+declare const PhononDispersionsProperty_base: Base;
+declare class PhononDispersionsProperty extends PhononDispersionsProperty_base implements Schema {
+    static readonly propertyName = PropertyName.phonon_dispersions;
+    static readonly propertyType = PropertyType.non_scalar;
+    readonly subtitle = "Phonon Dispersions";
+    readonly yAxisTitle: string;
+    readonly chartConfig: Options;
+    constructor(config: Omit<Schema, "name"> & {
+        pointsPath?: KPointPath;
+    });
+}
+export default PhononDispersionsProperty;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PhononDispersionsPropertySchemaMixin_1 = require("../../generated/PhononDispersionsPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+const BandStructureProperty_1 = require("./BandStructureProperty");
+class PhononDispersionsConfig extends BandStructureProperty_1.BandStructureConfig {
+    tooltipFormatter(xDataArray, yAxisName = "frequency") {
+        return super.tooltipFormatter(xDataArray, yAxisName);
+    }
+}
+class PhononDispersionsProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: PhononDispersionsProperty.propertyName });
+        this.subtitle = "Phonon Dispersions";
+        this.yAxisTitle = `Frequency (${this.yAxis.units})`;
+        this.chartConfig = new PhononDispersionsConfig(this, {
+            pointsPath: config.pointsPath,
+        }).config;
+    }
+}
+PhononDispersionsProperty.propertyName = settings_1.PropertyName.phonon_dispersions;
+PhononDispersionsProperty.propertyType = settings_1.PropertyType.non_scalar;
+(0, PhononDispersionsPropertySchemaMixin_1.phononDispersionsPropertySchemaMixin)(PhononDispersionsProperty.prototype);
+exports.default = PhononDispersionsProperty;