intelicoreact 2.0.7 → 2.0.9

package/dist/charts.cjs

@@ -0,0 +1,927 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/charts.ts
+var charts_exports = {};
+__export(charts_exports, {
+  Chart: () => Chart_default2,
+  PieChart: () => PieChart_default
+});
+module.exports = __toCommonJS(charts_exports);
+
+// src/Atomic/UI/Chart/Chart.tsx
+var import_chart = require("chart.js");
+var import_classnames2 = __toESM(require("classnames"), 1);
+var import_react2 = __toESM(require("react"), 1);
+var ChartComponents = __toESM(require("react-chartjs-2"), 1);
+
+// src/Functions/utils.js
+var import_react = require("react");
+var import_moment_timezone = __toESM(require("moment-timezone"), 1);
+var clone = (input) => {
+  if (input === null || typeof input !== "object") return input;
+  const data = input instanceof Array ? [] : {};
+  for (const i in input) data[i] = clone(input[i]);
+  return data;
+};
+var omitKeys = (obj = {}, keys = []) => keys.reduce((acc, key) => {
+  const { [key]: omit, ...rest } = acc;
+  return rest;
+}, obj);
+String.prototype.longerThan = function(compareWith) {
+  return this?.length > compareWith?.length;
+};
+String.prototype.lastIndexEqualsTo = function(index) {
+  return this?.length - 1 === index;
+};
+
+// src/Atomic/UI/Chart/partial/Chart.constants.js
+var CHART_TYPES = ["Bar", "Line"];
+var DEFAULT_CHART_MODEL = "emptyLayout";
+var FINTURF_ADD_GRADIENT_COLORS_POSITIVE = ["#53D1AD", "#389AA3"];
+var FINTURF_ADD_GRADIENT_COLORS_NEGATIVE = ["#FDB4DB", "#FA2E69"];
+var GRADIENTS_OBJECTS = {
+  finturf: {
+    bar: [
+      {
+        gradientTargetPropertyName: "backgroundColor",
+        colors: FINTURF_ADD_GRADIENT_COLORS_POSITIVE,
+        direction: "toBottom",
+        typeDistributionOfGradientPoints: "personalBase",
+        collorStopPoints: [0.2, 1]
+      }
+    ],
+    line: [
+      {
+        gradientTargetPropertyName: "borderColor",
+        colors: FINTURF_ADD_GRADIENT_COLORS_POSITIVE,
+        direction: "toRight"
+      },
+      {
+        gradientTargetPropertyName: "backgroundColor",
+        colors: [
+          "rgba(84, 210, 173, 0.2)",
+          "rgba(84, 210, 173, 0.1)",
+          "rgba(84, 210, 173, 0)"
+        ],
+        direction: "toBottom",
+        collorStopPoints: [0.31, 0.72, 1],
+        isAddFill: true
+      }
+    ],
+    positiveLineIcon: [
+      {
+        gradientTargetPropertyName: "borderColor",
+        colors: FINTURF_ADD_GRADIENT_COLORS_POSITIVE,
+        direction: "toRight"
+      }
+    ],
+    negativeLineIcon: [
+      {
+        gradientTargetPropertyName: "borderColor",
+        colors: FINTURF_ADD_GRADIENT_COLORS_NEGATIVE,
+        direction: "toRight"
+      }
+    ]
+  }
+};
+var FINTURF_TOOLTIP_OPTIONS = {
+  enabled: true,
+  mode: "index",
+  intersect: false,
+  padding: 8,
+  backgroundColor: "#FFFFFF",
+  titleColor: "#757F8C",
+  borderColor: "#D6D9E4",
+  titleFont: {
+    family: "Sarabun",
+    style: "normal",
+    weight: 500,
+    size: 12
+    // line-height: 18px;
+  },
+  titleAlign: "center",
+  bodyColor: "#1E1E2D",
+  bodyFont: {
+    family: "Sarabun",
+    style: "normal",
+    weight: 400,
+    size: 14
+  },
+  bodyAlign: "center",
+  caretSize: 0,
+  displayColors: false,
+  borderWidth: 1,
+  borderRadius: 6,
+  callbacks: {
+    label: (context) => context.raw || "0"
+  }
+};
+var ICON_MODELS = [
+  "lineIconLayout",
+  "finturfPositiveLineIcon",
+  "finturfNegativeLineIcon"
+];
+var COMPONENT_OPTIONS = {
+  disableDescriptionsFor: [...ICON_MODELS],
+  disableChartTypeSwitcherFor: [...ICON_MODELS, "barLayout", "lineLayout"]
+};
+
+// src/Atomic/UI/Chart/partial/ChartTypeSwitcherIcon/ChartTypeSwitcherIcon.tsx
+var import_classnames = __toESM(require("classnames"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+var RC = "chart__type-switcher-icon";
+function getIcon(type) {
+  switch (type) {
+    case "Bar":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+        "svg",
+        {
+          width: "24",
+          height: "24",
+          viewBox: "0 0 24 25",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("rect", { y: "0.5", width: "24", height: "24", rx: "4", fill: "#EAF2FF" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "path",
+              {
+                d: "M18 18V11",
+                stroke: "#1F7499",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "path",
+              {
+                d: "M12 18V6",
+                stroke: "#1F7499",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "path",
+              {
+                d: "M6 18V13",
+                stroke: "#1F7499",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          ]
+        }
+      );
+    case "Line":
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+        "svg",
+        {
+          width: "24",
+          height: "24",
+          viewBox: "0 0 24 25",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("rect", { y: "0.5", width: "24", height: "24", rx: "4", fill: "#EAF2FF" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "path",
+              {
+                d: "M21 8L15.2544 13.2668C14.1075 14.3181 12.3288 14.3014 11.1818\n            13.25V13.25C10.0349 12.1986 8.25615 12.1819 7.10919 13.2332L3 17",
+                stroke: "#1F7499",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          ]
+        }
+      );
+    default:
+      return null;
+  }
+}
+var ChartTypeSwitcherIcon = ({
+  iconType,
+  isActive,
+  className,
+  onClick
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      className: (0, import_classnames.default)(RC, { [`${RC}_active`]: isActive }, className),
+      onClick,
+      children: getIcon(iconType)
+    }
+  );
+};
+var ChartTypeSwitcherIcon_default = ChartTypeSwitcherIcon;
+
+// src/Atomic/UI/Chart/partial/datasetSetters.js
+var addDatasetsObjects = (currentData, mutation) => ({
+  ...currentData,
+  datasets: currentData.datasets?.map?.((dataset) => ({
+    ...dataset,
+    ...typeof mutation === "function" ? mutation(dataset) : mutation
+  }))
+});
+var createGradient = ({
+  ctx,
+  area,
+  colors,
+  direction,
+  correctionFactors,
+  collorStopPoints
+}) => {
+  const getStartGradient = () => {
+    switch (direction) {
+      case "toTop-toRight":
+        return ctx.createLinearGradient(
+          area.left,
+          area.bottom,
+          area.right,
+          area.top
+        );
+      case "toTop-toLeft":
+        return ctx.createLinearGradient(
+          area.right,
+          area.bottom,
+          area.left,
+          area.top
+        );
+      case "toBottom-toRight":
+        return ctx.createLinearGradient(
+          area.left,
+          area.top,
+          area.right,
+          area.bottom
+        );
+      case "toBottom-toLeft":
+        return ctx.createLinearGradient(
+          area.right,
+          area.top,
+          area.left,
+          area.bottom
+        );
+      case "toBottom":
+        return ctx.createLinearGradient(0, area.top, 0, area.bottom);
+      case "toTop":
+        return ctx.createLinearGradient(0, area.bottom, 0, area.top);
+      case "toLeft":
+        return ctx.createLinearGradient(area.right, 0, area.left, 0);
+      case "toRight":
+      default:
+        return ctx.createLinearGradient(area.left, 0, area.right, 0);
+    }
+  };
+  const getGradientWithPoints = (corection) => {
+    const newGradient = getStartGradient();
+    const staptPoint = corection ? 1 - corection : 0;
+    colors.forEach((color, idx) => {
+      const point = (() => {
+        if (idx === colors.length - 1) return 1;
+        return collorStopPoints && Array.isArray(collorStopPoints) ? staptPoint + collorStopPoints[idx] * (corection || 1) : staptPoint + 1 / colors.length * (corection || 1);
+      })();
+      newGradient.addColorStop(point.toFixed(2), color);
+    });
+    return newGradient;
+  };
+  return correctionFactors ? correctionFactors.map((corection) => getGradientWithPoints(corection)) : getGradientWithPoints();
+};
+var addGradientsObject = (currentData, gradientSettingsObj, chartInstance) => addDatasetsObjects(currentData, (dataset) => ({
+  [gradientSettingsObj.gradientTargetPropertyName]: createGradient({
+    ctx: chartInstance.ctx,
+    area: chartInstance.chartArea,
+    colors: gradientSettingsObj.colors,
+    direction: gradientSettingsObj.direction,
+    correctionFactors: gradientSettingsObj.typeDistributionOfGradientPoints === "personalBase" ? dataset.data.map(
+      (value) => value / Math.max.apply(null, dataset.data)
+    ) : null,
+    collorStopPoints: gradientSettingsObj.collorStopPoints
+  }),
+  ...gradientSettingsObj.isAddFill ? { fill: true } : {}
+}));
+var addNotLibraryAnimation = (currentData, animationObj, chartInstance) => {
+  const { type, ...restAnimationObj } = animationObj || {};
+  switch (type) {
+    case "runningColumns":
+      const runningColumnsDefaultFromValue = 25;
+      const runningColumnsDefaultToValue = 75;
+      const runningColumnsDefaultAverageValue = 50;
+      const runningColumnsDefaultColumnsDelayCoef = 50;
+      return addDatasetsObjects(currentData, (dataset) => ({
+        animations: dataset.data.map((item, idx) => ({
+          y: {
+            duration: animationObj.duration,
+            easing: animationObj.easing || "linear",
+            from: animationObj.isFixExtremeColumns && (!idx || idx === dataset.data.length - 1) ? runningColumnsDefaultAverageValue : animationObj.from || runningColumnsDefaultFromValue,
+            to: animationObj.isFixExtremeColumns && (!idx || idx === dataset.data.length - 1) ? runningColumnsDefaultAverageValue : animationObj.to || runningColumnsDefaultToValue,
+            loop: true,
+            delay: Math.random().toFixed(1) * (animationObj.columnsDelayCoef || runningColumnsDefaultColumnsDelayCoef)
+          }
+        }))
+      }));
+    default:
+      return currentData;
+  }
+};
+function changeData(currentData, iterationKey, settingsForChange, chartInstance) {
+  switch (iterationKey) {
+    case "setMaxBarThickness":
+      return addDatasetsObjects(currentData, {
+        maxBarThickness: settingsForChange
+      });
+    case "addGradientsObjects":
+      return settingsForChange.reduce(
+        (acc, gradientSettingsObj) => addGradientsObject(acc, gradientSettingsObj, chartInstance),
+        clone(currentData)
+      );
+    case "addNotLibraryAnimations":
+      return settingsForChange.reduce(
+        (acc, animationObj) => addNotLibraryAnimation(acc, animationObj, chartInstance),
+        currentData
+      );
+    default:
+      return currentData;
+  }
+}
+var datasetSetters_default = changeData;
+
+// src/Atomic/UI/Chart/partial/optionsSetters.js
+var addGradientsSettings = (currentOptions, gradientsSettings) => ({
+  ...currentOptions,
+  notLibraryOptions: {
+    ...currentOptions.notLibraryOptions,
+    changeData: {
+      ...currentOptions.notLibraryOptions?.changeData,
+      addGradientsObjects: gradientsSettings
+    }
+  }
+});
+var addTooltipOptions = (currentOptions, tooltipOptions) => ({
+  ...currentOptions,
+  options: {
+    ...currentOptions.options,
+    plugins: {
+      ...currentOptions.options.plugins,
+      tooltip: tooltipOptions
+    }
+  }
+});
+var addAdditionalOptions = (currentOptions, optionsToAdd) => {
+  const addOption = (currentOptions2, optionKey, optionData) => {
+    switch (optionKey) {
+      case "addGradientsSettings":
+        return addGradientsSettings(currentOptions2, optionData);
+      case "addTooltipOptions":
+        return addTooltipOptions(currentOptions2, optionData);
+      default:
+        return currentOptions2;
+    }
+  };
+  const iterator = Object.keys(optionsToAdd);
+  return iterator.reduce(
+    (acc, key) => addOption(acc, key, optionsToAdd[key]),
+    currentOptions
+  );
+};
+var optionsSetters_default = addAdditionalOptions;
+
+// src/Atomic/UI/Chart/partial/optionsConstructor.js
+var reactChartJsOptionsLayouts = {
+  lineIconLayout: {
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      scales: {
+        x: { display: false },
+        y: { display: false }
+      },
+      elements: {
+        point: { radius: 0 },
+        line: {
+          tension: 0.45,
+          borderJoinStyle: "round",
+          borderWidth: 2,
+          capBezierPoints: true
+        }
+      }
+    },
+    redraw: true,
+    notLibraryOptions: {
+      // Этот ключ должен быть в любой итоговой конфигурации для нормальной работы компонента именно в такой вложенности
+      // На основании этого ключа будет приниматься решение какой компонет будет использован (<Line />, <Bar /> и т.д.)
+      // => Файл Chart.js => определение ChartComponent
+      chartTypeKey: "Line",
+      setCanvasDimensions: {
+        width: "75px",
+        height: "35px"
+      }
+    }
+  },
+  lineLayout: {
+    options: {
+      responsive: true,
+      elements: {
+        point: {
+          radius: 4,
+          pointStyle: "circle",
+          backgroundColor: "#FFFFFF",
+          color: "#FFFFFF"
+        },
+        line: {
+          tension: 0.45,
+          borderJoinStyle: "round",
+          borderWidth: 2,
+          capBezierPoints: true
+        }
+      }
+    },
+    redraw: true,
+    notLibraryOptions: {
+      // Этот ключ должен быть в любой итоговой конфигурации для нормальной работы компонента именно в такой вложенности
+      // На основании этого ключа будет приниматься решение какой компонет будет использован (<Line />, <Bar /> и т.д.)
+      // => Файл Chart.js => определение ChartComponent
+      chartTypeKey: "Line"
+    }
+  },
+  barLayout: {
+    options: {
+      responsive: true,
+      elements: {
+        bar: {
+          borderRadius: 10
+        }
+      }
+    },
+    redraw: true,
+    notLibraryOptions: {
+      // Этот ключ должен быть в любой итоговой конфигурации для нормальной работы компонента именно в такой вложенности
+      // На основании этого ключа будет приниматься решение какой компонет будет использован (<Line />, <Bar /> и т.д.)
+      // => Файл Chart.js => определение ChartComponent
+      chartTypeKey: "Bar"
+    }
+  },
+  emptyLayout: {
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      scales: {
+        x: { display: false },
+        y: { display: false }
+      },
+      elements: {
+        point: { radius: 0 },
+        line: { borderWidth: 0 }
+      }
+    },
+    notLibraryOptions: {
+      // Этот ключ должен быть в любой итоговой конфигурации для нормальной работы компонента именно в такой вложенности
+      // На основании этого ключа будет приниматься решение какой компонет будет использован (<Line />, <Bar /> и т.д.)
+      // => Файл Chart.js => определение подкомпонента ChartComponent => строка const Component = ...
+      chartTypeKey: "Line"
+    }
+  }
+};
+var finturfChartLayouts = (() => {
+  return ["barLayout", "lineLayout"].reduce(
+    (acc, key) => ({
+      ...acc,
+      [key]: {
+        ...reactChartJsOptionsLayouts[key],
+        options: {
+          ...reactChartJsOptionsLayouts[key].options,
+          scales: {
+            ...reactChartJsOptionsLayouts[key].options?.scales,
+            x: {
+              ...reactChartJsOptionsLayouts[key].options?.scales?.x,
+              grid: {
+                ...reactChartJsOptionsLayouts[key].options?.scales?.x?.grid,
+                display: false,
+                offset: true
+              },
+              ticks: {
+                ...reactChartJsOptionsLayouts[key].options?.scales?.y?.ticks,
+                autoSkipPadding: 10,
+                align: "center",
+                color: "#757F8C",
+                lineHeight: 18,
+                font: {
+                  family: "Sarabun",
+                  style: "normal",
+                  weight: 400,
+                  size: 8
+                }
+                // callback: (value, index, ticks) => {
+                //   console.log(value);
+                //   console.log(index);
+                //   console.log(ticks);
+                //   console.log('***********');
+                //   return value;
+                // },
+              }
+            },
+            y: {
+              ...reactChartJsOptionsLayouts[key].options?.scales?.y,
+              min: 0,
+              // grace: '5%',
+              bounds: "data",
+              grid: {
+                ...reactChartJsOptionsLayouts[key].options?.scales?.y?.grid,
+                borderColor: "#E1E8F1",
+                color: "#E1E8F1",
+                borderDash: [5],
+                // borderDashOffset: 12,
+                drawTicks: false,
+                z: -1
+              },
+              ticks: {
+                ...reactChartJsOptionsLayouts[key].options?.scales?.y?.ticks,
+                autoSkipPadding: 10,
+                align: "center",
+                color: "#A0A4B0",
+                lineHeight: 18,
+                padding: 6,
+                font: {
+                  family: "Sarabun",
+                  style: "normal",
+                  weight: 400,
+                  size: 10
+                }
+              }
+            }
+          }
+        },
+        notLibraryOptions: {
+          ...reactChartJsOptionsLayouts[key].notLibraryOptions,
+          setCanvasDimensions: {
+            height: "194px"
+          }
+        }
+      }
+    }),
+    {}
+  );
+})();
+var finturfChartBar = {
+  ...finturfChartLayouts.barLayout,
+  options: {
+    ...finturfChartLayouts.barLayout?.options,
+    maintainAspectRatio: false,
+    elements: {
+      ...finturfChartLayouts.barLayout?.options?.elements,
+      bar: {
+        ...finturfChartLayouts.barLayout?.options?.elements?.bar,
+        borderRadius: 4
+      }
+    }
+  },
+  notLibraryOptions: {
+    ...finturfChartLayouts.barLayout?.notLibraryOptions,
+    changeData: {
+      ...finturfChartLayouts.barLayout?.notLibraryOptions?.changeData,
+      setMaxBarThickness: 16
+    }
+  }
+};
+var finturfChartLine = {
+  ...finturfChartLayouts.lineLayout,
+  options: {
+    ...finturfChartLayouts.lineLayout?.options,
+    maintainAspectRatio: false,
+    elements: {
+      ...finturfChartLayouts.lineLayout.options?.elements,
+      point: {
+        ...finturfChartLayouts.lineLayout.options?.elements?.point,
+        radius: 2,
+        borderColor: "#32A784",
+        borderWidth: 4
+      }
+    }
+  }
+};
+var finturfReactChartJsOptions = {
+  finturfChartBar: optionsSetters_default(finturfChartBar, {
+    addGradientsSettings: GRADIENTS_OBJECTS.finturf.bar,
+    addTooltipOptions: FINTURF_TOOLTIP_OPTIONS
+  }),
+  finturfLoadingModeBar: {
+    ...finturfChartBar,
+    options: {
+      ...finturfChartBar.options,
+      animations: {
+        ...finturfChartBar.options?.animations,
+        y: {
+          ...finturfChartBar.options?.animations?.y,
+          duration: 0
+        }
+      }
+    },
+    notLibraryOptions: {
+      ...finturfChartBar.notLibraryOptions,
+      changeData: {
+        ...finturfChartBar.notLibraryOptions?.changeData,
+        addNotLibraryAnimations: [
+          {
+            type: "runningColumns",
+            // duration - ms
+            duration: 600,
+            // default easing - 'linear',
+            // easing: 'easeInOutExpo',
+            // ToDo - предусмотреть 'auto' и default для from и to
+            from: 10,
+            to: 75,
+            columnsDelayCoef: 500
+          }
+        ]
+      }
+    }
+  },
+  finturfChartLine: optionsSetters_default(finturfChartLine, {
+    addGradientsSettings: GRADIENTS_OBJECTS.finturf.line,
+    addTooltipOptions: FINTURF_TOOLTIP_OPTIONS
+    // consoleCurrentData: true,
+  }),
+  finturfLoadingModeLine: {
+    ...finturfChartLine,
+    options: {
+      ...finturfChartLine.options,
+      elements: {
+        ...finturfChartLine.options?.elements,
+        point: {
+          ...finturfChartLine.options?.elements?.point,
+          radius: 4,
+          borderWidth: 1,
+          borderColor: "#E1E8F1"
+        }
+      },
+      animations: {
+        ...finturfChartLine.options?.animations,
+        y: {
+          ...finturfChartLine.options?.animations?.y,
+          duration: 0
+        }
+      }
+    },
+    notLibraryOptions: {
+      ...finturfChartLine.notLibraryOptions,
+      changeData: {
+        ...finturfChartLine.notLibraryOptions?.changeData,
+        addNotLibraryAnimations: [
+          {
+            type: "runningColumns",
+            // duration - ms
+            duration: 600,
+            // default easing - 'linear',
+            // easing: 'easeInOutExpo',
+            columnsDelayCoef: 500,
+            isFixExtremeColumns: true
+          }
+        ]
+      }
+    }
+  },
+  finturfPositiveLineIcon: optionsSetters_default(
+    reactChartJsOptionsLayouts.lineIconLayout,
+    {
+      addGradientsSettings: GRADIENTS_OBJECTS.finturf.positiveLineIcon
+    }
+  ),
+  finturfNegativeLineIcon: optionsSetters_default(
+    reactChartJsOptionsLayouts.lineIconLayout,
+    {
+      addGradientsSettings: GRADIENTS_OBJECTS.finturf.negativeLineIcon
+    }
+  )
+};
+var optionsConstructor_default = {
+  ...finturfReactChartJsOptions,
+  emptyLayout: reactChartJsOptionsLayouts.emptyLayout
+};
+
+// src/Atomic/UI/Chart/partial/utils.ts
+function getChartTypeKey(model) {
+  return optionsConstructor_default[model]?.notLibraryOptions?.chartTypeKey;
+}
+function correctModelKey(model) {
+  if (!model) return DEFAULT_CHART_MODEL;
+  const options = optionsConstructor_default[model];
+  if (!options) return DEFAULT_CHART_MODEL;
+  const chartTypeKey = getChartTypeKey(model);
+  return chartTypeKey && CHART_TYPES.includes(chartTypeKey) ? model : DEFAULT_CHART_MODEL;
+}
+function getOptions(model) {
+  const modelOptions = optionsConstructor_default[model] || optionsConstructor_default[DEFAULT_CHART_MODEL];
+  return omitKeys(modelOptions, ["notLibraryOptions"]);
+}
+function getNotLibraryOptionsOptions(model) {
+  const modelOptions = optionsConstructor_default[model] || optionsConstructor_default[DEFAULT_CHART_MODEL];
+  const { notLibraryOptions } = modelOptions || {};
+  return notLibraryOptions ? clone(notLibraryOptions) : void 0;
+}
+function prepareData(model, data, chartInstance, addToDatasets) {
+  if (!chartInstance) return data;
+  const notLibraryOptions = getNotLibraryOptionsOptions(model);
+  const iterator = notLibraryOptions?.changeData ? Object.keys(notLibraryOptions.changeData) : [];
+  const changedData = iterator.reduce(
+    (acc, dataChangeKey) => datasetSetters_default(
+      acc,
+      dataChangeKey,
+      notLibraryOptions.changeData[dataChangeKey],
+      chartInstance
+    ),
+    clone(data)
+  );
+  return addToDatasets && typeof addToDatasets === "object" && !Array.isArray(addToDatasets) ? {
+    ...changedData,
+    datasets: changedData.datasets.map((dataset) => ({
+      ...dataset,
+      ...addToDatasets
+    }))
+  } : changedData;
+}
+
+// src/Atomic/UI/Chart/Chart.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var RC2 = "chart";
+import_chart.Chart.register(
+  import_chart.CategoryScale,
+  import_chart.LinearScale,
+  import_chart.BarElement,
+  import_chart.PointElement,
+  import_chart.LineElement,
+  import_chart.Filler,
+  import_chart.Tooltip
+);
+var Chart = ({
+  className,
+  initialModel,
+  modelsForSwitch,
+  setModelExternalValue,
+  description,
+  customOptions,
+  data,
+  addToDatasets,
+  modifyOptions
+}) => {
+  const { label, value } = description || {};
+  const [model, setModel] = (0, import_react2.useState)(DEFAULT_CHART_MODEL);
+  const [localData, setLocalData] = (0, import_react2.useState)();
+  const chartRef = (0, import_react2.useRef)(null);
+  const charContainertRef = (0, import_react2.useRef)(null);
+  const options = (0, import_react2.useMemo)(
+    () => customOptions || (modifyOptions ? modifyOptions(getOptions(model)) : getOptions(model)),
+    [customOptions, model, modifyOptions?.toString?.(), data]
+  );
+  const notLibraryOptionsOptions = (0, import_react2.useMemo)(
+    () => customOptions ? customOptions?.notLibraryOptions : getNotLibraryOptionsOptions(model),
+    [customOptions, model, data]
+  );
+  const ChartComponent = (0, import_react2.useCallback)(
+    (props) => {
+      const chartType = getChartTypeKey(model);
+      const Component = ChartComponents[chartType];
+      return import_react2.default.createElement(Component, { ...props, ref: chartRef });
+    },
+    [model]
+  );
+  const isExcludeDescription = COMPONENT_OPTIONS.disableDescriptionsFor.includes(model);
+  const isExcludeChartTypeSwitcher = COMPONENT_OPTIONS.disableChartTypeSwitcherFor.includes(model);
+  (0, import_react2.useLayoutEffect)(() => {
+    if (setModelExternalValue && model !== "emptyLayout")
+      setModelExternalValue(model);
+  }, [model]);
+  (0, import_react2.useLayoutEffect)(() => {
+    const { setCanvasDimensions } = notLibraryOptionsOptions || {};
+    if (charContainertRef.current) {
+      charContainertRef.current.style.width = setCanvasDimensions?.width ?? "";
+      charContainertRef.current.style.height = setCanvasDimensions?.height ?? "";
+    }
+  }, [notLibraryOptionsOptions]);
+  (0, import_react2.useEffect)(() => {
+    setModel(correctModelKey(initialModel));
+  }, [initialModel]);
+  (0, import_react2.useEffect)(() => {
+    if (data) {
+      setLocalData(
+        prepareData(model, clone(data), chartRef.current, addToDatasets)
+      );
+    }
+  }, [model, data]);
+  if (!data || !localData) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    "div",
+    {
+      className: (0, import_classnames2.default)(
+        RC2,
+        { [`${RC2}_icon-mode`]: ICON_MODELS.includes(model) },
+        className
+      ),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+          "div",
+          {
+            className: (0, import_classnames2.default)(`${RC2}__header`, {
+              [`${RC2}__header_only-switcher`]: !description
+            }),
+            children: [
+              description && !isExcludeDescription ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: (0, import_classnames2.default)(`${RC2}__description`), children: [
+                label ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: (0, import_classnames2.default)(`${RC2}__description-title`), children: label }) : null,
+                value ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: (0, import_classnames2.default)(`${RC2}__description-value`), children: value }) : null
+              ] }) : null,
+              !isExcludeChartTypeSwitcher ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: (0, import_classnames2.default)(`${RC2}__type-switcher`), children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  ChartTypeSwitcherIcon_default,
+                  {
+                    iconType: "Bar",
+                    isActive: getChartTypeKey(model) === "Bar",
+                    onClick: () => setModel(modelsForSwitch?.[0] || "barLayout")
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  ChartTypeSwitcherIcon_default,
+                  {
+                    iconType: "Line",
+                    isActive: getChartTypeKey(model) === "Line",
+                    onClick: () => setModel(modelsForSwitch?.[1] || "lineLayout")
+                  }
+                )
+              ] }) : null
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { ref: charContainertRef, className: (0, import_classnames2.default)(`${RC2}__chart-wrapper`), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ChartComponent, { ...options, data: localData }) })
+      ]
+    }
+  );
+};
+var Chart_default = Chart;
+
+// src/Atomic/UI/Chart/index.ts
+var Chart_default2 = Chart_default;
+
+// src/Atomic/UI/PieChart/PieChart.js
+var import_react3 = __toESM(require("react"), 1);
+var import_chart2 = require("chart.js");
+var import_react_chartjs_2 = require("react-chartjs-2");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+import_chart2.Chart.register(import_chart2.ArcElement, import_chart2.Tooltip);
+var PieChart = ({
+  data,
+  cutout = "80%",
+  resultLabel,
+  resultValue = 0,
+  withLegend = false
+}) => {
+  const options = {
+    cutout,
+    plugins: {
+      legend: {
+        display: withLegend
+      }
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "pie-chart-box", style: { maxWidth: `320px` }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_chartjs_2.Pie, { data, options }),
+    Boolean(resultLabel) && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "pie-chart__result", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "pie-chart__result-value", children: [
+        resultValue,
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "pie-chart__result-percent", children: "%" }),
+        " "
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "pie-chart__result-label", children: resultLabel })
+    ] })
+  ] });
+};
+var PieChart_default = PieChart;
+//# sourceMappingURL=charts.cjs.map