nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/components/reports/charts/utility/colors.js

@@ -0,0 +1,92 @@
+import colorLib from '@kurkle/color';
+export function transparentize(value, opacity) {
+    var alpha = opacity === undefined ? 0.5 : 1 - opacity;
+    return colorLib(value).alpha(alpha).rgbString();
+}
+export function colorToHex(color) {
+    // Helper function to convert a single component to hex
+    function componentToHex(c) {
+        const hex = c.toString(16);
+        return hex.length === 1 ? '0' + hex : hex;
+    }
+    // Helper function to validate and parse a color component
+    function parseComponent(value, maxValue) {
+        value = parseFloat(value);
+        return isNaN(value) ? 0 : Math.min(maxValue, Math.max(0, value));
+    }
+    if (typeof color === 'string') {
+        // If the input is a string, attempt to parse it as a CSS color
+        const tempDiv = document.createElement('div');
+        tempDiv.style.color = color;
+        document.body.appendChild(tempDiv);
+        const computedColor = window.getComputedStyle(tempDiv).color;
+        document.body.removeChild(tempDiv);
+        color = computedColor;
+    }
+    if (color.startsWith('#')) {
+        // Hexadecimal color
+        return color.toUpperCase();
+    }
+    else if (color.startsWith('rgb') || color.startsWith('hsl')) {
+        // RGB, RGBA, HSL, HSLA color
+        const rgba = color.match(/(0?\.?\d{1,3})%?\b/g).map((component, index) => {
+            return index < 3 ? Math.round(parseComponent(component, 255)) : parseFloat(component);
+        });
+        return `#${componentToHex(rgba[0])}${componentToHex(rgba[1])}${componentToHex(rgba[2])}`;
+    }
+    // Unsupported color format, return input
+    return color;
+}
+// Function to convert hex to RGB
+export function hexToRgb(hex) {
+    let r = parseInt(hex.slice(1, 3), 16);
+    let g = parseInt(hex.slice(3, 5), 16);
+    let b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b };
+}
+// Function to convert RGB to hex
+export function rgbToHex(r, g, b) {
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase()}`;
+}
+// Function to create a tint (lighten the color)
+export function createTint(color, amount) {
+    const { r, g, b } = hexToRgb(color);
+    return rgbToHex(Math.min(255, r + amount), Math.min(255, g + amount), Math.min(255, b + amount));
+}
+// Function to create a shade (darken the color)
+export function createShade(color, amount) {
+    const { r, g, b } = hexToRgb(color);
+    return rgbToHex(Math.max(0, r - amount), Math.max(0, g - amount), Math.max(0, b - amount));
+}
+// Function to create multiple tints or shades
+export function createColorVariants(color, length, type = 'tint', amount = 43) {
+    let variants = [];
+    for (let i = 1; i <= length; i++) {
+        if (type === 'tint') {
+            variants.push(createTint(color, i * amount)); // Adjust the step size (here it's 40)
+        }
+        else {
+            variants.push(createShade(color, i * amount)); // Adjust the step size (here it's 20)
+        }
+    }
+    return variants;
+}
+export function createConicGradient(chart, colors) {
+    const { ctx, chartArea } = chart;
+    if (!chartArea || !('createConicGradient' in ctx)) {
+        return null;
+    }
+    const { left, width, top, height } = chartArea;
+    //@ts-ignore
+    const gradient = ctx.createConicGradient(0, left + width / 2, top + height / 2);
+    gradient.addColorStop(0, colors === null || colors === void 0 ? void 0 : colors.startColor);
+    gradient.addColorStop(1, colors === null || colors === void 0 ? void 0 : colors.endColor);
+    return gradient;
+}
+// Check if the string is a valid CSS color
+export function isColor(str) {
+    const s = new Option().style;
+    s.color = str;
+    return s.color !== '';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colors.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/charts/utility/colors.ts"],"names":[],"mappings":"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","sourcesContent":["import colorLib from '@kurkle/color';\r\nimport { Chart } from 'chart.js';\r\n\r\nexport function transparentize(value: string, opacity: number) {\r\n\tvar alpha = opacity === undefined ? 0.5 : 1 - opacity;\r\n\treturn colorLib(value).alpha(alpha).rgbString();\r\n}\r\n\r\nexport function colorToHex(color) {\r\n\t// Helper function to convert a single component to hex\r\n\tfunction componentToHex(c) {\r\n\t\tconst hex = c.toString(16);\r\n\t\treturn hex.length === 1 ? '0' + hex : hex;\r\n\t}\r\n\r\n\t// Helper function to validate and parse a color component\r\n\tfunction parseComponent(value, maxValue) {\r\n\t\tvalue = parseFloat(value);\r\n\t\treturn isNaN(value) ? 0 : Math.min(maxValue, Math.max(0, value));\r\n\t}\r\n\r\n\tif (typeof color === 'string') {\r\n\t\t// If the input is a string, attempt to parse it as a CSS color\r\n\t\tconst tempDiv = document.createElement('div');\r\n\t\ttempDiv.style.color = color;\r\n\t\tdocument.body.appendChild(tempDiv);\r\n\t\tconst computedColor = window.getComputedStyle(tempDiv).color;\r\n\t\tdocument.body.removeChild(tempDiv);\r\n\t\tcolor = computedColor;\r\n\t}\r\n\r\n\tif (color.startsWith('#')) {\r\n\t\t// Hexadecimal color\r\n\t\treturn color.toUpperCase();\r\n\t} else if (color.startsWith('rgb') || color.startsWith('hsl')) {\r\n\t\t// RGB, RGBA, HSL, HSLA color\r\n\t\tconst rgba = color.match(/(0?\\.?\\d{1,3})%?\\b/g).map((component, index) => {\r\n\t\t\treturn index < 3 ? Math.round(parseComponent(component, 255)) : parseFloat(component);\r\n\t\t});\r\n\r\n\t\treturn `#${componentToHex(rgba[0])}${componentToHex(rgba[1])}${componentToHex(rgba[2])}`;\r\n\t}\r\n\r\n\t// Unsupported color format, return input\r\n\treturn color;\r\n}\r\n\r\n// Function to convert hex to RGB\r\nexport function hexToRgb(hex: string): { r: number; g: number; b: number } {\r\n\tlet r = parseInt(hex.slice(1, 3), 16);\r\n\tlet g = parseInt(hex.slice(3, 5), 16);\r\n\tlet b = parseInt(hex.slice(5, 7), 16);\r\n\treturn { r, g, b };\r\n}\r\n\r\n// Function to convert RGB to hex\r\nexport function rgbToHex(r: number, g: number, b: number): string {\r\n\treturn `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase()}`;\r\n}\r\n\r\n// Function to create a tint (lighten the color)\r\nexport function createTint(color: string, amount: number): string {\r\n\tconst { r, g, b } = hexToRgb(color);\r\n\treturn rgbToHex(Math.min(255, r + amount), Math.min(255, g + amount), Math.min(255, b + amount));\r\n}\r\n\r\n// Function to create a shade (darken the color)\r\nexport function createShade(color: string, amount: number): string {\r\n\tconst { r, g, b } = hexToRgb(color);\r\n\treturn rgbToHex(Math.max(0, r - amount), Math.max(0, g - amount), Math.max(0, b - amount));\r\n}\r\n\r\n// Function to create multiple tints or shades\r\nexport function createColorVariants(\r\n\tcolor: string,\r\n\tlength: number,\r\n\ttype: 'tint' | 'shade' = 'tint',\r\n\tamount = 43\r\n): string[] {\r\n\tlet variants: string[] = [];\r\n\tfor (let i = 1; i <= length; i++) {\r\n\t\tif (type === 'tint') {\r\n\t\t\tvariants.push(createTint(color, i * amount)); // Adjust the step size (here it's 40)\r\n\t\t} else {\r\n\t\t\tvariants.push(createShade(color, i * amount)); // Adjust the step size (here it's 20)\r\n\t\t}\r\n\t}\r\n\treturn variants;\r\n}\r\n\r\nexport function createConicGradient(chart: Chart, colors: { startColor: string; endColor: string }) {\r\n\tconst { ctx, chartArea } = chart;\r\n\tif (!chartArea || !('createConicGradient' in ctx)) {\r\n\t\treturn null;\r\n\t}\r\n\r\n\tconst { left, width, top, height } = chartArea;\r\n\r\n\t//@ts-ignore\r\n\tconst gradient = ctx.createConicGradient(0, left + width / 2, top + height / 2);\r\n\tgradient.addColorStop(0, colors?.startColor);\r\n\tgradient.addColorStop(1, colors?.endColor);\r\n\r\n\treturn gradient;\r\n}\r\n\r\n// Check if the string is a valid CSS color\r\nexport function isColor(str: string): boolean {\r\n\tconst s = new Option().style;\r\n\ts.color = str;\r\n\treturn s.color !== '';\r\n}\r\n"]}

