@mozaic-ds/chart 0.1.0-beta.3 → 0.1.0-beta.30

package/src/services/ChartsCommonLegend.ts

@@ -1,5 +1,5 @@
 import type { Ref } from 'vue';
-import type { HTMLLegendPlugin } from "../types/Chart";
+import type { HTMLLegendPlugin } from '../types/Chart';
 import type { ChartOptions } from 'chart.js';
 import PatternFunctions from './PatternFunctions';
 import { formatValueAndRate } from './FormatUtilities';
@@ -9,87 +9,151 @@ const { getPatternCanvas } = PatternFunctions();
 
 export const LEGEND_FONT_SIZE = 14;
 export const LEGEND_LABEL_LEFT_MARGIN = '6px';
-export const LEGEND_BOX_SIZE = 18;
+export const LEGEND_BOX_SIZE = '22px';
 export const LEGEND_BOX_POINT_SIZE = 6;
+export const LEGEND_BOX_BORDER = '2px';
 
 export interface Chart {
-  update (): void;
+  update(): void;
 
-  toggleDataVisibility (datasetIndex: number): void;
+  toggleDataVisibility(datasetIndex: number): void;
 
-  isDatasetVisible (datasetIndex: number): boolean;
+  isDatasetVisible(datasetIndex: number): boolean;
 
   getDataVisibility(index: number): boolean;
 
-  setDatasetVisibility (datasetIndex: number, visible: boolean): void;
+  setDatasetVisibility(datasetIndex: number, visible: boolean): void;
 
-  plugins: HTMLLegendPlugin,
+  plugins: HTMLLegendPlugin;
 
-  options: ChartOptions<'radar'> | ChartOptions<'doughnut'> | ChartOptions<'bar'> | ChartOptions<'line'>,
+  options:
+    | ChartOptions<'radar'>
+    | ChartOptions<'doughnut'>
+    | ChartOptions<'bar'>
+    | ChartOptions<'line'>;
 
-  config: { type?: string, data: { labels: string[] ,datasets: unknown[], data?: unknown[] } },
+  config: {
+    type?: string;
+    data: { labels: string[]; datasets: unknown[]; data?: unknown[] };
+  };
 }
 
 export interface ChartItem {
-  fontColor: string,
-  hidden: boolean,
-  text: string,
-  fillStyle: string,
-  strokeStyle: string,
-  lineWidth: number
-  datasetIndex: number,
-  index: number
+  fontColor: string;
+  hidden: boolean;
+  text: string;
+  fillStyle: string;
+  strokeStyle: string;
+  lineWidth: number;
+  datasetIndex: number;
+  index: number;
+  lineCap?: string;
 }
 
