@techie_doubts/tui.chart.2026 4.6.1

package/dist/esm/helpers/tooltip.js

@@ -0,0 +1,18 @@
+import { isObject } from "./utils";
+import { isRangeValue } from "./range";
+function isBubblePointType(value) {
+    return value.hasOwnProperty('r');
+}
+export function getValueString(value) {
+    let result = '';
+    if (isRangeValue(value)) {
+        result = `${value[0]} ~ ${value[1]}`;
+    }
+    else if (isObject(value) && !Array.isArray(value)) {
+        result = `(${value.x}, ${value.y})` + (isBubblePointType(value) ? `, r: ${value.r}` : '');
+    }
+    else {
+        result = String(value);
+    }
+    return result;
+}

package/dist/esm/helpers/tooltipTemplate.d.ts

@@ -0,0 +1,21 @@
+import { TooltipModel, TooltipTemplateType } from "../../types/components/tooltip";
+import { DefaultTooltipTemplate } from "../../types/options";
+import { TooltipTheme } from "../../types/theme";
+export declare function getDefaultTemplate(model: TooltipModel, { header, body }: DefaultTooltipTemplate, theme: Required<TooltipTheme>): string;
+export declare function getHeaderTemplate({ category }: TooltipModel, theme: Required<TooltipTheme>): string;
+declare function getDefaultBodyTemplate({ data }: TooltipModel, theme: Required<TooltipTheme>): string;
+declare function getBoxPlotTemplate({ data }: TooltipModel, theme: Required<TooltipTheme>): string;
+declare function getBulletTemplate({ data }: TooltipModel, theme: Required<TooltipTheme>): string;
+declare function getPieTemplate({ data }: TooltipModel, theme: Required<TooltipTheme>): string;
+declare function getHeatmapTemplate({ data }: TooltipModel, theme: Required<TooltipTheme>): string;
+export declare const tooltipTemplates: {
+    default: typeof getDefaultTemplate;
+    defaultHeader: typeof getHeaderTemplate;
+    defaultBody: typeof getDefaultBodyTemplate;
+    boxPlot: typeof getBoxPlotTemplate;
+    bullet: typeof getBulletTemplate;
+    pie: typeof getPieTemplate;
+    heatmap: typeof getHeatmapTemplate;
+};
+export declare function getBodyTemplate(type?: TooltipTemplateType): typeof getDefaultBodyTemplate | typeof getBoxPlotTemplate | typeof getBulletTemplate | typeof getPieTemplate | typeof getHeatmapTemplate;
+export {};

package/dist/esm/helpers/tooltipTemplate.js