package/esm2015/lib/components/reports/charts/utility/common.js

@@ -0,0 +1,7 @@
+export function flatArray(data) {
+    return data.reduce((acc, curr) => acc.concat(curr), []);
+}
+export function isObject(obj) {
+    return obj && typeof obj === 'object';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29tcG9uZW50cy9yZXBvcnRzL2NoYXJ0cy91dGlsaXR5L2NvbW1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLFVBQVUsU0FBUyxDQUFzQixJQUFXO0lBQ3pELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDekQsQ0FBQztBQUVELE1BQU0sVUFBVSxRQUFRLENBQ3ZCLEdBQVE7SUFFUixPQUFPLEdBQUcsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLENBQUM7QUFDdkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYXJ0RGF0YXNldCwgQ2hhcnRUeXBlIH0gZnJvbSAnY2hhcnQuanMnO1xyXG5pbXBvcnQgeyBTdGF0aXN0aWNCdWNrZXQgfSBmcm9tICcuLi9tb2RlbHMnO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGZsYXRBcnJheTxUID0gU3RhdGlzdGljQnVja2V0PihkYXRhOiBUW11bXSk6IFRbXSB7XHJcblx0cmV0dXJuIGRhdGEucmVkdWNlKChhY2MsIGN1cnIpID0+IGFjYy5jb25jYXQoY3VyciksIFtdKTtcclxufVxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGlzT2JqZWN0PFQgZXh0ZW5kcyBDaGFydFR5cGU+KFxyXG5cdG9iajogYW55XHJcbik6IG9iaiBpcyBQYXJ0aWFsPENoYXJ0RGF0YXNldDxUPj4ge1xyXG5cdHJldHVybiBvYmogJiYgdHlwZW9mIG9iaiA9PT0gJ29iamVjdCc7XHJcbn1cclxuIl19

package/esm2015/lib/components/reports/charts/utility/css.js

@@ -0,0 +1,163 @@
+import { isColor } from './colors';
+/**
+ * Retrieves the value of a CSS variable or returns a default value if the variable is not defined.
+ *
+ * @param {string} key - The name of the CSS variable to retrieve (e.g., `--variable-name`).
+ * @param {string | number} defaultValue - The default value to return if the CSS variable is not defined.
+ * @returns {string | number} - The value of the CSS variable or the provided default value.
+ */
+export function getCssVariable(key, defaultValue) {
+    const root = document.querySelector('[data-theme]') || document.documentElement;
+    const computedStyle = getComputedStyle(root);
+    return computedStyle.getPropertyValue(key).trim() || defaultValue;
+}
+/**
+ * Retrieves the value of a CSS variable or returns a default color if the variable is not defined.
+ *
+ * @param {string} key - The name of the CSS variable to retrieve (e.g., `--variable-name`).
+ * @param {string} [defaultColor='#444'] - The default color to return if the CSS variable is not defined.
+ * @returns {string} - The value of the CSS variable or the provided default color.
+ */
+export function getColor(key, defaultColor) {
+    return getCssVariable(key, defaultColor || '#444');
+}
+/**
+ * Retrieves the grid color for the specified axis.
+ *
+ * @param {'x' | 'y'} axis - The axis for which to retrieve the grid color ('x' or 'y').
+ * @returns {string} - The grid color as a CSS value.
+ */
+export const getGridColor = (axis) => {
+    return getColor(`--chart-grid-${axis}-color`, '#cecece');
+};
+/**
+ * Retrieves the ticks color for the specified axis.
+ *
+ * @param {'x' | 'y'} axis - The axis for which to retrieve the ticks color ('x' or 'y').
+ * @returns {string} - The ticks color as a CSS value.
+ */
+export const getTicksColor = (axis) => {
+    return getColor(`--chart-ticks-${axis}-color`);
+};
+/**
+ * Retrieves an array of colors based on CSS variables or fallback to default colors.
+ *
+ * @param {number} [length=14] - The number of colors to retrieve.
+ * @param staticColors
+ * @returns {string[]} - An array of color codes.
+ */
+export const getColors = (length = 14, staticColors = [
+    '#47763b',
+    '#c8a791',
+    '#00837b',
+    '#b78b1c',
+    '#636569',
+    '#a84047',
+    '#f7f8f9',
+    '#fd6670',
+    '#00dca5',
+    '#fbb62c',
+    '#596973',
+    '#5a1496',
+    '#3c3cf0',
+    '#f17205' // Bright orange
+]) => {
+    const root = document.querySelector('[data-theme]') || document.documentElement;
+    const computedStyle = getComputedStyle(root);
+    const colors = [];
+    for (let index = 0; index < length; index++) {
+        const color = computedStyle.getPropertyValue(`--chart-color-${index}`).trim() || staticColors[index];
+        colors.push(color);
+    }
+    return colors;
+};
+/**
+ * Determines the appropriate text color (light or dark) based on the luminance of the given background color.
+ *
+ * @param {string} backgroundColor - The background color in hexadecimal (e.g., `#ffffff`) or RGB format (e.g., `rgb(255, 255, 255)`).
+ * @returns {string} - The text color, either the dark color (`--chart-value-dark-color`) or the light color (`--chart-value-light-color`).
+ */
+export function getTextColor(backgroundColor) {
+    const darkColor = getColor('--chart-value-dark-color', '#000');
+    const lightColor = getColor('--chart-value-light-color', '#fff');
+    let rgb = null;
+    if (backgroundColor.startsWith('#')) {
+        rgb = hexToRgb(backgroundColor);
+    }
+    else if (backgroundColor.startsWith('rgb')) {
+        rgb = parseRgbString(backgroundColor);
+    }
+    else {
+        return darkColor; // Default fallback
+    }
+    /**
+     * Converts an RGB component to its linearized value for luminance calculation.
+     *
+     * @param {number} c - The RGB component value (0-255).
+     * @returns {number} - The linearized value.
+     */
+    function toLinear(c) {
+        c /= 255;
+        return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    }
+    const [r, g, b] = rgb.map(toLinear);
+    const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    return luminance > 0.6 ? darkColor : lightColor;
+}
+export function getCssColors(colors) {
+    const _colors = (colors || []).map((color) => {
+        const str = `${color}`;
+        if (isCssVar(str)) {
+            const _var = extractCssVar(str);
+            return getColor(_var);
+        }
+        return str;
+    });
+    return [..._colors];
+}
+export function isCssVar(value) {
+    return typeof value === 'string' && (value.startsWith('var') || value.startsWith('--'));
+}
+export function extractCssVar(data) {
+    const match = data.match(/var\((--[^)]+)\)/);
+    return match ? match[1] : data;
+}
+export function resolveColor(value, cssVar, fallback) {
+    if (!value && !cssVar) {
+        return fallback;
+    }
+    if (isCssVar(value)) {
+        return getColor(extractCssVar(value), fallback);
+    }
+    if (isColor(value)) {
+        return value;
+    }
+    return getColor(cssVar, fallback);
+}
+/*
+ * Converts a hexadecimal color code to an RGB array.
+ *
+ * @param {string} hex - The hexadecimal color code (e.g., `#fff` or `#ffffff`).
+ * @returns {number[]} - An array containing the RGB values [red, green, blue].
+ */
+function hexToRgb(hex) {
+    hex = hex.replace(/^#/, '');
+    if (hex.length === 3) {
+        hex = hex
+            .split('')
+            .map((char) => char + char)
+            .join('');
+    }
+    const bigint = parseInt(hex, 16);
+    return [(bigint >> 16) & 255, (bigint >> 8) & 255, bigint & 255];
+}
+/**
+ * Parses an RGB string and extracts the numeric RGB values.
+ *
+ * @param {string} rgbString - The RGB string (e.g., `rgb(255, 255, 255)`).
+ * @returns {number[]} - An array containing the RGB values [red, green, blue].
+ */
+function parseRgbString(rgbString) {
+    return rgbString.match(/\d+/g).map(Number);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"css.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/charts/utility/css.ts"],"names":[],"mappings":"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","sourcesContent":["import { isColor } from './colors';\r\n\r\n/**\r\n * Retrieves the value of a CSS variable or returns a default value if the variable is not defined.\r\n *\r\n * @param {string} key - The name of the CSS variable to retrieve (e.g., `--variable-name`).\r\n * @param {string | number} defaultValue - The default value to return if the CSS variable is not defined.\r\n * @returns {string | number} - The value of the CSS variable or the provided default value.\r\n */\r\nexport function getCssVariable(key: string, defaultValue?: string | number): string | number {\r\n\tconst root = document.querySelector('[data-theme]') || document.documentElement;\r\n\tconst computedStyle = getComputedStyle(root);\r\n\treturn computedStyle.getPropertyValue(key).trim() || defaultValue;\r\n}\r\n\r\n/**\r\n * Retrieves the value of a CSS variable or returns a default color if the variable is not defined.\r\n *\r\n * @param {string} key - The name of the CSS variable to retrieve (e.g., `--variable-name`).\r\n * @param {string} [defaultColor='#444'] - The default color to return if the CSS variable is not defined.\r\n * @returns {string} - The value of the CSS variable or the provided default color.\r\n */\r\nexport function getColor(key: string, defaultColor?: string): string {\r\n\treturn getCssVariable(key, defaultColor || '#444') as string;\r\n}\r\n\r\n/**\r\n * Retrieves the grid color for the specified axis.\r\n *\r\n * @param {'x' | 'y'} axis - The axis for which to retrieve the grid color ('x' or 'y').\r\n * @returns {string} - The grid color as a CSS value.\r\n */\r\nexport const getGridColor = (axis: 'x' | 'y'): string => {\r\n\treturn getColor(`--chart-grid-${axis}-color`, '#cecece');\r\n};\r\n\r\n/**\r\n * Retrieves the ticks color for the specified axis.\r\n *\r\n * @param {'x' | 'y'} axis - The axis for which to retrieve the ticks color ('x' or 'y').\r\n * @returns {string} - The ticks color as a CSS value.\r\n */\r\nexport const getTicksColor = (axis: 'x' | 'y'): string => {\r\n\treturn getColor(`--chart-ticks-${axis}-color`);\r\n};\r\n\r\n/**\r\n * Retrieves an array of colors based on CSS variables or fallback to default colors.\r\n *\r\n * @param {number} [length=14] - The number of colors to retrieve.\r\n * @param staticColors\r\n * @returns {string[]} - An array of color codes.\r\n */\r\nexport const getColors = (\r\n\tlength: number = 14,\r\n\tstaticColors = [\r\n\t\t'#47763b', // Dark green\r\n\t\t'#c8a791', // Beige\r\n\t\t'#00837b', // Teal\r\n\t\t'#b78b1c', // Mustard\r\n\t\t'#636569', // Gray\r\n\t\t'#a84047', // Red\r\n\t\t'#f7f8f9', // Light gray\r\n\t\t'#fd6670', // Pink\r\n\t\t'#00dca5', // Aqua\r\n\t\t'#fbb62c', // Orange\r\n\t\t'#596973', // Steel blue\r\n\t\t'#5a1496', // Purple\r\n\t\t'#3c3cf0', // Blue\r\n\t\t'#f17205' // Bright orange\r\n\t]\r\n): string[] => {\r\n\tconst root = document.querySelector('[data-theme]') || document.documentElement;\r\n\tconst computedStyle = getComputedStyle(root);\r\n\tconst colors: string[] = [];\r\n\tfor (let index = 0; index < length; index++) {\r\n\t\tconst color = computedStyle.getPropertyValue(`--chart-color-${index}`).trim() || staticColors[index];\r\n\t\tcolors.push(color);\r\n\t}\r\n\r\n\treturn colors;\r\n};\r\n\r\n/**\r\n * Determines the appropriate text color (light or dark) based on the luminance of the given background color.\r\n *\r\n * @param {string} backgroundColor - The background color in hexadecimal (e.g., `#ffffff`) or RGB format (e.g., `rgb(255, 255, 255)`).\r\n * @returns {string} - The text color, either the dark color (`--chart-value-dark-color`) or the light color (`--chart-value-light-color`).\r\n */\r\nexport function getTextColor(backgroundColor: string): string {\r\n\tconst darkColor = getColor('--chart-value-dark-color', '#000');\r\n\tconst lightColor = getColor('--chart-value-light-color', '#fff');\r\n\r\n\tlet rgb: any = null;\r\n\r\n\tif (backgroundColor.startsWith('#')) {\r\n\t\trgb = hexToRgb(backgroundColor);\r\n\t} else if (backgroundColor.startsWith('rgb')) {\r\n\t\trgb = parseRgbString(backgroundColor);\r\n\t} else {\r\n\t\treturn darkColor; // Default fallback\r\n\t}\r\n\r\n\t/**\r\n\t * Converts an RGB component to its linearized value for luminance calculation.\r\n\t *\r\n\t * @param {number} c - The RGB component value (0-255).\r\n\t * @returns {number} - The linearized value.\r\n\t */\r\n\tfunction toLinear(c: number): number {\r\n\t\tc /= 255;\r\n\t\treturn c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);\r\n\t}\r\n\r\n\tconst [r, g, b] = rgb.map(toLinear);\r\n\tconst luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;\r\n\r\n\treturn luminance > 0.6 ? darkColor : lightColor;\r\n}\r\n\r\nexport function getCssColors(colors: string[]) {\r\n\tconst _colors = (colors || []).map((color) => {\r\n\t\tconst str = `${color}`;\r\n\t\tif (isCssVar(str)) {\r\n\t\t\tconst _var = extractCssVar(str);\r\n\t\t\treturn getColor(_var);\r\n\t\t}\r\n\t\treturn str;\r\n\t});\r\n\treturn [..._colors];\r\n}\r\n\r\nexport function isCssVar(value: string) {\r\n\treturn typeof value === 'string' && (value.startsWith('var') || value.startsWith('--'));\r\n}\r\n\r\nexport function extractCssVar(data: string) {\r\n\tconst match = data.match(/var\\((--[^)]+)\\)/);\r\n\treturn match ? match[1] : data;\r\n}\r\n\r\nexport function resolveColor(value: string | undefined, cssVar: string, fallback: string): string {\r\n\tif (!value && !cssVar) {\r\n\t\treturn fallback;\r\n\t}\r\n\r\n\tif (isCssVar(value)) {\r\n\t\treturn getColor(extractCssVar(value), fallback);\r\n\t}\r\n\r\n\tif (isColor(value)) {\r\n\t\treturn value;\r\n\t}\r\n\r\n\treturn getColor(cssVar, fallback);\r\n}\r\n\r\n/*\r\n * Converts a hexadecimal color code to an RGB array.\r\n *\r\n * @param {string} hex - The hexadecimal color code (e.g., `#fff` or `#ffffff`).\r\n * @returns {number[]} - An array containing the RGB values [red, green, blue].\r\n */\r\nfunction hexToRgb(hex) {\r\n\thex = hex.replace(/^#/, '');\r\n\tif (hex.length === 3) {\r\n\t\thex = hex\r\n\t\t\t.split('')\r\n\t\t\t.map((char) => char + char)\r\n\t\t\t.join('');\r\n\t}\r\n\tconst bigint = parseInt(hex, 16);\r\n\treturn [(bigint >> 16) & 255, (bigint >> 8) & 255, bigint & 255];\r\n}\r\n\r\n/**\r\n * Parses an RGB string and extracts the numeric RGB values.\r\n *\r\n * @param {string} rgbString - The RGB string (e.g., `rgb(255, 255, 255)`).\r\n * @returns {number[]} - An array containing the RGB values [red, green, blue].\r\n */\r\nfunction parseRgbString(rgbString: string): number[] {\r\n\treturn rgbString.match(/\\d+/g).map(Number);\r\n}\r\n"]}