-export function getHtmlLegendPlugin(legendContainer: Ref, selectMode: Ref<boolean>,  onHoverIndex: any, disableAccessibility: Ref<boolean>, patternsColors: Ref<string[]>, patternsList: Ref<((hover: boolean, color: string, disableAccessibility: boolean) => CanvasPattern)[]>, maxValueToDisplay?: number, chartData?: any): HTMLLegendPlugin[] {
-  return [{
-      id: 'htmlLegend',
-      afterUpdate (chart: any) {
+export function getHtmlLegendPlugin(
+  legendContainer: Ref,
+  selectMode: Ref<boolean>,
+  onHoverIndex: any,
+  disableAccessibility: Ref<boolean>,
+  patternsColors: Ref<string[]>,
+  patternsList: Ref<
+    ((
+      hover: boolean,
+      color: string,
+      disableAccessibility: boolean
+    ) => CanvasPattern)[]
+  >,
+  enableHoverFeature: Ref<boolean>,
+  maxValueToDisplay?: number,
+  chartData?: any
+): HTMLLegendPlugin {
+  return {
+    id: 'htmlLegend',
+    afterUpdate(chart: any) {
+      const isDoughnut: boolean = chart.config.type === 'doughnut';
+      const flexDirection = isDoughnut ? 'column' : 'row';
+      const ul: HTMLLIElement = getOrCreateLegendList(
+        legendContainer,
+        flexDirection
+      );
+      ul.style.margin = '1.375rem 1.0625rem';
+      while (ul.firstChild) {
+        ul.firstChild.remove();
+      }
+      const items: ChartItem[] =
+        chart.options.plugins.legend.labels.generateLabels(chart);
+      items.forEach((item: ChartItem): void => {
         const isDoughnut: boolean = chart.config.type === 'doughnut';
-        const flexDirection = isDoughnut ? 'column' : 'row';
-        const ul: HTMLLIElement = getOrCreateLegendList(legendContainer, flexDirection);
-        ul.style.margin = '1.375rem 1.0625rem';
-        while (ul.firstChild) {
-          ul.firstChild.remove();
-        }
-        const items: ChartItem[] = chart.options.plugins.legend.labels.generateLabels(chart);
-        items.forEach((item: ChartItem): void => {
-          const isDoughnut: boolean = chart.config.type === 'doughnut';
-          const index: number = isDoughnut ? item.index : item.datasetIndex;
-          const li: HTMLElement = createHtmlLegendListElement(chart, selectMode, index);
-          if (isDoughnut) {
-            const isOthersElement: boolean = index + 1 === maxValueToDisplay ? true : false;
-            li.style.marginTop = '12px';
-            if (isOthersElement) {
-              li.style.position = 'relative';
-            }
-          } else {
-            li.style.marginRight = '12px'
-          }
-          li.style.width = 'max-content';
-          li.style.cursor = 'pointer';
-          let liContent: HTMLElement;
-          if (!selectMode.value) {
-            liContent = createLegendElementWithPatterns(item, chart, onHoverIndex, disableAccessibility.value, patternsColors.value, patternsList.value);
-          } else {
-            liContent = createLegendElementWithCheckbox(chart, item, selectMode, onHoverIndex, disableAccessibility.value);
-          }
-          li.appendChild(liContent);
-          li.appendChild(createHtmlLegendItemText(item));
-          if (isDoughnut && maxValueToDisplay && hasOthersTooltipToDisplay(chartData, maxValueToDisplay, index)) {
-            li.appendChild(createTooltipAndItsIcon(chartData, maxValueToDisplay));
+        const index: number = isDoughnut ? item.index : item.datasetIndex;
+        const li: HTMLElement = createHtmlLegendListElement(
+          chart,
+          selectMode,
+          index
+        );
+        if (isDoughnut) {
+          const isOthersElement: boolean =
+            index + 1 === maxValueToDisplay ? true : false;
+          li.style.marginTop = '12px';
+          if (isOthersElement) {
+            li.style.position = 'relative';
           }
-          ul.appendChild(li);
-        });
-      }
-  }];
+        } else {
+          li.style.marginRight = '10px';
+        }
+        li.style.width = 'max-content';
+        li.style.cursor = 'pointer';
+        let liContent: HTMLElement;
+        if (!selectMode.value) {
+          liContent = createLegendElementWithPatterns(
+            item,
+            chart,
+            onHoverIndex,
+            disableAccessibility.value,
+            patternsColors.value,
+            patternsList.value,
+            enableHoverFeature.value
+          );
+        } else {
+          liContent = createLegendElementWithCheckbox(
+            chart,
+            item,
+            selectMode,
+            onHoverIndex,
+            patternsColors.value,
+            enableHoverFeature.value
+          );
+        }
+        liContent.style.boxSizing = 'border-box';
+        li.appendChild(liContent);
+        li.appendChild(createHtmlLegendItemText(item));
+        if (
+          isDoughnut &&
+          maxValueToDisplay &&
+          hasOthersTooltipToDisplay(chartData, maxValueToDisplay, index)
+        ) {
+          li.appendChild(createTooltipAndItsIcon(chartData, maxValueToDisplay));
+        }
+        ul.appendChild(li);
+      });
+    }
+  };
 }
 
-export function hasOthersTooltipToDisplay (doughnutData: any, maxValueToDisplay: number, index: number) {
-  return doughnutData.data.length > maxValueToDisplay && index === maxValueToDisplay - 1;
+export function hasOthersTooltipToDisplay(
+  doughnutData: any,
+  maxValueToDisplay: number,
+  index: number
+) {
+  return (
+    doughnutData.data.length > maxValueToDisplay &&
+    index === maxValueToDisplay - 1
+  );
 }
 
-export function createTooltipAndItsIcon (doughnutData: any, maxValueToDisplay: number): HTMLDivElement {
+export function createTooltipAndItsIcon(
+  doughnutData: any,
+  maxValueToDisplay: number
+): HTMLDivElement {
   const iconTopWrapper = document.createElement('div');
   const iconWrapper = document.createElement('div');
   const icon = document.createElement('img');
@@ -98,22 +162,29 @@ export function createTooltipAndItsIcon (doughnutData: any, maxValueToDisplay: n
   icon.src = QuestionMarkSvg;
   icon.style.top = '0';
   icon.style.width = '1.5rem';
-  icon.style.filter = 'invert(38%) sepia(19%) saturate(18%) hue-rotate(337deg) brightness(97%) contrast(85%)';
+  icon.style.filter =
+    'invert(38%) sepia(19%) saturate(18%) hue-rotate(337deg) brightness(97%) contrast(85%)';
   iconWrapper.style.position = 'relative';
   iconWrapper.style.display = 'flex';
   const tooltip = createLegendOthersTooltip(doughnutData, maxValueToDisplay);
   icon.onmouseover = () => {
     (iconWrapper.firstElementChild as HTMLElement).style.visibility = 'visible';
   };
+  icon.onmouseleave = () => {
+    (iconWrapper.firstElementChild as HTMLElement).style.visibility = 'hidden';
+  };
   iconTopWrapper.appendChild(iconWrapper);
   iconWrapper.appendChild(tooltip);
   iconWrapper.appendChild(icon);
   return iconTopWrapper;
 }
 
-function createLegendOthersTooltip (doughnutData: any, maxValueToDisplay: number) {
+function createLegendOthersTooltip(
+  doughnutData: any,
+  maxValueToDisplay: number
+) {
   const tooltip = document.createElement('div');
-  tooltip.style.visibility= 'hidden';
+  tooltip.style.visibility = 'hidden';
   tooltip.style.position = 'absolute';
   tooltip.style.zIndex = '10';
   tooltip.style.width = '350px';
@@ -129,9 +200,13 @@ function createLegendOthersTooltip (doughnutData: any, maxValueToDisplay: number
   return tooltip;
 }
 
-function addOthersTooltipLines (doughnutData: any, maxValueToDisplay: number, tooltip: HTMLDivElement) {
-const startIndex = maxValueToDisplay - 1;
-doughnutData.data.slice(startIndex).forEach((_ignore: any, index: number) => {
+function addOthersTooltipLines(
+  doughnutData: any,
+  maxValueToDisplay: number,
+  tooltip: HTMLDivElement
+) {
+  const startIndex = maxValueToDisplay - 1;
+  doughnutData.data.slice(startIndex).forEach((_ignore: any, index: number) => {
     const dataIndex = startIndex + index;
     const textWrapper = document.createElement('div');
     textWrapper.style.display = 'flex';
@@ -141,65 +216,103 @@ doughnutData.data.slice(startIndex).forEach((_ignore: any, index: number) => {
     const label = document.createElement('span');
     label.appendChild(document.createTextNode(doughnutData.labels[dataIndex]));
     const value = document.createElement('span');
-    value.appendChild(document.createTextNode(formatValueAndRate(doughnutData, dataIndex)));
+    value.appendChild(
+      document.createTextNode(formatValueAndRate(doughnutData, dataIndex))
+    );
     textWrapper.appendChild(label);
     textWrapper.appendChild(value);
     tooltip.appendChild(textWrapper);
-  }
-);
+  });
 }
 
-export function createLegendElementWithPatterns
-(item: ChartItem, chart: Chart, onHoverIndex: any | null, disableAccessibility: boolean, patternsColors: string[], patternsList: ((hover: boolean, color: string, disableAccessibility: boolean) => CanvasPattern)[])
-  : HTMLElement {
-    const isDoughnut: boolean = chart.config.type === 'doughnut';
-    const index: number = isDoughnut ? item.index : item.datasetIndex;
-    const img: HTMLImageElement = new Image();
-    const boxSpan: HTMLElement = createHtmlLegendLine(item, chart.config.type);
-    const pattern: CanvasPattern = patternsList[index](false, patternsColors[index], disableAccessibility);
-    const patternCanvas: HTMLCanvasElement = getPatternCanvas(pattern);
-    img.src = patternCanvas.toDataURL();
-    boxSpan.style.background = `url(${img.src})`;
-    boxSpan.style.backgroundSize = 'cover';
-    boxSpan.style.borderColor = patternsColors[index];
-    boxSpan.style.borderWidth = '2px';
-
-    boxSpan.onmouseover = ():void => {
-      isDoughnut ? onHoverIndex.value = index : onHoverIndex.dataSetIndex = index;
+export function createLegendElementWithPatterns(
+  item: ChartItem,
+  chart: Chart,
+  onHoverIndex: any | null,
+  disableAccessibility: boolean,
+  patternsColors: string[],
+  patternsList: ((
+    hover: boolean,
+    color: string,
+    disableAccessibility: boolean
+  ) => CanvasPattern)[],
+  enableHoverFeature: boolean
+): HTMLElement {
+  const isDoughnut: boolean = chart.config.type === 'doughnut';
+  const index: number = isDoughnut ? item.index : item.datasetIndex;
+  const img: HTMLImageElement = new Image();
+  const boxSpan: HTMLElement = createHtmlLegendLine(item, chart.config.type);
+  const pattern: CanvasPattern = patternsList[index](
+    false,
+    patternsColors[index],
+    disableAccessibility
+  );
+  const patternCanvas: HTMLCanvasElement = getPatternCanvas(pattern);
+  img.src = patternCanvas.toDataURL();
+  boxSpan.style.background = `url(${img.src})`;
+  boxSpan.style.backgroundSize = 'cover';
+  boxSpan.style.borderColor = patternsColors[index];
+  boxSpan.style.borderWidth = LEGEND_BOX_BORDER;
+
+  if (enableHoverFeature) {
+    boxSpan.onmouseover = (): void => {
+      isDoughnut
+        ? (onHoverIndex.value = index)
+        : (onHoverIndex.dataSetIndex = index);
     };
     boxSpan.onmouseleave = (): void => {
-      isDoughnut ? onHoverIndex.value = null : onHoverIndex.dataSetIndex = null;
+      isDoughnut
+        ? (onHoverIndex.value = null)
+        : (onHoverIndex.dataSetIndex = -1);
     };
-    return boxSpan;
+  }
+  return boxSpan;
 }
 
-export function createLegendElementWithCheckbox
-(chart: Chart, item: ChartItem, selectMode: Ref<boolean>, onHoverIndex: any | null, disableAccessibility: boolean): HTMLElement {
+export function createLegendElementWithCheckbox(
+  chart: Chart,
+  item: ChartItem,
+  selectMode: Ref<boolean>,
+  onHoverIndex: any | null,
+  patternsColors: string[],
+  enableHoverFeature: boolean
+): HTMLElement {
   const isDoughnut: boolean = chart.config.type === 'doughnut';
   const index: number = isDoughnut ? item.index : item.datasetIndex;
-  const checkbox: HTMLElement = createLegendCheckbox(chart, item, disableAccessibility);
+  const checkbox: HTMLElement = createLegendCheckbox(
+    chart,
+    item,
+    patternsColors
+  );
   const labels = chart.config.data.labels;
-  const allCheckBoxesVisible: boolean =
-    labels.every((label: string, index: number) => chart.getDataVisibility(index));
+  const allCheckBoxesVisible: boolean = labels.every((_, index: number) =>
+    chart.getDataVisibility(index)
+  );
   if (allCheckBoxesVisible) {
     if (isDoughnut) {
-      onHoverIndex.value = -1;
       selectMode.value = false;
-    } else {
-      onHoverIndex.dataSetIndex = -1;
+      onHoverIndex.value = -1;
     }
     return checkbox;
   }
-  checkbox.onmouseover = ():void => {
-    isDoughnut ? onHoverIndex.value = index : onHoverIndex.dataSetIndex = index;
-  };
-  checkbox.onmouseleave = (): void => {
-    isDoughnut ? onHoverIndex.value = null : onHoverIndex.dataSetIndex = null;
-  };
+  if (enableHoverFeature) {
+    checkbox.onmouseover = (): void => {
+      isDoughnut
+        ? (onHoverIndex.value = index)
+        : (onHoverIndex.dataSetIndex = index);
+      chart.update();
+    };
+    checkbox.onmouseleave = (): void => {
+      isDoughnut
+        ? (onHoverIndex.value = null)
+        : (onHoverIndex.dataSetIndex = -1);
+      chart.update();
+    };
+  }
   return checkbox;
 }
 
-export function createHtmlLegendItemText (item: ChartItem) {
+export function createHtmlLegendItemText(item: ChartItem) {
   const textContainer = document.createElement('p');
   textContainer.style.color = item.fontColor;
   textContainer.style.fontSize = `${LEGEND_FONT_SIZE}px`;
@@ -211,37 +324,43 @@ export function createHtmlLegendItemText (item: ChartItem) {
   return textContainer;
 }
 
-export function createHtmlLegendLine (item: ChartItem, type: string | undefined) {
+export function createHtmlLegendLine(
+  item: ChartItem,
+  type: string | undefined
+) {
   const boxSpan = document.createElement('div');
   if (type !== 'doughnut') {
-    boxSpan.style.background = item.fillStyle;
+    boxSpan.style.background = 'rgba(0, 0, 0, 0.1)';
     boxSpan.style.borderColor = item.strokeStyle;
-    boxSpan.style.borderWidth = item.lineWidth + 'px';
+    boxSpan.style.borderWidth = LEGEND_BOX_BORDER;
   }
   boxSpan.style.borderRadius = '5px';
   boxSpan.style.borderStyle = 'solid';
   boxSpan.style.display = 'flex';
   boxSpan.style.justifyContent = 'center';
   boxSpan.style.alignItems = 'center';
-  boxSpan.style.width = LEGEND_BOX_SIZE + 'px';
+  boxSpan.style.minWidth = LEGEND_BOX_SIZE;
   boxSpan.style.marginRight = LEGEND_LABEL_LEFT_MARGIN;
-  boxSpan.style.height = LEGEND_BOX_SIZE + 'px';
+  boxSpan.style.minHeight = LEGEND_BOX_SIZE;
   return boxSpan;
 }
 
-export function createHtmlLegendDatasetSquare (item: ChartItem) {
+export function createHtmlLegendDatasetSquare(item: ChartItem) {
   const divPoint = document.createElement('div');
   divPoint.style.height = LEGEND_BOX_POINT_SIZE + 'px';
   divPoint.style.width = LEGEND_BOX_POINT_SIZE + 'px';
   divPoint.style.background = 'white';
   divPoint.style.borderStyle = 'solid';
   divPoint.style.borderColor = item.strokeStyle;
-  divPoint.style.borderWidth = item.lineWidth + 'px';
+  divPoint.style.borderWidth = LEGEND_BOX_BORDER;
   return divPoint;
 }
 
-export function createHtmlLegendListElement
-(chart: Chart, selectMode: Ref, elementIndex: number) {
+export function createHtmlLegendListElement(
+  chart: Chart,
+  selectMode: Ref,
+  elementIndex: number
+) {
   const li: HTMLElement = document.createElement('li');
   li.style.alignItems = 'center';
   li.style.cursor = selectMode.value ? '' : 'pointer';
@@ -259,39 +378,57 @@ export function createHtmlLegendListElement
   return li;
 }
 
-export function addCheckboxStyle (isDataSetVisible: boolean, item: ChartItem, checkbox: Element, disableAccessibility: boolean) {
+export function addCheckboxStyle(
+  isDataSetVisible: boolean,
+  item: ChartItem,
+  checkbox: Element,
+  patternColor: string
+) {
   let backgroundColor = '#fff';
   let borderColor = '#666';
   if (isDataSetVisible) {
-    backgroundColor = disableAccessibility? item.fillStyle : item.strokeStyle;
-    borderColor = item.strokeStyle;
+    //Default white for patterns chart
+    backgroundColor = isDefaultWhiteColor(item.strokeStyle)
+      ? patternColor
+      : item.strokeStyle;
+    borderColor = isDefaultWhiteColor(item.strokeStyle)
+      ? patternColor
+      : item.strokeStyle;
+    checkbox.setAttribute('checked', '' + isDataSetVisible);
   }
-  checkbox.setAttribute('checked', '' + isDataSetVisible);
   checkbox.setAttribute('class', 'mc-checkbox__input');
-  checkbox.setAttribute('style', `background-color: ${backgroundColor};
-    width: ${LEGEND_BOX_SIZE + 4 + 'px'};
-    height: ${LEGEND_BOX_SIZE + 4 + 'px'};
+  checkbox.setAttribute(
+    'style',
+    `background-color: ${backgroundColor};
+    min-width: ${LEGEND_BOX_SIZE};
+    min-height: ${LEGEND_BOX_SIZE};
     margin-right: ${LEGEND_LABEL_LEFT_MARGIN};
-    border-color: ${borderColor};`);
+    border-color: ${borderColor};`
+  );
 }
 
-export function createLegendCheckbox (chart: Chart, item: ChartItem, disableAccessibility: boolean = false) {
+export function createLegendCheckbox(
+  chart: Chart,
+  item: ChartItem,
+  patternsColors: string[]
+) {
   const isDoughnut: boolean = chart.config.type === 'doughnut';
   const index: number = isDoughnut ? item.index : item.datasetIndex;
   const checkbox = document.createElement('input');
   checkbox.setAttribute('type', 'checkbox');
   checkbox.setAttribute('data-test-id', `legend-checkbox-${index}`);
-  const isDataSetVisible = isDoughnut ? chart.getDataVisibility(index) :  chart.isDatasetVisible(index);
-  addCheckboxStyle(isDataSetVisible, item, checkbox, disableAccessibility);
+  const isDataSetVisible = isChartDataVisible(chart, index);
+  const patternColor = patternsColors ? patternsColors[index] : undefined;
+  addCheckboxStyle(isDataSetVisible, item, checkbox, patternColor as string);
   return checkbox;
 }
 
-function isMonoDataSetChart (chart: Chart) {
+function isMonoDataSetChart(chart: Chart) {
   const { type } = chart.config;
   return type === 'pie' || type === 'doughnut';
 }
 
-function getChartsData (chart: any) {
+function getChartsData(chart: any) {
   let dataSets: unknown[] = chart.config.data.datasets;
   if (isMonoDataSetChart(chart)) {
     dataSets = chart.config.data.datasets[0].data;
@@ -299,7 +436,11 @@ function getChartsData (chart: any) {
   return dataSets;
 }
 
-export function hideAllButThis (chart: Chart, elementIndex: number, selectMode: Ref) {
+export function hideAllButThis(
+  chart: Chart,
+  elementIndex: number,
+  selectMode: Ref
+) {
   if (!selectMode.value) {
     const dataSets: unknown[] = getChartsData(chart);
     selectMode.value = true;
@@ -311,43 +452,70 @@ export function hideAllButThis (chart: Chart, elementIndex: number, selectMode:
   }
 }
 
-function allDataVisible (chart: Chart): boolean {
+function allDataVisible(chart: Chart): boolean {
   let allVisible = true;
   const chartsData: unknown[] = getChartsData(chart);
   chartsData.forEach((_data, dataIndex) => {
-    allVisible = allVisible && chart.isDatasetVisible(dataIndex);
+    allVisible = allVisible && isChartDataVisible(chart, dataIndex);
   });
   return allVisible;
 }
 
-export function switchItemVisibility (chart: Chart, elementIndex: number, selectMode?: Ref) {
+function isChartDataVisible(chart: Chart, dataIndex: number): boolean {
+  if (isMonoDataSetChart(chart)) {
+    return chart.getDataVisibility(dataIndex);
+  } else {
+    return chart.isDatasetVisible(dataIndex);
+  }
+}
+
+export function switchItemVisibility(
+  chart: Chart,
+  elementIndex: number,
+  selectMode?: Ref
+) {
   if (isMonoDataSetChart(chart)) {
     chart.toggleDataVisibility(elementIndex);
   } else {
-    chart.setDatasetVisibility(elementIndex, !chart.isDatasetVisible(elementIndex));
+    chart.setDatasetVisibility(
+      elementIndex,
+      !chart.isDatasetVisible(elementIndex)
+    );
   }
+
   if (selectMode && allDataVisible(chart)) {
     selectMode.value = false;
   }
   chart.update();
 }
 
-
-export function createLegendElementWithSquareArea (item: ChartItem, mainSerieFirstDataset?: boolean) {
+export function createLegendElementWithSquareArea(
+  item: ChartItem,
+  mainSerieFirstDataset?: boolean
+) {
   const liContent = createHtmlLegendLine(item, '');
   const divPoint = createHtmlLegendDatasetSquare(item);
   const index = item.index || item.datasetIndex;
-  if (index === 0) {
-    mainSerieFirstDataset ? divPoint.style.borderRadius = '25px' : divPoint.style.transform = 'rotate(45deg)';
+
+  divPoint.style.width = '10px';
+  divPoint.style.height = '10px';
+  if (index % 2 === 0) {
+    mainSerieFirstDataset
+      ? (divPoint.style.borderRadius = '25px')
+      : (divPoint.style.transform = 'rotate(45deg)');
   } else {
-    mainSerieFirstDataset ? divPoint.style.transform = 'rotate(45deg)' : divPoint.style.borderRadius = '25px';
+    mainSerieFirstDataset
+      ? (divPoint.style.transform = 'rotate(45deg)')
+      : (divPoint.style.borderRadius = '25px');
   }
   liContent.appendChild(divPoint);
   return liContent;
 }
 
-
-export function getOrCreateLegendList (legendContainer: Ref, flexDirection: string) {
+export function getOrCreateLegendList(
+  legendContainer: Ref,
+  flexDirection: string
+) {
   let listContainer = legendContainer.value?.querySelector('ul');
   if (!listContainer) {
     listContainer = document.createElement('ul');
@@ -359,3 +527,7 @@ export function getOrCreateLegendList (legendContainer: Ref, flexDirection: stri
   }
   return listContainer;
 }
+
+function isDefaultWhiteColor(color: string) {
+  return color === '#00000000';
+}

package/src/services/ColorFunctions.ts

@@ -1,4 +1,4 @@
 export function addAlpha(color: string, opacity: number) {
   const _opacity = Math.round(Math.min(Math.max(opacity || 1, 0), 1) * 255);
   return color + _opacity.toString(16).toUpperCase();
-}
+}