@techie_doubts/tui.chart.2026 4.6.1

package/dist/esm/helpers/downloader.js

@@ -0,0 +1,287 @@
+import { isString, isUndefined, isNumber, includes, isNull, range, getFirstValidValue, } from "./utils";
+import { getCoordinateXValue, getCoordinateYValue } from "./coordinate";
+const DATA_URI_HEADERS = {
+    xls: 'data:application/vnd.ms-excel;base64,',
+    csv: 'data:text/csv;charset=utf-8,%EF%BB%BF' /* BOM for utf-8 */,
+};
+function getDownloadMethod() {
+    let method;
+    const isDownloadAttributeSupported = !isUndefined(document.createElement('a').download);
+    const isMSSaveOrOpenBlobSupported = !isUndefined(window.Blob && window.navigator.msSaveOrOpenBlob);
+    if (isMSSaveOrOpenBlobSupported) {
+        method = downloadWithMSSaveOrOpenBlob;
+    }
+    else if (isDownloadAttributeSupported) {
+        method = downloadWithAnchorElementDownloadAttribute;
+    }
+    return method;
+}
+/**
+ * Base64 string to blob
+ * original source ref: https://github.com/miguelmota/base64toblob/blob/master/base64toblob.js
+ * Licence: MIT Licence
+ */
+function base64toBlob(base64String) {
+    const contentType = base64String
+        .substr(0, base64String.indexOf(';base64,'))
+        .substr(base64String.indexOf(':') + 1);
+    const sliceSize = 1024;
+    const byteCharacters = atob(base64String.substr(base64String.indexOf(',') + 1));
+    const byteArrays = [];
+    for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+        const slice = byteCharacters.slice(offset, offset + sliceSize);
+        const byteNumbers = new Array(slice.length);
+        for (let i = 0; i < slice.length; i += 1) {
+            byteNumbers[i] = slice.charCodeAt(i);
+        }
+        byteArrays.push(new window.Uint8Array(byteNumbers));
+    }
+    try {
+        // for IE 11
+        return new Blob(byteArrays, { type: contentType });
+    }
+    catch (e) {
+        // for IE 10
+        return new Blob(byteArrays.map((byteArr) => byteArr.buffer), { type: contentType });
+    }
+}
+function isImageExtension(extension) {
+    return extension === 'jpeg' || extension === 'png';
+}
+function downloadWithMSSaveOrOpenBlob(fileName, extension, content, contentType) {
+    const blobObject = isImageExtension(extension)
+        ? base64toBlob(content)
+        : new Blob([content], { type: contentType });
+    window.navigator.msSaveOrOpenBlob(blobObject, `${fileName}.${extension}`);
+}
+function downloadWithAnchorElementDownloadAttribute(fileName, extension, content) {
+    if (content) {
+        const anchorElement = document.createElement('a');
+        anchorElement.href = content;
+        anchorElement.target = '_blank';
+        anchorElement.download = `${fileName}.${extension}`;
+        document.body.appendChild(anchorElement);
+        anchorElement.click();
+        anchorElement.remove();
+    }
+}
+function oneLineTrim(...args) {
+    const normalTag = (template, ...expressions) => template.reduce((accumulator, part, i) => accumulator + expressions[i - 1] + part);
+    return normalTag(...args).replace(/\n\s*/g, '');
+}
+function isNeedDataEncoding() {
+    const isDownloadAttributeSupported = !isUndefined(document.createElement('a').download);
+    const isMSSaveOrOpenBlobSupported = !isUndefined(window.Blob && window.navigator.msSaveOrOpenBlob);
+    return !isMSSaveOrOpenBlobSupported && isDownloadAttributeSupported;
+}
+function getBulletLongestArrayLength(arr, field) {
+    return arr.reduce((acc, cur, idx) => { var _a, _b; return (!idx || acc < ((_b = (_a = cur) === null || _a === void 0 ? void 0 : _a[field]) === null || _b === void 0 ? void 0 : _b.length) ? cur[field].length : acc); }, 0);
+}
+function makeBulletExportData({ series }) {
+    const seriesData = series.bullet.data;
+    const markerCount = getBulletLongestArrayLength(seriesData, 'markers');
+    const rangeCount = getBulletLongestArrayLength(seriesData, 'ranges');
+    const rangesHeaders = range(0, rangeCount).map((idx) => `Range ${idx + 1}`);
+    const markerHeaders = range(0, markerCount).map((idx) => `Marker ${idx + 1}`);
+    return seriesData.reduce((acc, { data, markers, name, ranges }) => {
+        const rangeDatum = rangesHeaders.map((_, index) => {
+            var _a;
+            const rangeData = (_a = ranges) === null || _a === void 0 ? void 0 : _a[index];
+            return rangeData ? `${rangeData[0]} ~ ${rangeData[1]}` : '';
+        });
+        const markerDatum = markerHeaders.map((_, index) => { var _a, _b; return _b = (_a = markers) === null || _a === void 0 ? void 0 : _a[index], (_b !== null && _b !== void 0 ? _b : ''); });
+        return [...acc, [name, (data !== null && data !== void 0 ? data : ''), ...rangeDatum, ...markerDatum]];
+    }, [['', 'Actual', ...rangesHeaders, ...markerHeaders]]);
+}
+function makeHeatmapExportData({ categories, series }) {
+    const xCategories = categories.x;
+    return series.heatmap.data.reduce((acc, { data, yCategory }) => [
+        ...acc,
+        [yCategory, ...data.map((datum) => (isNull(datum) ? '' : datum))],
+    ], [['', ...xCategories]]);
+}
+function recursiveTreemapData({ label, data, children = [] }, result) {
+    if (data) {
+        result.push([label, data]);
+    }
+    children.forEach((childrenData) => recursiveTreemapData(childrenData, result));
+    return result;
+}
+function makeTreemapExportData(exportData) {
+    const { series } = exportData;
+    const result = [['Label', 'Data']];
+    series.treemap.data.forEach((datum) => {
+        recursiveTreemapData(datum, result);
+    });
+    return result;
+}
+function makeBubbleExportData(exportData) {
+    const { series } = exportData;
+    return series.bubble.data.reduce((acc, { name, data }) => [
+        ...acc,
+        ...data.map((datum) => isNull(datum) ? [] : [name, datum.label, String(datum.x), datum.y, datum.r]),
+    ], [['Name', 'Label', 'X', 'Y', 'Radius']]);
+}
+function makeBoxPlotExportData(exportData) {
+    var _a;
+    const { series } = exportData;
+    const categories = (_a = exportData.categories, (_a !== null && _a !== void 0 ? _a : []));
+    return series.boxPlot.data.reduce((acc, { name, data, outliers }) => {
+        const values = ((data !== null && data !== void 0 ? data : [])).map((rawData, index) => {
+            var _a;
+            const outlierValue = (_a = ((outliers !== null && outliers !== void 0 ? outliers : [])).find((outlier) => outlier[0] === index)) === null || _a === void 0 ? void 0 : _a[1];
+            const value = outlierValue ? [...rawData, outlierValue] : [...rawData];
+            return value.join();
+        });
+        return [...acc, [name, ...values]];
+    }, [['', ...categories]]);
+}
+function makePieExportData(exportData) {
+    var _a;
+    const { series } = exportData;
+    const categories = (_a = exportData.categories, (_a !== null && _a !== void 0 ? _a : []));
+    return series.pie.data.reduce((acc, { name, data }) => {
+        const values = Array.isArray(data)
+            ? ((data !== null && data !== void 0 ? data : [])).reduce((accNestedPieValue, value) => {
+                var _a;
+                return [...accNestedPieValue, [value.name, (_a = value.data, (_a !== null && _a !== void 0 ? _a : ''))]];
+            }, [])
+            : [[name, (data !== null && data !== void 0 ? data : '')]];
+        return [...acc, ...values];
+    }, categories.length ? [['', ...categories]] : []);
+}
+function makeCoordinateExportDataValues(type, categories, data) {
+    return categories.map((category, index) => {
+        if (type === 'area' && Array.isArray(data[index])) {
+            return data[index].join();
+        }
+        const foundItem = data.find((value) => category === String(getCoordinateXValue(value)));
+        return foundItem ? getCoordinateYValue(foundItem) : '';
+    });
+}
+function makeExportData(exportData) {
+    const { series } = exportData;
+    const categories = exportData.categories;
+    return Object.keys(series).reduce((acc, type) => {
+        const result = series[type].data.map(({ name, data }) => {
+            const values = !isNumber(getFirstValidValue(data)) && includes(['line', 'area', 'scatter'], type)
+                ? makeCoordinateExportDataValues(type, categories, data)
+                : data.map((value) => (Array.isArray(value) ? value.join() : value));
+            return [name, ...values];
+        });
+        return [...acc, ...result];
+    }, series.gauge ? [] : [['', ...categories]]);
+}
+function get2DArrayFromRawData(exportData) {
+    let result;
+    const { series } = exportData;
+    if (series.bullet) {
+        result = makeBulletExportData(exportData);
+    }
+    else if (series.heatmap) {
+        result = makeHeatmapExportData(exportData);
+    }
+    else if (series.bubble) {
+        result = makeBubbleExportData(exportData);
+    }
+    else if (series.boxPlot) {
+        result = makeBoxPlotExportData(exportData);
+    }
+    else if (series.pie) {
+        result = makePieExportData(exportData);
+    }
+    else if (series.treemap) {
+        result = makeTreemapExportData(exportData);
+    }
+    else {
+        result = makeExportData(exportData);
+    }
+    return result;
+}
+function getTableElementStringForXLS(chartData2DArray) {
+    let tableElementString = '<table>';
+    chartData2DArray.forEach((row, rowIndex) => {
+        const cellTagName = rowIndex === 0 ? 'th' : 'td';
+        tableElementString += '<tr>';
+        row.forEach((cell, cellIndex) => {
+            const cellNumberClass = rowIndex !== 0 || cellIndex === 0 ? ' class="number"' : '';
+            const cellString = `<${cellTagName}${cellNumberClass}>${cell}</${cellTagName}>`;
+            tableElementString += cellString;
+        });
+        tableElementString += '</tr>';
+    });
+    tableElementString += '</table>';
+    return tableElementString;
+}
+function makeXLSBodyWithRawData(chartData2DArray) {
+    return oneLineTrim `<html xmlns:o="urn:schemas-microsoft-com:office:office"
+        xmlns:x="urn:schemas-microsoft-com:office:excel"
+        xmlns="http://www.w3.org/TR/REC-html40">
+        <head>
+            <!--[if gte mso 9]>
+                <xml>
+                    <x:ExcelWorkbook>
+                        <x:ExcelWorksheets>
+                            <x:ExcelWorksheet>
+                                <x:Name>Ark1</x:Name>
+                                <x:WorksheetOptions>
+                                    <x:DisplayGridlines/>
+                                </x:WorksheetOptions>
+                            </x:ExcelWorksheet>
+                        </x:ExcelWorksheets>
+                        </x:ExcelWorkbook>
+                </xml>
+            <![endif]-->
+            <meta name=ProgId content=Excel.Sheet>
+            <meta charset=UTF-8>
+        </head>
+        <body>
+            ${getTableElementStringForXLS(chartData2DArray)}
+        </body>
+        </html>`;
+}
+function makeCSVBodyWithRawData(chartData2DArray, option = {}) {
+    const { lineDelimiter = '\u000a', itemDelimiter = ',' } = option;
+    const lastRowIndex = chartData2DArray.length - 1;
+    let csvText = '';
+    chartData2DArray.forEach((row, rowIndex) => {
+        const lastCellIndex = row.length - 1;
+        row.forEach((cell, cellIndex) => {
+            const cellContent = isNumber(cell) ? cell : `"${cell}"`;
+            csvText += cellContent;
+            if (cellIndex < lastCellIndex) {
+                csvText += itemDelimiter;
+            }
+        });
+        if (rowIndex < lastRowIndex) {
+            csvText += lineDelimiter;
+        }
+    });
+    return csvText;
+}
+export function execDownload(fileName, extension, content, contentType) {
+    const downloadMethod = getDownloadMethod();
+    if (!isString(content) || !downloadMethod) {
+        return;
+    }
+    downloadMethod(fileName, extension, content, contentType);
+}
+export function downloadSpreadSheet(fileName, extension, data) {
+    const chartData2DArray = get2DArrayFromRawData(data);
+    const contentType = DATA_URI_HEADERS[extension].replace(/(data:|;base64,|,%EF%BB%BF)/g, '');
+    let content = '';
+    if (extension === 'csv') {
+        content = encodeURIComponent(makeCSVBodyWithRawData(chartData2DArray));
+    }
+    else {
+        content = makeXLSBodyWithRawData(chartData2DArray);
+    }
+    if (isNeedDataEncoding()) {
+        if (extension !== 'csv') {
+            // base64 encoding for data URI scheme.
+            content = window.btoa(unescape(encodeURIComponent(content)));
+        }
+        content = DATA_URI_HEADERS[extension] + content;
+    }
+    execDownload(fileName, extension, content, contentType);
+}

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

