@visionaris-bruno/vs-echarts 9.0.7 → 9.1.3

package/fesm2022/visionaris-bruno-vs-echarts.mjs

@@ -1,10 +1,10 @@
 import { provideEchartsCore, NgxEchartsDirective } from 'ngx-echarts';
 import * as echarts from 'echarts/core';
-import { BarChart, PieChart, LineChart, ScatterChart, FunnelChart, SunburstChart, SankeyChart, BoxplotChart } from 'echarts/charts';
-import { TooltipComponent, GridComponent, LegendComponent, GraphicComponent, PolarComponent, DatasetComponent, DataZoomComponent } from 'echarts/components';
+import { BarChart, PieChart, LineChart, ScatterChart, FunnelChart, SunburstChart, SankeyChart, BoxplotChart, HeatmapChart } from 'echarts/charts';
+import { TooltipComponent, GridComponent, CalendarComponent, LegendComponent, GraphicComponent, PolarComponent, DatasetComponent, DataZoomComponent, VisualMapComponent } from 'echarts/components';
 import { CanvasRenderer, SVGRenderer } from 'echarts/renderers';
 import * as i0 from '@angular/core';
-import { InjectionToken, Inject, Injectable, EventEmitter, inject, Output, Input, ViewChild, Directive, Component } from '@angular/core';
+import { Inject, Injectable, InjectionToken, EventEmitter, inject, Output, Input, ViewChild, Directive, Component } from '@angular/core';
 import langES from 'echarts/lib/i18n/langES.js';
 import langDE from 'echarts/lib/i18n/langDE.js';
 import langFR from 'echarts/lib/i18n/langFR.js';
@@ -17,6 +17,55 @@ import { CommonModule } from '@angular/common';
 import { merge as merge$1 } from 'lodash';
 import { TranslateService } from '@ngx-translate/core';
 
+// TODO: Exportar valores por defecto de vs-echarts.config.ts por este servicio y actualizar en logica de frontend.
+let activeLocale = undefined;
+function getActiveLocale() {
+    return activeLocale;
+}
+function setActiveLocale(locale) {
+    activeLocale = locale;
+}
+class VSEchartsConfigService {
+    vsEchartsConfig;
+    mapping = {
+        es: 'ES',
+        en: 'EN',
+        us: 'EN',
+        de: 'DE',
+        fr: 'FR',
+        it: 'IT',
+        pt: 'PT-br',
+        br: 'PT-br',
+    };
+    constructor(vsEchartsConfig) {
+        this.vsEchartsConfig = vsEchartsConfig;
+        if (this.vsEchartsConfig?.locale) {
+            setActiveLocale(this.vsEchartsConfig.locale);
+        }
+    }
+    setLocale(language) {
+        if (!language) {
+            this.vsEchartsConfig.locale = 'ES';
+            setActiveLocale('ES');
+            return;
+        }
+        const echartsLocale = this.mapping[language.toLowerCase()] || 'ES';
+        this.vsEchartsConfig.locale = echartsLocale;
+        setActiveLocale(echartsLocale);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, deps: [{ token: VS_ECHARTS_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VS_ECHARTS_CONFIG]
+                }] }] });
+
 /**
  * Global Design Tokens for ECharts
  */