@@ -0,0 +1,147 @@
+import { pieTooltipLabelFormatter } from "./pieSeries";
+import { getFontStyleString } from "./style";
+import { isNumber } from "./utils";
+import { isRangeValue } from "./range";
+function getSeriesNameTemplate(label, color) {
+    return `<span class="td-chart-series-name">
+    <i class="td-chart-icon" style="background: ${color}"></i>
+    <span class="td-chart-name">${label}</span>
+  </span>`;
+}
+function getTitleValueTemplate(title, value) {
+    return `<div class="td-chart-tooltip-series">
+    <span class="td-chart-series-name">${title}</span>
+    <span class="td-chart-series-value">${value}</span>
+  </div>`;
+}
+function getColorValueTemplate(color, value) {
+    return `<div class="td-chart-tooltip-series">
+    <i class="td-chart-icon" style="background: ${color}"></i>
+    <span class="td-chart-series-value">${value}</span>
+  </div>`;
+}
+function makeBulletDataTemplate(data, titleType) {
+    return data
+        .filter(({ title }) => title === titleType)
+        .sort((a, b) => {
+        if (isRangeValue(a.value) && isRangeValue(b.value)) {
+            return a.value[0] - b.value[0];
+        }
+        if (isNumber(a.value) && isNumber(b.value)) {
+            return a.value - b.value;
+        }
+        return 0;
+    })
+        .map(({ formattedValue, color }) => getColorValueTemplate(color, formattedValue))
+        .join('');
+}
+export function getDefaultTemplate(model, { header, body }, theme) {
+    const { borderColor, borderWidth, background, borderRadius, borderStyle } = theme;
+    const style = `border: ${borderWidth}px ${borderStyle} ${borderColor};border-radius: ${borderRadius}px;background: ${background};`;
+    return `<div class="td-chart-tooltip" style="${style}">${header}${body}</div>`;
+}
+export function getHeaderTemplate({ category }, theme) {
+    return category
+        ? `<div class="td-chart-tooltip-category" style="${getFontStyleString(theme.header)}">
+        ${category}
+      </div>`
+        : '';
+}
+function getDefaultBodyTemplate({ data }, theme) {
+    return `
+    <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+      ${data
+        .map(({ label, color, formattedValue }) => `<div class="td-chart-tooltip-series">
+                ${getSeriesNameTemplate(label, color)}
+                <span class="td-chart-series-value">${formattedValue}</span>
+              </div>`)
+        .join('')}
+    </div>`;
+}
+function getBoxPlotTemplate({ data }, theme) {
+    const groupedData = data.reduce((acc, item, index) => {
+        if (!index) {
+            return item;
+        }
+        if (acc.category === item.category && acc.label === item.label) {
+            acc.value = [...acc.value, ...item.value];
+        }
+        return acc;
+    }, {});
+    return `
+    <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+      ${[groupedData]
+        .map(({ label, color, value: values }) => `<div class="td-chart-tooltip-series">
+              ${getSeriesNameTemplate(label, color)}
+            </div>
+            <div>
+          ${values
+        .map(({ title, formattedValue }) => getTitleValueTemplate(title, formattedValue))
+        .join('')}
+            </div>`)
+        .join('')}
+    </div>`;
+}
+function getBulletTemplate({ data }, theme) {
+    return data.length > 1
+        ? getBulletGroupedTemplate(data, theme)
+        : getBulletBasicTemplate(data, theme);
+}
+function getBulletBasicTemplate(data, theme) {
+    return `
+    <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+      ${data
+        .map(({ label, color, value: values }) => `<div class="td-chart-tooltip-series">${getSeriesNameTemplate(label, color)}</div>
+            ${values
+        .map(({ title, formattedValue }) => getTitleValueTemplate(title, formattedValue))
+        .join('')}`)
+        .join('')}
+    </div>`;
+}
+function getBulletGroupedTemplate(data, theme) {
+    const bulletData = data.map(({ value }) => value[0]);
+    const [actual, ranges, markers] = ['Actual', 'Range', 'Marker'].map((titleType) => makeBulletDataTemplate(bulletData, titleType));
+    return `<div class="td-chart-tooltip-category" style="${getFontStyleString(theme.header)}">
+      ${data[0].label}
+    </div>
+    <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+      ${actual ? '<div class="td-chart-tooltip-title">Actual</div>' : ''} ${actual}
+      ${ranges ? '<div class="td-chart-tooltip-title">Ranges</div>' : ''} ${ranges}
+      ${markers ? '<div class="td-chart-tooltip-title">Markers</div>' : ''} ${markers}
+    </div>`;
+}
+function getPieTemplate({ data }, theme) {
+    return `
+    <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+      ${data
+        .map(({ label, color, formattedValue, percentValue }) => `<div class="td-chart-tooltip-series">
+          ${getSeriesNameTemplate(label, color)}
+          <span class="td-chart-series-value">${pieTooltipLabelFormatter(percentValue)}&nbsp;&nbsp;(${formattedValue})</span>
+        </div>`)
+        .join('')}
+    </div>`;
+}
+function getHeatmapTemplate({ data }, theme) {
+    return `${data
+        .map(({ label, color, formattedValue }) => `<div class="td-chart-tooltip-category" style="${getFontStyleString(theme.header)}">
+          ${label}
+        </div>
+        <div class="td-chart-tooltip-series-wrapper" style="${getFontStyleString(theme.body)}">
+          <div class="td-chart-tooltip-series">
+            ${getSeriesNameTemplate(formattedValue, color)}
+          </div>
+        </div>`)
+        .join('')}`;
+}
+export const tooltipTemplates = {
+    default: getDefaultTemplate,
+    defaultHeader: getHeaderTemplate,
+    defaultBody: getDefaultBodyTemplate,
+    boxPlot: getBoxPlotTemplate,
+    bullet: getBulletTemplate,
+    pie: getPieTemplate,
+    heatmap: getHeatmapTemplate,
+};
+export function getBodyTemplate(type) {
+    return tooltipTemplates[type || 'defaultBody'];
+}