@@ -0,0 +1,16 @@
+import { DateOption } from "../../types/options";
+export declare const DEFAULT_DATE_FORMAT = "YY-MM-DD hh:mm:ss";
+export declare function getDateFormat(date?: DateOption): string | undefined;
+export declare function formatDate(form: string, date: Date | {
+    year: number;
+    month: number;
+    date: number;
+    hour: number;
+    minute: number;
+    second: number;
+}, option?: {
+    meridiemSet: {
+        AM?: string;
+        PM?: string;
+    };
+}): string;

package/dist/esm/helpers/formatDate.js

@@ -0,0 +1,140 @@
+// https://github.com/nhn/tui.code-snippet/blob/master/formatDate/formatDate.js
+import { isDate, isObject } from "./utils";
+export const DEFAULT_DATE_FORMAT = 'YY-MM-DD hh:mm:ss';
+export function getDateFormat(date) {
+    if (!date) {
+        return;
+    }
+    return isObject(date) ? date.format : DEFAULT_DATE_FORMAT;
+}
+const tokens = /[\\]*YYYY|[\\]*YY|[\\]*MMMM|[\\]*MMM|[\\]*MM|[\\]*M|[\\]*DD|[\\]*D|[\\]*HH|[\\]*H|[\\]*mm|[\\]*m|[\\]*ss|[\\]*s|[\\]*A/gi;
+const MONTH_STR = [
+    'Invalid month',
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'Jun',
+    'Jul',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+const MONTH_DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const replaceMap = {
+    M: (date) => Number(date.month),
+    MM: (date) => {
+        const month = date.month;
+        return Number(month) < 10 ? `0${month}` : month;
+    },
+    MMM: (date) => MONTH_STR[Number(date.month)].substr(0, 3),
+    MMMM: (date) => MONTH_STR[Number(date.month)],
+    D: (date) => Number(date.date),
+    d: (date) => replaceMap.D(date),
+    DD: (date) => {
+        const dayInMonth = date.date;
+        return Number(dayInMonth) < 10 ? `0${dayInMonth}` : dayInMonth;
+    },
+    dd: (date) => replaceMap.DD(date),
+    YY: (date) => Number(date.year) % 100,
+    yy: (date) => replaceMap.YY(date),
+    YYYY: (date) => {
+        let prefix = '20';
+        const year = date.year;
+        if (year > 69 && year < 100) {
+            prefix = '19';
+        }
+        return Number(year) < 100 ? prefix + String(year) : year;
+    },
+    yyyy: (date) => replaceMap.YYYY(date),
+    A: (date) => date.meridiem,
+    a: (date) => date.meridiem,
+    hh: (date) => {
+        const hour = date.hour;
+        return Number(hour) < 10 ? '0' + hour : hour;
+    },
+    HH: (date) => replaceMap.hh(date),
+    h: (date) => String(Number(date.hour)),
+    H: (date) => replaceMap.h(date),
+    m: (date) => String(Number(date.minute)),
+    mm: (date) => {
+        const minute = date.minute;
+        return Number(minute) < 10 ? `0${minute}` : minute;
+    },
+    s: (date) => String(Number(date.second)),
+    ss: (date) => {
+        const second = date.second;
+        return Number(second) < 10 ? `0${second}` : second;
+    },
+};
+function isLeapYear(month, year) {
+    return month === 2 && year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function isValidDate(y, m, d) {
+    const year = Number(y);
+    const month = Number(m);
+    const date = Number(d);
+    const isValidYear = (year > -1 && year < 100) || (year > 1969 && year < 2070);
+    const isValidMonth = month > 0 && month < 13;
+    if (!isValidYear || !isValidMonth) {
+        return false;
+    }
+    const lastDayInMonth = isLeapYear(month, year) ? 29 : MONTH_DAYS[month];
+    return date > 0 && date <= lastDayInMonth;
+}
+/*
+ * key             | Shorthand
+ * --------------- |-----------------------
+ * years           | YY / YYYY / yy / yyyy
+ * months(n)       | M / MM
+ * months(str)     | MMM / MMMM
+ * days            | D / DD / d / dd
+ * hours           | H / HH / h / hh
+ * minutes         | m / mm
+ * seconds         | s / ss
+ * meridiem(AM,PM) | A / a
+ */
+export function formatDate(form, date, option) {
+    var _a, _b, _c;
+    const am = (_b = (_a = option) === null || _a === void 0 ? void 0 : _a.meridiemSet.AM, (_b !== null && _b !== void 0 ? _b : 'AM'));
+    const pm = ((_c = option) === null || _c === void 0 ? void 0 : _c.meridiemSet.PM) || 'PM';
+    let nDate;
+    if (isDate(date)) {
+        nDate = {
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            date: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+        };
+    }
+    else {
+        const { year, month, hour, minute, second } = date;
+        nDate = { year, month, date: date.date, hour, minute, second };
+    }
+    if (!isValidDate(nDate.year, nDate.month, nDate.date)) {
+        return '';
+    }
+    nDate.meridiem = '';
+    if (/([^\\]|^)[aA]\b/.test(form)) {
+        if (nDate.hour > 12) {
+            // See the clock system: https://en.wikipedia.org/wiki/12-hour_clock
+            nDate.hour %= 12;
+        }
+        if (nDate.hour === 0) {
+            nDate.hour = 12;
+        }
+        nDate.meridiem = nDate.hour > 11 ? pm : am;
+    }
+    return form.replace(tokens, (key) => {
+        if (key.indexOf('\\') > -1) {
+            // escape character
+            return key.replace(/\\/, '');
+        }
+        return replaceMap[key](nDate) || '';
+    });
+}

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

@@ -0,0 +1,3 @@
+export declare const ANGLE_CANDIDATES: number[];
+export declare function calculateRotatedWidth(degree: number, width: number, height: number): number;
+export declare function calculateRotatedHeight(degree: number, width: number, height: number): number;

package/dist/esm/helpers/geometric.js

@@ -0,0 +1,35 @@
+const RAD = Math.PI / 180;
+const ANGLE_90 = 90;
+export const ANGLE_CANDIDATES = [0, 25, 45, 65, 85, 90];
+/**
+ * Calculate adjacent.
+ *
+ *   H : Hypotenuse
+ *   A : Adjacent
+ *   O : Opposite
+ *   D : Degree
+ *
+ *        /|
+ *       / |
+ *    H /  | O
+ *     /   |
+ *    /\ D |
+ *    -----
+ *       A
+ */
+function calculateAdjacent(degree, hypotenuse) {
+    return Math.cos(degree * RAD) * hypotenuse;
+}
+function calculateOpposite(degree, hypotenuse) {
+    return Math.sin(degree * RAD) * hypotenuse;
+}
+export function calculateRotatedWidth(degree, width, height) {
+    const centerHalf = calculateAdjacent(degree, width / 2);
+    const sideHalf = calculateAdjacent(ANGLE_90 - degree, height / 2);
+    return (centerHalf + sideHalf) * 2;
+}
+export function calculateRotatedHeight(degree, width, height) {
+    const centerHalf = calculateOpposite(degree, width / 2);
+    const sideHalf = calculateOpposite(ANGLE_90 - degree, height / 2);
+    return (centerHalf + sideHalf) * 2;
+}

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

@@ -0,0 +1 @@
+export declare function sendHostname(): void;

package/dist/esm/helpers/googleAnalytics.js

@@ -0,0 +1,39 @@
+const MS_7_DAYS = 7 * 24 * 60 * 60 * 1000;
+function isExpired(date) {
+    const now = new Date().getTime();
+    return now - date > MS_7_DAYS;
+}
+function imagePing(url, trackingInfo) {
+    const queryString = Object.keys(trackingInfo)
+        .map((id, index) => `${index ? '&' : ''}${id}=${trackingInfo[id]}`)
+        .join('');
+    const trackingElement = document.createElement('img');
+    trackingElement.src = `${url}?${queryString}`;
+    trackingElement.style.display = 'none';
+    document.body.appendChild(trackingElement);
+    document.body.removeChild(trackingElement);
+    return trackingElement;
+}
+export function sendHostname() {
+    const hostname = location.hostname;
+    const applicationKeyForStorage = `TOAST UI chart for ${hostname}: Statistics`;
+    const date = window.localStorage.getItem(applicationKeyForStorage);
+    if (date && !isExpired(Number(date))) {
+        return;
+    }
+    window.localStorage.setItem(applicationKeyForStorage, String(new Date().getTime()));
+    setTimeout(() => {
+        if (document.readyState === 'interactive' || document.readyState === 'complete') {
+            imagePing('https://www.google-analytics.com/collect', {
+                v: 1,
+                t: 'event',
+                tid: 'UA-129983528-2',
+                cid: hostname,
+                dp: hostname,
+                dh: 'chart',
+                el: 'chart',
+                ec: 'use',
+            });
+        }
+    }, 1000);
+}

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

@@ -0,0 +1 @@
+export declare function sanitizeHTML(html: string): string;

package/dist/esm/helpers/htmlSanitizer.js

@@ -0,0 +1,86 @@
+import { findNodes, removeNode } from "./dom";
+import { isString, toArray } from "./utils";
+const HTML_ATTR_LIST_RX = new RegExp('^(abbr|align|alt|axis|bgcolor|border|cellpadding|cellspacing|class|clear|' +
+    'color|cols|compact|coords|dir|face|headers|height|hreflang|hspace|' +
+    'ismap|lang|language|nohref|nowrap|rel|rev|rows|rules|' +
+    'scope|scrolling|shape|size|span|start|summary|tabindex|target|title|type|' +
+    'valign|value|vspace|width|checked|mathvariant|encoding|id|name|' +
+    'background|cite|href|longdesc|src|usemap|xlink:href|data-+|checked|style)', 'g');
+const SVG_ATTR_LIST_RX = new RegExp('^(accent-height|accumulate|additive|alphabetic|arabic-form|ascent|' +
+    'baseProfile|bbox|begin|by|calcMode|cap-height|class|color|color-rendering|content|' +
+    'cx|cy|d|dx|dy|descent|display|dur|end|fill|fill-rule|font-family|font-size|font-stretch|' +
+    'font-style|font-variant|font-weight|from|fx|fy|g1|g2|glyph-name|gradientUnits|hanging|' +
+    'height|horiz-adv-x|horiz-origin-x|ideographic|k|keyPoints|keySplines|keyTimes|lang|' +
+    'marker-end|marker-mid|marker-start|markerHeight|markerUnits|markerWidth|mathematical|' +
+    'max|min|offset|opacity|orient|origin|overline-position|overline-thickness|panose-1|' +
+    'path|pathLength|points|preserveAspectRatio|r|refX|refY|repeatCount|repeatDur|' +
+    'requiredExtensions|requiredFeatures|restart|rotate|rx|ry|slope|stemh|stemv|stop-color|' +
+    'stop-opacity|strikethrough-position|strikethrough-thickness|stroke|stroke-dasharray|' +
+    'stroke-dashoffset|stroke-linecap|stroke-linejoin|stroke-miterlimit|stroke-opacity|' +
+    'stroke-width|systemLanguage|target|text-anchor|to|transform|type|u1|u2|underline-position|' +
+    'underline-thickness|unicode|unicode-range|units-per-em|values|version|viewBox|visibility|' +
+    'width|widths|x|x-height|x1|x2|xlink:actuate|xlink:arcrole|xlink:role|xlink:show|xlink:title|' +
+    'xlink:type|xml:base|xml:lang|xml:space|xmlns|xmlns:xlink|y|y1|y2|zoomAndPan)', 'g');
+const DEFAULT_TAG_DENY_LIST = [
+    'script',
+    'iframe',
+    'textarea',
+    'form',
+    'button',
+    'select',
+    'input',
+    'meta',
+    'style',
+    'link',
+    'title',
+    'embed',
+    'object',
+];
+const XSS_ATTR_RX = /href|src|background/gi;
+const XSS_VALUE_RX = /((java|vb|live)script|x):/gi;
+const ON_EVENT_RX = /^on\S+/;
+export function sanitizeHTML(html) {
+    const root = document.createElement('div');
+    if (isString(html)) {
+        html = html.replace(/<!--[\s\S]*?-->/g, '');
+        root.innerHTML = html;
+    }
+    else {
+        root.appendChild(html);
+    }
+    removeUnnecessaryTags(root);
+    leaveOnlyWhitelistAttribute(root);
+    return root.innerHTML;
+}
+function removeUnnecessaryTags(html) {
+    const removedTags = findNodes(html, DEFAULT_TAG_DENY_LIST.join(','));
+    removedTags.forEach((node) => {
+        removeNode(node);
+    });
+}
+function isXSSAttribute(attrName, attrValue) {
+    return attrName.match(XSS_ATTR_RX) && attrValue.match(XSS_VALUE_RX);
+}
+function removeBlacklistAttributes(node, blacklistAttrs) {
+    blacklistAttrs.forEach(({ name }) => {
+        if (ON_EVENT_RX.test(name)) {
+            node[name] = null;
+        }
+        if (node.getAttribute(name)) {
+            node.removeAttribute(name);
+        }
+    });
+}
+function leaveOnlyWhitelistAttribute(html) {
+    findNodes(html, '*').forEach((node) => {
+        const { attributes } = node;
+        const blacklist = toArray(attributes).filter((attr) => {
+            const { name, value } = attr;
+            const htmlAttr = name.match(HTML_ATTR_LIST_RX);
+            const svgAttr = name.match(SVG_ATTR_LIST_RX);
+            const xssAttr = htmlAttr && isXSSAttribute(name, value);
+            return (!htmlAttr && !svgAttr) || xssAttr;
+        });
+        removeBlacklistAttributes(node, blacklist);
+    });
+}

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

@@ -0,0 +1,9 @@
+import { ChartType, Legend, LegendIconType, Options, RawSeries, Series } from "../../types/store/store";
+import { BubbleChartOptions, HeatmapChartOptions, TreemapChartOptions, GaugeChartOptions } from "../../types/options";
+export declare type OptionsWithNormalLegendType = Exclude<Options, TreemapChartOptions | HeatmapChartOptions | GaugeChartOptions>;
+export declare function getActiveSeriesMap(legend: Legend): {};
+export declare function showCircleLegend(options: BubbleChartOptions): boolean;
+export declare function showLegend(options: Options, series: Series | RawSeries): boolean;
+export declare function showCheckbox(options: OptionsWithNormalLegendType): boolean;
+export declare function getIconType(type: ChartType): LegendIconType;
+export declare function getLegendAlign(options: Options): import("../../types/components/axis").ArrowDirection;

package/dist/esm/helpers/legend.js

@@ -0,0 +1,47 @@
+import { includes, isUndefined } from "./utils";
+export function getActiveSeriesMap(legend) {
+    return legend.data.reduce((acc, { active, label }) => (Object.assign(Object.assign({}, acc), { [label]: active })), {});
+}
+export function showCircleLegend(options) {
+    var _a, _b, _c;
+    return _c = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.circleLegend) === null || _b === void 0 ? void 0 : _b.visible, (_c !== null && _c !== void 0 ? _c : true);
+}
+export function showLegend(options, series) {
+    var _a, _b, _c;
+    if (series.gauge ||
+        (series.treemap && !((_a = options.series) === null || _a === void 0 ? void 0 : _a.useColorValue))) {
+        return false;
+    }
+    return isUndefined((_b = options.legend) === null || _b === void 0 ? void 0 : _b.visible) ? true : !!((_c = options.legend) === null || _c === void 0 ? void 0 : _c.visible);
+}
+export function showCheckbox(options) {
+    var _a, _b;
+    return isUndefined((_a = options.legend) === null || _a === void 0 ? void 0 : _a.showCheckbox) ? true : !!((_b = options.legend) === null || _b === void 0 ? void 0 : _b.showCheckbox);
+}
+// @TODO: Need to manage with chart type constant/Enum
+function useRectIcon(type) {
+    return includes(['bar', 'column', 'area', 'pie', 'boxPlot', 'bullet', 'radialBar'], type);
+}
+function useCircleIcon(type) {
+    return includes(['bubble', 'scatter'], type);
+}
+function useLineIcon(type) {
+    return includes(['line', 'radar'], type);
+}
+export function getIconType(type) {
+    let iconType = 'spectrum';
+    if (useCircleIcon(type)) {
+        iconType = 'circle';
+    }
+    else if (useRectIcon(type)) {
+        iconType = 'rect';
+    }
+    else if (useLineIcon(type)) {
+        iconType = 'line';
+    }
+    return iconType;
+}
+export function getLegendAlign(options) {
+    var _a, _b;
+    return _b = (_a = options.legend) === null || _a === void 0 ? void 0 : _a.align, (_b !== null && _b !== void 0 ? _b : 'right');
+}