package/esm2015/lib/components/reports/charts/utility/index.js

@@ -0,0 +1,4 @@
+export * from './colors';
+export * from './common';
+export * from './css';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL3JlcG9ydHMvY2hhcnRzL3V0aWxpdHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbG9ycyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uJztcclxuZXhwb3J0ICogZnJvbSAnLi9jc3MnO1xyXG4iXX0=

package/esm2015/lib/components/reports/index.js

@@ -0,0 +1,4 @@
+export * from './charts';
+export * from './ndf-reports';
+export * from './chart-panel';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL3JlcG9ydHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXJ0cyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbmRmLXJlcG9ydHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0LXBhbmVsJ1xyXG4iXX0=

package/esm2015/lib/components/reports/ndf-reports/base/base-chart.js

@@ -0,0 +1,61 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { DestroySubject } from '../../../../shared/components';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+export class BaseChart extends DestroySubject {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this._translateService = this.injector.get(TranslateService);
+        this._rebuildTriggerSub = new BehaviorSubject(false);
+        this._configSub = new ReplaySubject(null);
+        this._isInitialized = false;
+        this._dataSub = new ReplaySubject(null);
+        this.onReady = new EventEmitter();
+        this._subscribeToLanguage();
+    }
+    set data(data) {
+        this._data = data;
+        this._dataSub.next(data);
+    }
+    get data() {
+        return this._data;
+    }
+    set config(config) {
+        this._config = _.cloneDeep(config);
+        this._configSub.next(this._config);
+    }
+    get config() {
+        return this._config;
+    }
+    set criteria(value) {
+        this._criteria = _.cloneDeep(value);
+    }
+    get criteria() {
+        return this._criteria;
+    }
+    _subscribeToLanguage() {
+        this._translateService.onLangChange
+            .pipe(distinctUntilChanged((pre, next) => pre.lang == next.lang), filter(() => this._isInitialized), takeUntil(this.destroy$))
+            .subscribe((_) => {
+            this._rebuildTriggerSub.next(true);
+        });
+    }
+}
+BaseChart.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseChart, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+BaseChart.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: BaseChart, inputs: { data: "data", config: "config", criteria: "criteria" }, outputs: { onReady: "onReady" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseChart, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { data: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], criteria: [{
+                type: Input
+            }], onReady: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jaGFydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvcmVwb3J0cy9uZGYtcmVwb3J0cy9iYXNlL2Jhc2UtY2hhcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQVksS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVqRixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFL0QsT0FBTyxFQUFFLGVBQWUsRUFBYyxhQUFhLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFbEUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDdkQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6RSxPQUFPLENBQUMsTUFBTSxRQUFRLENBQUM7O0FBR3ZCLE1BQU0sT0FBZ0IsU0FBYSxTQUFRLGNBQWM7SUEwQ3hELFlBQW1CLFFBQWtCO1FBQ3BDLEtBQUssRUFBRSxDQUFDO1FBRFUsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQXZDM0Isc0JBQWlCLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUMvQyx1QkFBa0IsR0FBRyxJQUFJLGVBQWUsQ0FBVSxLQUFLLENBQUMsQ0FBQztRQUNsRSxlQUFVLEdBQUcsSUFBSSxhQUFhLENBQUksSUFBSSxDQUFDLENBQUM7UUFHeEMsbUJBQWMsR0FBRyxLQUFLLENBQUM7UUFFdkIsYUFBUSxHQUFHLElBQUksYUFBYSxDQUFzQixJQUFJLENBQUMsQ0FBQztRQThCeEQsWUFBTyxHQUFHLElBQUksWUFBWSxFQUFTLENBQUM7UUFJN0MsSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7SUFDN0IsQ0FBQztJQWpDRCxJQUFhLElBQUksQ0FBQyxJQUF5QjtRQUMxQyxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBRUQsSUFBSSxJQUFJO1FBQ1AsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ25CLENBQUM7SUFHRCxJQUFhLE1BQU0sQ0FBQyxNQUFTO1FBQzVCLElBQUksQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNuQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVELElBQUksTUFBTTtRQUNULE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUNyQixDQUFDO0lBR0QsSUFBYSxRQUFRLENBQUMsS0FBb0I7UUFDekMsSUFBSSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxJQUFJLFFBQVE7UUFDWCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7SUFDdkIsQ0FBQztJQVNTLG9CQUFvQjtRQUM3QixJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWTthQUNqQyxJQUFJLENBQ0osb0JBQW9CLENBQUMsQ0FBQyxHQUFHLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsRUFDMUQsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsRUFDakMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FDeEI7YUFDQSxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUNoQixJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3BDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7dUdBekRvQixTQUFTOzJGQUFULFNBQVM7NEZBQVQsU0FBUztrQkFEOUIsU0FBUzsrRkFhSSxJQUFJO3NCQUFoQixLQUFLO2dCQVVPLE1BQU07c0JBQWxCLEtBQUs7Z0JBVU8sUUFBUTtzQkFBcEIsS0FBSztnQkFRSSxPQUFPO3NCQUFoQixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFdmVudEVtaXR0ZXIsIEluamVjdG9yLCBJbnB1dCwgT3V0cHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5pbXBvcnQgeyBEZXN0cm95U3ViamVjdCB9IGZyb20gJy4uLy4uLy4uLy4uL3NoYXJlZC9jb21wb25lbnRzJztcclxuXHJcbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCwgT2JzZXJ2YWJsZSwgUmVwbGF5U3ViamVjdCB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgQ2hhcnQgZnJvbSAnY2hhcnQuanMvYXV0byc7XHJcbmltcG9ydCB7IFRyYW5zbGF0ZVNlcnZpY2UgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcclxuaW1wb3J0IHsgZGlzdGluY3RVbnRpbENoYW5nZWQsIGZpbHRlciwgdGFrZVVudGlsIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xyXG5pbXBvcnQgeyBDcml0ZXJpYU1vZGVsLCBSZXBvcnRSZXNwb25zZU1vZGVsIH0gZnJvbSAnLi4vbW9kZWxzJztcclxuaW1wb3J0IF8gZnJvbSAnbG9kYXNoJztcclxuXHJcbkBEaXJlY3RpdmUoKVxyXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUNoYXJ0PFQ+IGV4dGVuZHMgRGVzdHJveVN1YmplY3Qge1xyXG5cdHB1YmxpYyBhYnN0cmFjdCByZXBvcnQkOiBPYnNlcnZhYmxlPGFueT47XHJcblxyXG5cdHByb3RlY3RlZCBfdHJhbnNsYXRlU2VydmljZSA9IHRoaXMuaW5qZWN0b3IuZ2V0KFRyYW5zbGF0ZVNlcnZpY2UpO1xyXG5cdHByb3RlY3RlZCByZWFkb25seSBfcmVidWlsZFRyaWdnZXJTdWIgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+KGZhbHNlKTtcclxuXHRwcm90ZWN0ZWQgX2NvbmZpZ1N1YiA9IG5ldyBSZXBsYXlTdWJqZWN0PFQ+KG51bGwpO1xyXG5cclxuXHJcblx0cHJvdGVjdGVkIF9pc0luaXRpYWxpemVkID0gZmFsc2U7XHJcblxyXG5cdHByb3RlY3RlZCBfZGF0YVN1YiA9IG5ldyBSZXBsYXlTdWJqZWN0PFJlcG9ydFJlc3BvbnNlTW9kZWw+KG51bGwpO1xyXG5cdHByaXZhdGUgX2RhdGE6IFJlcG9ydFJlc3BvbnNlTW9kZWw7XHJcblx0QElucHV0KCkgc2V0IGRhdGEoZGF0YTogUmVwb3J0UmVzcG9uc2VNb2RlbCkge1xyXG5cdFx0dGhpcy5fZGF0YSA9IGRhdGE7XHJcblx0XHR0aGlzLl9kYXRhU3ViLm5leHQoZGF0YSk7XHJcblx0fVxyXG5cclxuXHRnZXQgZGF0YSgpIHtcclxuXHRcdHJldHVybiB0aGlzLl9kYXRhO1xyXG5cdH1cclxuXHJcblx0cHJpdmF0ZSBfY29uZmlnOiBUO1xyXG5cdEBJbnB1dCgpIHNldCBjb25maWcoY29uZmlnOiBUKSB7XHJcblx0XHR0aGlzLl9jb25maWcgPSBfLmNsb25lRGVlcChjb25maWcpO1xyXG5cdFx0dGhpcy5fY29uZmlnU3ViLm5leHQodGhpcy5fY29uZmlnKTtcclxuXHR9XHJcblxyXG5cdGdldCBjb25maWcoKSB7XHJcblx0XHRyZXR1cm4gdGhpcy5fY29uZmlnO1xyXG5cdH1cclxuXHJcblx0cHJpdmF0ZSBfY3JpdGVyaWE6IENyaXRlcmlhTW9kZWw7XHJcblx0QElucHV0KCkgc2V0IGNyaXRlcmlhKHZhbHVlOiBDcml0ZXJpYU1vZGVsKSB7XHJcblx0XHR0aGlzLl9jcml0ZXJpYSA9IF8uY2xvbmVEZWVwKHZhbHVlKTtcclxuXHR9XHJcblxyXG5cdGdldCBjcml0ZXJpYSgpIHtcclxuXHRcdHJldHVybiB0aGlzLl9jcml0ZXJpYTtcclxuXHR9XHJcblxyXG5cdEBPdXRwdXQoKSBvblJlYWR5ID0gbmV3IEV2ZW50RW1pdHRlcjxDaGFydD4oKTtcclxuXHJcblx0Y29uc3RydWN0b3IocHVibGljIGluamVjdG9yOiBJbmplY3Rvcikge1xyXG5cdFx0c3VwZXIoKTtcclxuXHRcdHRoaXMuX3N1YnNjcmliZVRvTGFuZ3VhZ2UoKTtcclxuXHR9XHJcblxyXG5cdHByb3RlY3RlZCBfc3Vic2NyaWJlVG9MYW5ndWFnZSgpIHtcclxuXHRcdHRoaXMuX3RyYW5zbGF0ZVNlcnZpY2Uub25MYW5nQ2hhbmdlXHJcblx0XHRcdC5waXBlKFxyXG5cdFx0XHRcdGRpc3RpbmN0VW50aWxDaGFuZ2VkKChwcmUsIG5leHQpID0+IHByZS5sYW5nID09IG5leHQubGFuZyksXHJcblx0XHRcdFx0ZmlsdGVyKCgpID0+IHRoaXMuX2lzSW5pdGlhbGl6ZWQpLFxyXG5cdFx0XHRcdHRha2VVbnRpbCh0aGlzLmRlc3Ryb3kkKVxyXG5cdFx0XHQpXHJcblx0XHRcdC5zdWJzY3JpYmUoKF8pID0+IHtcclxuXHRcdFx0XHR0aGlzLl9yZWJ1aWxkVHJpZ2dlclN1Yi5uZXh0KHRydWUpO1xyXG5cdFx0XHR9KTtcclxuXHR9XHJcbn1cclxuIl19

package/esm2015/lib/components/reports/ndf-reports/base/base-custom-report.js

@@ -0,0 +1,77 @@
+import { Directive, Input } from '@angular/core';
+import _ from 'lodash';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { DestroySubject } from '../../../../shared/components';
+import { ChartManagerService } from '../services';
+import * as i0 from "@angular/core";
+export class BaseCustomReport extends DestroySubject {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this._chartHelperService = this.injector.get(ChartManagerService);
+        this.direction = 'rtl';
+        this._dataSub = new ReplaySubject(null);
+        this._criteriaSub = new ReplaySubject(null);
+        this.criteria$ = this._criteriaSub.asObservable();
+        this._configSub = new BehaviorSubject(null);
+        this.config$ = this._configSub.asObservable();
+    }
+    set data(data) {
+        this._data = data;
+        this._dataSub.next(data);
+    }
+    get data() {
+        return this._data;
+    }
+    set criteria(value) {
+        this._criteria = _.cloneDeep(value);
+        this._criteriaSub.next(this._criteria);
+    }
+    get criteria() {
+        return this._criteria;
+    }
+    set config(obj) {
+        if (obj) {
+            this._configSub.next(obj);
+        }
+    }
+    get config() {
+        return this._configSub.getValue();
+    }
+    chartReady(chart) {
+        this.chart = chart;
+        this._chartHelperService.setChart(chart);
+        this._printListener = (event) => {
+            this.chart.resize();
+        };
+        window.addEventListener('beforeprint', this._printListener);
+        queueMicrotask(() => {
+            this.chart.resize();
+        });
+    }
+    ngOnDestroy() {
+        if (this.chart) {
+            this.chart.destroy();
+        }
+        if (this._printListener) {
+            window.removeEventListener('beforeprint', this._printListener);
+        }
+        super.ngOnDestroy();
+    }
+}
+BaseCustomReport.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseCustomReport, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+BaseCustomReport.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: BaseCustomReport, inputs: { direction: "direction", definition: "definition", data: "data", criteria: "criteria", config: "config" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseCustomReport, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { direction: [{
+                type: Input
+            }], definition: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], criteria: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/reports/ndf-reports/base/base-graph.report.js

@@ -0,0 +1,57 @@
+import { __rest } from "tslib";
+import { Directive } from '@angular/core';
+import { ChartThemeService } from '../services';
+import { ReportsDialogService } from '../services/reports-dialog.service';
+import { BaseReport } from './base-report';
+import Chart from 'chart.js/auto';
+import { getColor } from '../../charts/utility';
+import { filter, takeUntil } from 'rxjs/operators';
+import _ from 'lodash';
+import { GraphDialogComponent } from '../components/_parts/graph-dialog/graph-dialog.component';
+import * as i0 from "@angular/core";
+export class BaseGraphReport extends BaseReport {
+    constructor() {
+        super(...arguments);
+        this._dialog = this.injector.get(ReportsDialogService);
+        this._chartThemeService = this.injector.get(ChartThemeService);
+        this._initialTheme = this._chartThemeService.getCurrentTheme();
+    }
+    openGraphDialog(component = GraphDialogComponent) {
+        this._dialog.open(component, {
+            config: this.config,
+            data: this.data,
+            criteria: this.criteria,
+            direction: this.direction
+        });
+    }
+    ngAfterViewInit() {
+        this._setupThemeWatcher();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._chartThemeService.destroy();
+    }
+    _setupThemeWatcher() {
+        this._chartThemeService.theme$
+            .pipe(filter((value) => value !== this._initialTheme && !!this._definition), takeUntil(this.destroy$))
+            .subscribe((theme) => {
+            this._initialTheme = theme;
+            const _a = this._configSub.getValue(), { chart } = _a, config = __rest(_a, ["chart"]);
+            const data = _.merge({}, this._definition, {
+                chart: {
+                    type: chart.type
+                }
+            });
+            this._configSub.next(this._prepareConfig(data));
+            Chart.defaults.color = getColor('--chart-default-color', '#666');
+            Chart.defaults.backgroundColor = getColor('--chart-default-background-color', 'rgba(0, 0, 0, 0.1)');
+            Chart.defaults.borderColor = getColor('--chart-default-border-color', 'rgba(0, 0, 0, 0.1)');
+        });
+    }
+}
+BaseGraphReport.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseGraphReport, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+BaseGraphReport.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: BaseGraphReport, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BaseGraphReport, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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