package/dist/esm/helpers/utils.d.ts

@@ -0,0 +1,42 @@
+import { ChartSizeInput } from "../../types/options";
+export declare function isExist(value: unknown): boolean;
+export declare function isDate(value: unknown): value is Date;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isNull(value: unknown): value is null;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isNumber(value: unknown): value is number;
+export declare function isString(value: unknown): value is string;
+export declare function isInteger(value: unknown): value is number;
+export declare function isObject(obj: unknown): obj is object;
+export declare function isFunction(value: unknown): value is Function;
+export declare function forEach<T extends object, K extends Extract<keyof T, string>, V extends T[K]>(obj: T, cb: (item: V, key: K) => void): void;
+export declare function forEachArray<T>(arr: Array<T> | ArrayLike<T>, iteratee: (value: T, index: number, targetArr: Array<T> | ArrayLike<T>) => boolean | void, context?: object | null): void;
+export declare function range(start: number, stop?: number, step?: number): number[];
+export declare function toArray<T>(arrayLike: ArrayLike<T>): T[];
+export declare function includes<T>(arr: T[], searchItem: T, searchIndex?: number): boolean;
+export declare function pick<T extends object, K extends keyof T>(obj: T, ...propNames: K[]): Pick<T, K>;
+export declare function omit<T extends object, K extends keyof T>(obj: T, ...propNames: K[]): Pick<T, Exclude<keyof T, K>>;
+export declare function pickProperty(target: Record<string, any>, keys: string[]): Record<string, any> | null;
+export declare function pickPropertyWithMakeup(target: Record<string, any>, args: string[]): Record<string, any>;
+export declare function debounce(fn: Function, delay?: number): (...args: any[]) => void;
+export declare function merge(target: Record<string, any>, ...args: Record<string, any>[]): Record<string, any>;
+export declare function throttle(fn: Function, interval?: number): {
+    (...args: any[]): void;
+    reset: () => void;
+};
+export declare function deepMergedCopy<T1 extends Record<string, any>, T2 extends Record<string, any>>(targetObj: T1, obj: T2): T1 & T2;
+export declare function deepCopyArray<T extends Array<any>>(items: T): T;
+export declare function deepCopy<T extends Record<string, any>>(obj: T): T;
+export declare function sortCategories(x: number | string, y: number | string): number;
+export declare function sortNumber(x: number, y: number): number;
+export declare function first<T>(items: T[]): T | undefined;
+export declare function last<T>(items: T[]): T | undefined;
+export declare function hasNegative(values?: (number | string)[]): boolean;
+export declare function sum(items: number[]): number;
+export declare function hasPositiveOnly(values: (number | string)[]): boolean;
+export declare function hasNegativeOnly(values: (number | string)[]): boolean;
+export declare function getFirstValidValue(values: any): any;
+export declare function getPercentageValue(text: string): number;
+export declare function calculateSizeWithPercentString(size: number, value: string | number): number;
+export declare function getInitialSize(size?: ChartSizeInput): number;
+export declare function isAutoValue(value?: ChartSizeInput): boolean;

package/dist/esm/helpers/utils.js