@@ -44,7 +93,7 @@ function getDefaultPalette() {
  * pero por algun motivo esto es distinto en este tipo de graficos.
  *
  * apache echarts version: 5.6.0
-*/
+ * */
 const fixPieDataIndexInside = (e) => {
     /** selected serie index */
     const ssi = e.fromActionPayload.seriesIndex;
@@ -56,11 +105,47 @@ const fixPieDataIndexInside = (e) => {
     e.fromActionPayload.dataIndexInside = fixedDataIndex; // aplico corrección de index inside.
     return e;
 };
+/**
+ * Retorna valor con formato local establecido por configuracion de biblioteca.
+ * Utilizara el del navegador si el locale y activeLocale es indefinido.
+ * @param value
+ * @param opts
+ * @returns
+ */
+const valueToLocale = (value, opts) => {
+    const locale = opts?.locale ?? getActiveLocale();
+    const officialLocale = locale ? localeMapper[locale] : undefined;
+    // 1. Si ya es una instancia de Date
+    if (value instanceof Date) {
+        return value.toLocaleString(officialLocale);
+    }
+    // 2. Si es un string, intentamos ver si es una fecha válida
+    if (typeof value === 'string') {
+        const parsedDate = Date.parse(value);
+        if (!isNaN(parsedDate)) {
+            return new Date(parsedDate).toLocaleString(officialLocale);
+        }
+        // Si no era una fecha válida, devolvemos el string tal cual
+        return value;
+    }
+    // 3. Si es un número o bigint
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return value.toLocaleString(officialLocale);
+    }
+    // Fallback por si llega algo inesperado (null, undefined, etc.)
+    return String(value);
+};
+const defaultValueFormatter = (value) => {
+    return valueToLocale(value);
+};
 
 /// <reference path="./typings.d.ts" />
 const VS_ECHARTS_CONFIG = new InjectionToken('VS_ECHARTS_CONFIG', {
     providedIn: 'root',
-    factory: () => ({ renderer: 'svg' }),
+    factory: () => ({
+        renderer: 'svg',
+        locale: 'AR',
+    }),
 });
 /**
  * Inicialización centralizada de ECharts para evitar duplicación y efectos secundarios
@@ -78,6 +163,8 @@ function initializeEcharts() {
         BoxplotChart,
         TooltipComponent,
         GridComponent,
+        HeatmapChart,
+        CalendarComponent,
         LegendComponent,
         CanvasRenderer,
         SVGRenderer,
@@ -85,6 +172,7 @@ function initializeEcharts() {
         PolarComponent,
         DatasetComponent,
         DataZoomComponent,
+        VisualMapComponent,
     ]);
     // Register additional locales in ECharts
     echarts.registerLocale('ES', langES);
@@ -102,6 +190,47 @@ function provideVSEcharts() {
     initializeEcharts();
     return provideEchartsCore({ echarts });
 }
+// 2. Diccionario de mapeo interno a códigos BCP 47 oficiales
+const localeMapper = {
+    ZH: 'zh-CN', // Chino Simplificado (puedes cambiarlo a zh-TW si prefieres)
+    EN: 'en-US', // Inglés (o en-GB)
+    AR: 'ar-EG', // Árabe
+    CS: 'cs-CZ', // Checo
+    DE: 'de-DE', // Alemán
+    EL: 'el-GR', // Griego
+    ES: 'es-ES', // Español
+    FA: 'fa-IR', // Persa
+    FI: 'fi-FI', // Finlandés
+    FR: 'fr-FR', // Francés
+    HU: 'hu-HU', // Húngaro
+    IT: 'it-IT', // Italiano
+    JA: 'ja-JP', // Japonés
+    KO: 'ko-KR', // Coreano
+    LV: 'lv-LV', // Letón
+    'nb-NO': 'nb-NO', // Noruego Bokmål (ya es estándar)
+    NL: 'nl-NL', // Neerlandés
+    PL: 'pl-PL', // Polaco
+    'PT-br': 'pt-BR', // Portugués de Brasil (corregido a camelCase estándar)
+    RO: 'ro-RO', // Rumano
+    RU: 'ru-RU', // Ruso
+    SI: 'si-LK', // Cingalés
+    SV: 'sv-SE', // Sueco
+    TH: 'th-TH', // Tailandés
+    TR: 'tr-TR', // Turco
+    UK: 'uk-UA', // Ucraniano
+    VI: 'vi-VN', // Vietnamita
+};
+// 3. Función formateadora universal (para números)
+function formatNumberByLocale(value, customLocale, options) {
+    // Obtenemos el locale oficial, si no existe por alguna razón, usamos el del sistema
+    const officialLocale = localeMapper[customLocale] || undefined;
+    return value.toLocaleString(officialLocale, options);
+}
+// 4. Función formateadora universal (para fechas)
+function formatDateByLocale(date, customLocale, options) {
+    const officialLocale = localeMapper[customLocale] || undefined;
+    return date.toLocaleString(officialLocale, options);
+}
 function defaultOptionsOverrides() {
     return {
         tooltip: {
@@ -183,46 +312,11 @@ function defaultOptionsOverrides() {
         hBoxplot: {
             series: {}
         },
+        heatmapCalendar: {
+            series: {},
+        },
     };
 }
-const defaultValueFormatter = (value) => `${value}`;
-
-// TODO: Exportar valores por defecto de vs-echarts.config.ts por este servicio y actualizar en logica de frontend.
-class VSEchartsConfigService {
-    vsEchartsConfig;
-    mapping = {
-        es: 'ES',
-        en: 'EN',
-        us: 'EN',
-        de: 'DE',
-        fr: 'FR',
-        it: 'IT',
-        pt: 'PT-br',
-        br: 'PT-br',
-    };
-    constructor(vsEchartsConfig) {
-        this.vsEchartsConfig = vsEchartsConfig;
-    }
-    setLocale(language) {
-        if (!language) {
-            this.vsEchartsConfig.locale = 'ES';
-            return;
-        }
-        const echartsLocale = this.mapping[language.toLowerCase()] || 'ES';
-        this.vsEchartsConfig.locale = echartsLocale;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, deps: [{ token: VS_ECHARTS_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: VSEchartsConfigService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [VS_ECHARTS_CONFIG]
-                }] }] });
 
 /**
  * BaseEchartsComponent
@@ -247,6 +341,7 @@ class BaseEchartsComponent {
     /** Subject para debouncing de actualizaciones. ReplaySubject asegura no perder el primer renderizado. */
     updateSubject = new ReplaySubject(1);
     updateSubscription;
+    afterSetOptionsHook;
     chartInstance;
     vsEchartsConfig = (() => {
         try {
@@ -290,6 +385,9 @@ class BaseEchartsComponent {
             replaceMerge,
         };
         this.chartInstance?.setOption(chartOptions, _opts);
+        if (this.afterSetOptionsHook) {
+            this.afterSetOptionsHook();
+        }
     }
     // metodos protegidos //
     dispatchAction(type, d) {
@@ -435,12 +533,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImpo
  *
  * @see {@link VisionarisFrontEnd/docs/technical/echarts-architecture.md}
  */
-// Pre-cached native formatter for performance in axis ticks
-const compactFormatter = new Intl.NumberFormat('es-AR', {
-    notation: 'compact',
-    compactDisplay: 'short',
-    maximumFractionDigits: 1
-});
+const formattersCache = new Map();
+function getCompactFormatter() {
+    const locale = getActiveLocale();
+    const officialLocale = locale ? localeMapper[locale] : undefined;
+    const cacheKey = officialLocale || 'default';
+    let formatter = formattersCache.get(cacheKey);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(officialLocale, {
+            notation: 'compact',
+            compactDisplay: 'short',
+            maximumFractionDigits: 1
+        });
+        formattersCache.set(cacheKey, formatter);
+    }
+    return formatter;
+}
+// Wrap with custom formatter implementation to keep identical signature/API dynamically
+const compactFormatter = {
+    format: (value) => getCompactFormatter().format(value)
+};
 /**
  * Formats a value using native browser SI suffixes (k, M, B).
  */
@@ -1135,7 +1247,8 @@ class BoxPlotBuilder {
             {
                 type: 'slider',
                 height: 20,
-                bottom: 10
+                bottom: 10,
+                labelFormatter: (value) => valueToLocale(value)
             }
         ];
     }
@@ -1935,6 +2048,123 @@ class SankeyBuilder {
     }
 }
 
+class HeatmapCalendarBuilder {
+    baseProduct;
+    result = {};
+    calendarHeight = 0;
+    valueFormatter = defaultValueFormatter;
+    palette = [];
+    colorResolver;
+    constructor(baseProduct) {
+        this.baseProduct = baseProduct;
+    }
+    reset() {
+        this.result = {};
+    }
+    addCommons() {
+        const opts = {
+            palette: this.palette,
+        };
+        const commonsOverrides = getCommons(opts);
+        merge$1(this.result, commonsOverrides, { grid: {} });
+    }
+    addDataset(data, opts) { }
+    addVisualmap(data) { }
+    addCalendar(data) { }
+    addSeries(data, overrides, opts) {
+        if (!data || !data.dimensions || !data.source || data.source.length === 0)
+            return;
+        const calendarOverrides = opts.calendar;
+        const visualMapOverrides = opts.visualMap;
+        const measureDim = data.dimensions.find(d => d.name !== 'category');
+        const dimKey = measureDim ? measureDim.name : '';
+        const dataByYear = new Map();
+        let min = Infinity;
+        let max = -Infinity;
+        data.source.forEach((s) => {
+            if (!s.category)
+                return;
+            const dateObj = new Date(s.category);
+            if (isNaN(dateObj.getTime()))
+                return;
+            const year = dateObj.getFullYear().toString();
+            const value = s[dimKey] !== undefined && s[dimKey] !== null ? Number(s[dimKey]) : 0;
+            if (value < min)
+                min = value;
+            if (value > max)
+                max = value;
+            if (!dataByYear.has(year)) {
+                dataByYear.set(year, []);
+            }
+            const formattedDate = dateObj.toISOString().split('T')[0];
+            dataByYear.get(year).push([formattedDate, value]);
+        });
+        if (min === Infinity)
+            min = 0;
+        if (max === -Infinity)
+            max = 0;
+        const sortedYears = Array.from(dataByYear.keys()).sort();
+        const calendars = [];
+        const series = [];
+        sortedYears.forEach((year, index) => {
+            calendars.push(merge$1({
+                top: 120 + index * 180,
+                range: year,
+            }, calendarOverrides));
+            series.push(merge$1({
+                calendarIndex: index,
+                data: dataByYear.get(year) || []
+            }, overrides));
+        });
+        this.result.calendar = calendars;
+        this.result.series = series;
+        const visualMap = merge$1({
+            min: min,
+            max: max,
+        }, visualMapOverrides);
+        if (this.palette && this.palette.length > 0) {
+            visualMap.inRange = {
+                color: this.palette
+            };
+        }
+        this.result.visualMap = visualMap;
+    }
+    addTooltip(data, overrides) {
+        const mainDim = data.dimensions.filter(d => d.name != 'category')[0];
+        const valueFormatter = this.valueFormatter;
+        const dimkey = mainDim.name, dimAlias = mainDim.displayName;
+        const tooltipFormatter = (params) => {
+            const date = params.value[params.encode['time']], value = params.value[params.encode['value']];
+            return `<div style="text-align: center;" ><b>${date}</b></br>${params.marker} ${mainDim.displayName}</br><b>${valueFormatter(value, dimkey)}</b></div>`;
+        };
+        const tooltipOptions = getTooltipOptions({
+            trigger: 'item',
+            formatter: tooltipFormatter,
+        });
+        this.result.tooltip = tooltipOptions;
+    }
+    addPolar() { }
+    addXAxis(data, overrides, type) { }
+    addYAxis(data, overrides, type) { }
+    addRadiusAxis(data, overrides) { }
+    addAngleAxis(data, overrides) { }
+    addLegend() { }
+    addGraphic() { }
+    addDataZoom() { }
+    setValueFormatter(formatter) {
+        this.valueFormatter = formatter;
+    }
+    setPalette(palette) {
+        this.palette = palette;
+    }
+    setColorResolver(resolver) {
+        this.colorResolver = resolver;
+    }
+    getResult() {
+        return this.result;
+    }
+}
+
 /**
  * Director de Builds.
  */
@@ -2206,6 +2436,30 @@ class VSECDirector {
         this.builder.addTooltip(data, overrides.tooltip);
         this.builder.addDataZoom();
     }
+    makeHeatmapCalendar(data, overrides, opts = {}) {
+        if (this.builder instanceof HeatmapCalendarBuilder == false) {
+            return;
+        }
+        const { valueFormatter = undefined, palette = undefined, colorResolver = undefined, axisTypes = {
+            x: 'value',
+            y: 'category',
+        }, } = opts;
+        this.builder.reset();
+        // El orden importa, primero callbacks y despues componentes.
+        // chart callbaks
+        if (valueFormatter)
+            this.builder.setValueFormatter(valueFormatter);
+        const product = this.builder.baseProduct;
+        const seriesOverrides = merge$1({}, product.baseOptions.series, overrides[product.chartKey].series);
+        // chart components
+        this.builder.addCommons();
+        const seriesConfigOpts = {
+            calendar: product.baseOptions.calendar,
+            visualMap: product.baseOptions.visualMap,
+        };
+        this.builder.addSeries(data, seriesOverrides, seriesConfigOpts);
+        this.builder.addTooltip(data, overrides.tooltip);
+    }
 }
 
 /**
@@ -3008,6 +3262,104 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImpo
                     ], template: "<div\n  class=\"echarts-container\"\n  echarts\n  [options]=\"{}\"\n  [initOpts]=\"initOptions\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n></div>\n", styles: [".echarts-container{width:100%;height:100%;position:relative}\n"] }]
         }] });
 
+class EChartsHeatmapCalendar extends BaseEchartsComponent {
+    /** aires para el calculo de resize y posicionamientos de distintos componentes */
+    calendarPaddings = {
+        visualMapTop: 5,
+    };
+    baseSeriesOptions = {
+        type: 'heatmap',
+        coordinateSystem: 'calendar',
+        selectedMode: 'single',
+        select: {
+            itemStyle: {
+                borderWidth: 2,
+                borderColor: EChartsTokens.sBorderColor,
+                shadowColor: EChartsTokens.sShadowColor,
+                shadowBlur: 6,
+            }
+        }
+    };
+    baseProduct = {
+        chartKey: 'heatmapCalendar',
+        baseOptions: {
+            visualMap: {
+                calculable: true,
+                orient: 'horizontal',
+                left: 'center',
+                top: this.calendarPaddings.visualMapTop,
+                formatter: (dv) => {
+                    const value = dv ?? '';
+                    return valueToLocale(value);
+                },
+            }, // dinamico
+            calendar: {
+                cellSize: ['auto', 20],
+                right: 5,
+                left: 60,
+                yearLabel: { show: true },
+                dayLabel: { firstDay: 1 },
+            },
+            series: this.baseSeriesOptions, // dinamico, uno por año.
+        }
+    };
+    builder = new HeatmapCalendarBuilder(this.baseProduct);
+    director = new VSECDirector(this.builder);
+    make() {
+        const makeOpts = {
+            palette: this.palette,
+            valueFormatter: this.valueFormatter,
+            colorResolver: this.colorResolver,
+        };
+        this.director.makeHeatmapCalendar(this.data, this.optionsOverrides, makeOpts);
+    }
+    afterSetOptionsHook = () => {
+        if (!this.chartInstance)
+            return;
+        let chartHeight = 0;
+        const gElements = this.chartInstance.getDom().getElementsByTagName("g");
+        for (let i = 0; i < gElements.length; i++) {
+            const ge = gElements[i];
+            const geHeight = ge.getBBox().height;
+            if (chartHeight < geHeight) {
+                chartHeight = geHeight;
+            }
+        }
+        const { visualMapTop } = this.calendarPaddings;
+        /**
+       * aire inferior para el svg maestro.
+       */
+        const svgBottom = 5;
+        this.chartInstance.resize({ height: chartHeight + visualMapTop + svgBottom });
+    };
+    onChartClick(event) {
+        if (event.componentType === 'series') {
+            const dimension = this.data.dimensions.filter(d => d.name != 'category')[0];
+            const dimensionAlias = dimension.displayName;
+            const dimensionKey = dimension.name;
+            const itemValue = event.value[event.encode['value']];
+            const date = event.value[event.encode['time']];
+            // opero event para que sea compatible con el de base
+            event.value = {
+                category: date,
+                [dimensionKey]: itemValue,
+            };
+            event.name = date;
+            event.seriesName = dimensionAlias;
+            super.onChartClick(event);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: EChartsHeatmapCalendar, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.19", type: EChartsHeatmapCalendar, isStandalone: true, selector: "vs-echarts-heatmapCalendar", usesInheritance: true, ngImport: i0, template: "<div\n  class=\"echarts-container\"\n  echarts\n  [options]=\"{}\"\n  [initOpts]=\"initOptions\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n  (chartClick)=\"onChartClick($event)\"\n  (chartSelectChanged)=\"onChartSelectChanged($event)\"\n></div>", styles: [".echarts-container{width:100%;height:100%;position:relative;overflow-y:auto;scrollbar-gutter:stable}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "initOpts", "merge", "autoResize", "loading", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartHighlight", "chartDownplay", "chartSelectChanged", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendLegendSelectAll", "chartLegendLegendInverseSelect", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartGraphRoam", "chartGeoRoam", "chartTreeRoam", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartGeoSelectChanged", "chartGeoSelected", "chartGeoUnselected", "chartAxisAreaSelected", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartGlobalCursorTaken", "chartRendered", "chartFinished"], exportAs: ["echarts"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: EChartsHeatmapCalendar, decorators: [{
+            type: Component,
+            args: [{ selector: 'vs-echarts-heatmapCalendar', standalone: true, imports: [
+                        CommonModule,
+                        NgxEchartsDirective,
+                    ], template: "<div\n  class=\"echarts-container\"\n  echarts\n  [options]=\"{}\"\n  [initOpts]=\"initOptions\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n  (chartClick)=\"onChartClick($event)\"\n  (chartSelectChanged)=\"onChartSelectChanged($event)\"\n></div>", styles: [".echarts-container{width:100%;height:100%;position:relative;overflow-y:auto;scrollbar-gutter:stable}\n"] }]
+        }] });
+
 // Interfaces de Inputs de Base EChart Component // 
 // TopLevelFormatterParams
 
@@ -3023,5 +3375,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { BaseEchartsComponent, EChartsAreaComponent, EChartsAreaStackComponent, EChartsBarStackedComponent, EChartsBarStackedRadialComponent, EChartsHBarComponent, EChartsHBarStackedComponent, EChartsHBoxplotComponent, EChartsSunburstComponent, EchartsBarComponent, EchartsFunnelComponent, EchartsLineComponent, EchartsPieComponent, EchartsRingComponent, EchartsSankeyComponent, EchartsScatterComponent, VSEchartsConfigService, defaultOptionsOverrides, provideVSEcharts };
+export { BaseEchartsComponent, EChartsAreaComponent, EChartsAreaStackComponent, EChartsBarStackedComponent, EChartsBarStackedRadialComponent, EChartsHBarComponent, EChartsHBarStackedComponent, EChartsHBoxplotComponent, EChartsHeatmapCalendar, EChartsSunburstComponent, EchartsBarComponent, EchartsFunnelComponent, EchartsLineComponent, EchartsPieComponent, EchartsRingComponent, EchartsSankeyComponent, EchartsScatterComponent, VSEchartsConfigService, defaultOptionsOverrides, getActiveLocale, provideVSEcharts, setActiveLocale };
 //# sourceMappingURL=visionaris-bruno-vs-echarts.mjs.map