@@ -0,0 +1,268 @@
+export function isExist(value) {
+    return !isUndefined(value) && !isNull(value);
+}
+export function isDate(value) {
+    return value instanceof Date;
+}
+export function isUndefined(value) {
+    return typeof value === 'undefined';
+}
+export function isNull(value) {
+    return value === null;
+}
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+export function isNumber(value) {
+    return typeof value === 'number';
+}
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isInteger(value) {
+    return isNumber(value) && isFinite(value) && Math.floor(value) === value;
+}
+export function isObject(obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+export function isFunction(value) {
+    return typeof value === 'function';
+}
+export function forEach(obj, cb) {
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            cb(obj[key], key);
+        }
+    }
+}
+export function forEachArray(arr, iteratee, context = null) {
+    for (let index = 0, len = arr.length; index < len; index += 1) {
+        if (iteratee.call(context, arr[index], index, arr) === false) {
+            break;
+        }
+    }
+}
+export function range(start, stop, step) {
+    if (isUndefined(stop)) {
+        stop = start || 0;
+        start = 0;
+    }
+    step = step || 1;
+    const arr = [];
+    if (stop) {
+        const flag = step < 0 ? -1 : 1;
+        stop *= flag;
+        for (; start * flag < stop; start += step) {
+            arr.push(start);
+        }
+    }
+    return arr;
+}
+export function toArray(arrayLike) {
+    let arr = [];
+    try {
+        arr = Array.prototype.slice.call(arrayLike);
+    }
+    catch (e) {
+        forEachArray(arrayLike, function (value) {
+            arr.push(value);
+        });
+    }
+    return arr;
+}
+export function includes(arr, searchItem, searchIndex) {
+    if (typeof searchIndex === 'number' && arr[searchIndex] !== searchItem) {
+        return false;
+    }
+    for (const item of arr) {
+        if (item === searchItem) {
+            return true;
+        }
+    }
+    return false;
+}
+export function pick(obj, ...propNames) {
+    const resultMap = {};
+    Object.keys(obj).forEach((key) => {
+        if (includes(propNames, key)) {
+            resultMap[key] = obj[key];
+        }
+    });
+    return resultMap;
+}
+export function omit(obj, ...propNames) {
+    const resultMap = {};
+    Object.keys(obj).forEach((key) => {
+        if (!includes(propNames, key)) {
+            resultMap[key] = obj[key];
+        }
+    });
+    return resultMap;
+}
+export function pickProperty(target, keys) {
+    const { length } = keys;
+    if (length) {
+        for (let i = 0; i < length; i += 1) {
+            if (isUndefined(target) || isNull(target)) {
+                return null;
+            }
+            target = target[keys[i]];
+        }
+    }
+    return target;
+}
+export function pickPropertyWithMakeup(target, args) {
+    const { length } = args;
+    if (length) {
+        for (let i = 0; i < length; i += 1) {
+            if (isUndefined(target[args[i]])) {
+                target[args[i]] = {};
+            }
+            target = target[args[i]];
+        }
+    }
+    return target;
+}
+export function debounce(fn, delay = 0) {
+    let timer;
+    function debounced(...args) {
+        window.clearTimeout(timer);
+        timer = window.setTimeout(() => {
+            fn(...args);
+        }, delay);
+    }
+    return debounced;
+}
+export function merge(target, ...args) {
+    target = target || {};
+    args.forEach((obj) => {
+        if (!obj) {
+            return;
+        }
+        forEach(obj, (item, key) => {
+            if (Object.prototype.toString.call(item) === '[object Object]') {
+                target[key] = merge(target[key], item);
+            }
+            else {
+                target[key] = item;
+            }
+        });
+    });
+    return target;
+}
+export function throttle(fn, interval = 0) {
+    let base = null;
+    let isLeading = true;
+    const tick = function (...args) {
+        fn(...args);
+        base = null;
+    };
+    let stamp = 0;
+    const debounced = debounce(tick, interval);
+    function throttled(...args) {
+        if (isLeading) {
+            tick(...args);
+            isLeading = false;
+            return;
+        }
+        stamp = Number(new Date());
+        base = base || stamp;
+        debounced(args);
+        if (stamp - base >= interval) {
+            tick(args);
+        }
+    }
+    function reset() {
+        // eslint-disable-line require-jsdoc
+        isLeading = true;
+        base = null;
+    }
+    throttled.reset = reset;
+    return throttled;
+}
+export function deepMergedCopy(targetObj, obj) {
+    const resultObj = Object.assign({}, targetObj);
+    Object.keys(obj).forEach((prop) => {
+        if (isObject(resultObj[prop])) {
+            if (Array.isArray(obj[prop])) {
+                resultObj[prop] = deepCopyArray(obj[prop]);
+            }
+            else if (resultObj.hasOwnProperty(prop)) {
+                resultObj[prop] = deepMergedCopy(resultObj[prop], obj[prop]);
+            }
+            else {
+                resultObj[prop] = deepCopy(obj[prop]);
+            }
+        }
+        else {
+            resultObj[prop] = obj[prop];
+        }
+    });
+    return resultObj;
+}
+export function deepCopyArray(items) {
+    return items.map((item) => {
+        if (isObject(item)) {
+            return Array.isArray(item) ? deepCopyArray(item) : deepCopy(item);
+        }
+        return item;
+    });
+}
+export function deepCopy(obj) {
+    const resultObj = {};
+    const keys = Object.keys(obj);
+    if (!keys.length) {
+        return obj;
+    }
+    keys.forEach((prop) => {
+        if (isObject(obj[prop])) {
+            resultObj[prop] = Array.isArray(obj[prop]) ? deepCopyArray(obj[prop]) : deepCopy(obj[prop]);
+        }
+        else {
+            resultObj[prop] = obj[prop];
+        }
+    });
+    return resultObj;
+}
+export function sortCategories(x, y) {
+    return isInteger(x) ? Number(x) - Number(y) : new Date(x).getTime() - new Date(y).getTime();
+}
+export function sortNumber(x, y) {
+    return x - y;
+}
+export function first(items) {
+    // eslint-disable-next-line no-undefined
+    return items.length ? items[0] : undefined;
+}
+export function last(items) {
+    // eslint-disable-next-line no-undefined
+    return items.length ? items[items.length - 1] : undefined;
+}
+export function hasNegative(values = []) {
+    return values.some((value) => Number(value) < 0);
+}
+export function sum(items) {
+    return items.reduce((a, b) => a + b, 0);
+}
+export function hasPositiveOnly(values) {
+    return values.every((value) => Number(value) >= 0);
+}
+export function hasNegativeOnly(values) {
+    return values.every((value) => Number(value) <= 0);
+}
+export function getFirstValidValue(values) {
+    var _a;
+    return (_a = values) === null || _a === void 0 ? void 0 : _a.find((value) => value !== null);
+}
+export function getPercentageValue(text) {
+    return Number(text.substr(0, text.length - 1));
+}
+export function calculateSizeWithPercentString(size, value) {
+    return isNumber(value) ? value : Number(((size * getPercentageValue(value)) / 100).toFixed(2));
+}
+export function getInitialSize(size) {
+    return isNumber(size) ? size : 0;
+}
+export function isAutoValue(value) {
+    return value === 'auto';
+}

package/dist/esm/helpers/validation.d.ts

@@ -0,0 +1,6 @@
+import { SelectSeriesInfo } from "../../types/charts";
+import { BoxTypeEventDetectType, LineTypeEventDetectType } from "../../types/options";
+import { Series } from "../../types/store/store";
+export declare function isAvailableShowTooltipInfo(info: SelectSeriesInfo, eventDetectType: LineTypeEventDetectType | BoxTypeEventDetectType, targetChartType: 'area' | 'line' | 'column' | 'radialBar'): boolean;
+export declare function isAvailableSelectSeries(info: SelectSeriesInfo, targetChartType: 'area' | 'line' | 'column' | 'scatter'): boolean;
+export declare function isNoData(series: Series): boolean;

package/dist/esm/helpers/validation.js

@@ -0,0 +1,16 @@
+import { isNumber, isUndefined } from "./utils";
+export function isAvailableShowTooltipInfo(info, eventDetectType, targetChartType) {
+    const { index, seriesIndex, chartType } = info;
+    return (isNumber(index) &&
+        (eventDetectType === 'grouped' || isNumber(seriesIndex)) &&
+        (isUndefined(chartType) || chartType === targetChartType));
+}
+export function isAvailableSelectSeries(info, targetChartType) {
+    const { index, seriesIndex, chartType } = info;
+    return (isNumber(index) &&
+        isNumber(seriesIndex) &&
+        (isUndefined(chartType) || chartType === targetChartType));
+}
+export function isNoData(series) {
+    return Object.keys(series).reduce((acc, chartType) => !series[chartType].data.length && acc, true);
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,40 @@
+import LineChart from "./charts/lineChart";
+import PieChart from "./charts/pieChart";
+import HeatmapChart from "./charts/heatmapChart";
+import AreaChart from "./charts/areaChart";
+import LineScatterChart from "./charts/lineScatterChart";
+import LineAreaChart from "./charts/lineAreaChart";
+import BarChart from "./charts/barChart";
+import ColumnChart from "./charts/columnChart";
+import ColumnLineChart from "./charts/columnLineChart";
+import BubbleChart from "./charts/bubbleChart";
+import ScatterChart from "./charts/scatterChart";
+import BulletChart from "./charts/bulletChart";
+import NestedPieChart from "./charts/nestedPieChart";
+import RadarChart from "./charts/radarChart";
+import TreemapChart from "./charts/treemapChart";
+import BoxPlotChart from "./charts/boxPlotChart";
+import RadialBarChart from "./charts/radialBarChart";
+import GaugeChart from "./charts/gaugeChart";
+import { LineChartProps, PieChartProps, HeatmapChartProps, AreaChartProps, LineScatterChartProps, LineAreaChartProps, BulletChartProps, NestedPieChartProps, RadarChartProps, RadialBarChartProps, BarChartProps, BoxPlotChartProps, ColumnLineChartProps, BubbleChartProps, TreemapChartProps, ScatterChartProps, ColumnChartProps, GaugeChartProps } from "../types/charts";
+export default class Chart {
+    static lineChart: (props: LineChartProps) => LineChart;
+    static areaChart: (props: AreaChartProps) => AreaChart;
+    static barChart: (props: BarChartProps) => BarChart;
+    static boxPlotChart: (props: BoxPlotChartProps) => BoxPlotChart;
+    static columnChart: (props: ColumnChartProps) => ColumnChart;
+    static pieChart: (props: PieChartProps) => PieChart;
+    static heatmapChart: (props: HeatmapChartProps) => HeatmapChart;
+    static bubbleChart: (props: BubbleChartProps) => BubbleChart;
+    static scatterChart: (props: ScatterChartProps) => ScatterChart;
+    static bulletChart: (props: BulletChartProps) => BulletChart;
+    static radarChart: (props: RadarChartProps) => RadarChart;
+    static treemapChart: (props: TreemapChartProps) => TreemapChart;
+    static nestedPieChart: (props: NestedPieChartProps) => NestedPieChart;
+    static lineAreaChart: (props: LineAreaChartProps) => LineAreaChart;
+    static lineScatterChart: (props: LineScatterChartProps) => LineScatterChart;
+    static columnLineChart: (props: ColumnLineChartProps) => ColumnLineChart;
+    static radialBarChart: (props: RadialBarChartProps) => RadialBarChart;
+    static gaugeChart: (props: GaugeChartProps) => GaugeChart;
+}
+export { LineChart, AreaChart, BarChart, ColumnChart, PieChart, HeatmapChart, BubbleChart, ScatterChart, BulletChart, RadarChart, TreemapChart, NestedPieChart, LineAreaChart, LineScatterChart, ColumnLineChart, BoxPlotChart, RadialBarChart, GaugeChart, };

package/dist/esm/index.js

@@ -0,0 +1,75 @@
+import LineChart from "./charts/lineChart";
+import PieChart from "./charts/pieChart";
+import HeatmapChart from "./charts/heatmapChart";
+import AreaChart from "./charts/areaChart";
+import LineScatterChart from "./charts/lineScatterChart";
+import LineAreaChart from "./charts/lineAreaChart";
+import BarChart from "./charts/barChart";
+import ColumnChart from "./charts/columnChart";
+import ColumnLineChart from "./charts/columnLineChart";
+import BubbleChart from "./charts/bubbleChart";
+import ScatterChart from "./charts/scatterChart";
+import BulletChart from "./charts/bulletChart";
+import NestedPieChart from "./charts/nestedPieChart";
+import RadarChart from "./charts/radarChart";
+import TreemapChart from "./charts/treemapChart";
+import BoxPlotChart from "./charts/boxPlotChart";
+import RadialBarChart from "./charts/radialBarChart";
+import GaugeChart from "./charts/gaugeChart";
+export default class Chart {
+}
+Chart.lineChart = (props) => {
+    return new LineChart(props);
+};
+Chart.areaChart = (props) => {
+    return new AreaChart(props);
+};
+Chart.barChart = (props) => {
+    return new BarChart(props);
+};
+Chart.boxPlotChart = (props) => {
+    return new BoxPlotChart(props);
+};
+Chart.columnChart = (props) => {
+    return new ColumnChart(props);
+};
+Chart.pieChart = (props) => {
+    return new PieChart(props);
+};
+Chart.heatmapChart = (props) => {
+    return new HeatmapChart(props);
+};
+Chart.bubbleChart = (props) => {
+    return new BubbleChart(props);
+};
+Chart.scatterChart = (props) => {
+    return new ScatterChart(props);
+};
+Chart.bulletChart = (props) => {
+    return new BulletChart(props);
+};
+Chart.radarChart = (props) => {
+    return new RadarChart(props);
+};
+Chart.treemapChart = (props) => {
+    return new TreemapChart(props);
+};
+Chart.nestedPieChart = (props) => {
+    return new NestedPieChart(props);
+};
+Chart.lineAreaChart = (props) => {
+    return new LineAreaChart(props);
+};
+Chart.lineScatterChart = (props) => {
+    return new LineScatterChart(props);
+};
+Chart.columnLineChart = (props) => {
+    return new ColumnLineChart(props);
+};
+Chart.radialBarChart = (props) => {
+    return new RadialBarChart(props);
+};
+Chart.gaugeChart = (props) => {
+    return new GaugeChart(props);
+};
+export { LineChart, AreaChart, BarChart, ColumnChart, PieChart, HeatmapChart, BubbleChart, ScatterChart, BulletChart, RadarChart, TreemapChart, NestedPieChart, LineAreaChart, LineScatterChart, ColumnLineChart, BoxPlotChart, RadialBarChart, GaugeChart, };

package/dist/esm/message.d.ts

@@ -0,0 +1,11 @@
+export declare const message: {
+    SELECT_SERIES_API_SELECTABLE_ERROR: string;
+    SELECT_SERIES_API_INDEX_ERROR: string;
+    ALREADY_OBSERVABLE_ERROR: string;
+    CIRCLE_LEGEND_RENDER_ERROR: string;
+    noDataError: (chartName: string) => string;
+    noBrushError: (brushName: string) => string;
+    DASH_SEGMENTS_UNAVAILABLE_ERROR: string;
+    SERIES_INDEX_ERROR: string;
+    AUTO_LAYOUT_CONTAINER_SIZE_ERROR: string;
+};

package/dist/esm/message.js

@@ -0,0 +1,11 @@
+export const message = {
+    SELECT_SERIES_API_SELECTABLE_ERROR: 'It works only when the selectable option is true.',
+    SELECT_SERIES_API_INDEX_ERROR: 'The index value is invalid.',
+    ALREADY_OBSERVABLE_ERROR: 'Source object is observable already',
+    CIRCLE_LEGEND_RENDER_ERROR: 'circleLegend is only possible when bubble series is present',
+    noDataError: (chartName) => `There's no ${chartName} data!`,
+    noBrushError: (brushName) => `Brush don't exist in painter: ${brushName}`,
+    DASH_SEGMENTS_UNAVAILABLE_ERROR: 'DashSegments option is available from IE11 and above.',
+    SERIES_INDEX_ERROR: 'The seriesIndex value is invalid',
+    AUTO_LAYOUT_CONTAINER_SIZE_ERROR: 'To use auto layout, the width or height of the container must be specified as a value such as "%" or "vh", "vw".',
+};