plmt-constructor-sdk 0.13.2

package/__internal__/config.d.ts

@@ -0,0 +1,53 @@
+import { Text, DataQueryMethod, DataQueryFunction } from '../config';
+import { ColumnType } from '../data';
+import { DatasetColumnType_Server } from './dataset';
+export declare enum ConfigDataBlockType_Server {
+    Column = "column",
+    Filter = "filter",
+    Sort = "sort",
+    Colorizer = "colorizer",
+    Drilldown = "drilldown"
+}
+export interface Config_Server {
+    label: Text;
+    icon: string;
+    data_options: ConfigDataOption_Server[];
+    doc: {
+        info: string;
+        assets: string;
+        images: string[];
+    };
+    sdk_version: string;
+    version: string;
+}
+export interface ConfigDataOption_Server {
+    key: string;
+    method: DataQueryMethod;
+    label?: Text;
+    min?: number;
+    max?: number;
+    validation?: {
+        required_some?: string[];
+        required_every?: string[];
+    };
+    blocks: ConfigDataOptionBlock_Server[];
+}
+export interface ConfigDataOptionBlock_Server {
+    type: ConfigDataBlockType_Server;
+    key: string;
+    label: Text;
+    icon?: string;
+    data_type?: DatasetColumnType_Server;
+    field_type?: ColumnType;
+    max?: number;
+    function?: DataQueryFunction;
+}
+export declare const configDataBlock_Server = "8316067a-d04b-4b21-bd4d-35529846617b";
+export declare const blockFilterKey = "34642664-dbd1-4e35-b0ea-2eaabe796b48";
+export declare const blockSortKey = "2c849ed6-6105-4aa2-a961-9f95135dfe3b";
+export declare const blockColorizeKey = "badd51f7-82ce-45b2-a67e-37d52df88c5c";
+export declare function decodeDrilldownData(source: string, additionalFilterSources: string[]): string;
+export declare function encodeDrilldownData(key: string): {
+    source: string;
+    additionalFilterSources: string[];
+};

package/__internal__/config.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeDrilldownData = exports.decodeDrilldownData = exports.blockColorizeKey = exports.blockSortKey = exports.blockFilterKey = exports.configDataBlock_Server = exports.ConfigDataBlockType_Server = void 0;
+// enums
+var ConfigDataBlockType_Server;
+(function (ConfigDataBlockType_Server) {
+    ConfigDataBlockType_Server["Column"] = "column";
+    ConfigDataBlockType_Server["Filter"] = "filter";
+    ConfigDataBlockType_Server["Sort"] = "sort";
+    ConfigDataBlockType_Server["Colorizer"] = "colorizer";
+    ConfigDataBlockType_Server["Drilldown"] = "drilldown";
+})(ConfigDataBlockType_Server = exports.ConfigDataBlockType_Server || (exports.ConfigDataBlockType_Server = {}));
+exports.configDataBlock_Server = '8316067a-d04b-4b21-bd4d-35529846617b';
+exports.blockFilterKey = '34642664-dbd1-4e35-b0ea-2eaabe796b48';
+exports.blockSortKey = '2c849ed6-6105-4aa2-a961-9f95135dfe3b';
+exports.blockColorizeKey = 'badd51f7-82ce-45b2-a67e-37d52df88c5c';
+function decodeDrilldownData(source, additionalFilterSources) {
+    const keyParts = [length(source.length), source];
+    additionalFilterSources.forEach((item) => keyParts.push(length(item.length), item));
+    return keyParts.join('');
+    function length(value) {
+        if (value > 0xff)
+            throw new RangeError();
+        return value > 0xf
+            ? `0x${value.toString(16)}`
+            : `0x0${value.toString(16)}`;
+    }
+}
+exports.decodeDrilldownData = decodeDrilldownData;
+function encodeDrilldownData(key) {
+    const parts = [];
+    parse();
+    const [source, ...additionalFilterSources] = parts;
+    return {
+        source,
+        additionalFilterSources,
+    };
+    function parse(offset = 0) {
+        const start = offset + 4;
+        const end = start + parseInt(key.slice(offset, start));
+        parts.push(key.slice(start, end));
+        if (end < key.length)
+            parse(end);
+    }
+}
+exports.encodeDrilldownData = encodeDrilldownData;

package/__internal__/dataset.d.ts

@@ -0,0 +1,19 @@
+import { ColumnType } from '../data';
+export { ColumnType as ColumnFieldType_Server } from '../data';
+export declare enum DatasetColumnType_Server {
+    Dimension = "dimension",
+    Fact = "fact",
+    Any = "any"
+}
+export interface Dataset_Server {
+    id: number;
+    name: string;
+    columns_id: Column_Server[];
+}
+export interface Column_Server {
+    id: number;
+    name: string;
+    path: string;
+    base_type: ColumnType;
+    data_type?: DatasetColumnType_Server;
+}

package/__internal__/dataset.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetColumnType_Server = exports.ColumnFieldType_Server = void 0;
+// enums
+var data_1 = require("../data");
+Object.defineProperty(exports, "ColumnFieldType_Server", { enumerable: true, get: function () { return data_1.ColumnType; } });
+var DatasetColumnType_Server;
+(function (DatasetColumnType_Server) {
+    DatasetColumnType_Server["Dimension"] = "dimension";
+    DatasetColumnType_Server["Fact"] = "fact";
+    DatasetColumnType_Server["Any"] = "any";
+})(DatasetColumnType_Server = exports.DatasetColumnType_Server || (exports.DatasetColumnType_Server = {}));

package/__internal__/theme.d.ts

@@ -0,0 +1,13 @@
+import { Theme } from '../theme';
+export interface ThemeProvide {
+    theme: Theme;
+    themeKey: string;
+    themeProjectKey: string;
+}
+export declare type ThemeKey = keyof Pick<Theme, 'background' | 'backgroundBright' | 'backgroundTint' | 'text' | 'textTint'>;
+export declare type ThemeProjectKey = keyof Pick<Theme, 'colors'>;
+export declare const themeKeys: ThemeKey[];
+export declare const themeProjectKeys: ThemeProjectKey[];
+export declare function provideCssVariables({ theme, themeKey, themeProjectKey, }: ThemeProvide): void;
+export declare function colorizeClassName(i: number, j: number): string;
+export declare function createColorizeColors(source: string[]): string[][];

package/__internal__/theme.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createColorizeColors = exports.colorizeClassName = exports.provideCssVariables = exports.themeProjectKeys = exports.themeKeys = void 0;
+const logical_not_1 = require("logical-not");
+exports.themeKeys = [
+    'background',
+    'backgroundBright',
+    'backgroundTint',
+    'text',
+    'textTint',
+];
+exports.themeProjectKeys = ['colors'];
+const head = document.querySelector('head');
+const body = document.querySelector('body');
+const providedCssVariablesMap = {};
+let prevThemeClassName = '';
+let prevThemeProjectClassName = '';
+function provideCssVariables({ theme, themeKey, themeProjectKey, }) {
+    const themeClassName = `ptnl-theme-${kebabCase(themeKey)}`;
+    if ((0, logical_not_1.not)(themeClassName in providedCssVariablesMap)) {
+        const cssVariables = [];
+        Object.entries(theme).forEach(([key, source]) => {
+            if (exports.themeKeys.includes(key)) {
+                const name = kebabCase(key);
+                if (Array.isArray(source))
+                    source.forEach((value, i) => cssVariables.push({
+                        name: `--${name}-${i}`,
+                        value,
+                    }));
+                else
+                    cssVariables.push({ name: `--${name}`, value: source });
+            }
+        });
+        addStyles(themeClassName, [
+            { className: themeClassName, cssProperties: cssVariables },
+        ]);
+    }
+    prevThemeClassName = switchClassName(prevThemeClassName, themeClassName);
+    const themeProjectClassName = `ptnl-project-${themeProjectKey}`;
+    if ((0, logical_not_1.not)(themeProjectClassName in providedCssVariablesMap)) {
+        const cssVariables = theme.colors.map((value, i) => ({
+            name: `--ptnl-color-${i}`,
+            value,
+        }));
+        addStyles(themeProjectClassName, [
+            { className: themeProjectClassName, cssProperties: cssVariables },
+        ]);
+    }
+    prevThemeProjectClassName = switchClassName(prevThemeProjectClassName, themeProjectClassName);
+    if ((0, logical_not_1.not)('colorize' in providedCssVariablesMap)) {
+        const items = [];
+        theme.colorize.forEach((colors, i) => {
+            colors.forEach((value, j) => items.push({
+                className: colorizeClassName(i, j),
+                cssProperties: [
+                    {
+                        name: 'background-color',
+                        value,
+                    },
+                ],
+            }));
+        });
+        addStyles(`colorize`, items);
+    }
+}
+exports.provideCssVariables = provideCssVariables;
+function colorizeClassName(i, j) {
+    return `ptnl-colorize-${i}-${j}`;
+}
+exports.colorizeClassName = colorizeClassName;
+const range10 = [...Array(10)].map((_, i) => i);
+function createColorizeColors(source) {
+    return source.map((color) => {
+        const [r, g, b] = parseColor(color);
+        return range10.map((i) => `rgba(${r},${g},${b},${++i > 9 ? '1' : `0.${i}`})`);
+    });
+}
+exports.createColorizeColors = createColorizeColors;
+const color6hex = /([0-9abcdef]{2})([0-9abcdef]{2})([0-9abcdef]{2})/i;
+const color3hex = /([0-9abcdef])([0-9abcdef])([0-9abcdef])/i;
+function parseColor(source) {
+    const [, r, g, b] = source.match(color6hex) ||
+        source.match(color3hex) || [, '0', '0', '0'];
+    return [parseInt(r, 16), parseInt(g, 16), parseInt(b, 16)];
+}
+function addStyles(name, items) {
+    const style = document.createElement('style');
+    providedCssVariablesMap[name] = style;
+    const styleParts = [];
+    items.forEach(({ className, cssProperties }) => {
+        styleParts.push('.', className, '{\n');
+        cssProperties.forEach(({ name, value }) => styleParts.push('  ', name, ': ', value, ';\n'));
+        styleParts.push('}\n');
+    });
+    style.innerHTML = styleParts.join('');
+    head.append(style);
+}
+function switchClassName(prev, next) {
+    if (prev)
+        body.classList.remove(prev);
+    body.classList.add(next);
+    return next;
+}
+function kebabCase(source) {
+    const chars = Array(source.length);
+    for (let i = 0, lim = source.length; i < lim; i++) {
+        const char = source.charAt(i);
+        const lowerCaseChar = char.toLowerCase();
+        chars[i] = char === lowerCaseChar ? char : '-' + lowerCaseChar;
+    }
+    return chars.join('');
+}

package/__internal__/view-settings.d.ts

@@ -0,0 +1,24 @@
+import { Text, ViewSettingsItem } from '../config';
+export declare enum ViewSettingsItemType {
+    Input = "text",
+    Checkbox = "checkbox",
+    Radio = "radio",
+    Select = "select",
+    ColorPicker = "color-picker",
+    Title = "title",
+    TextArea = "textArea"
+}
+export interface ViewSettingsItemValue {
+    type: ViewSettingsItemType;
+    key: string;
+    label: Text;
+    defaultValue?: any;
+    options?: {
+        label: Text;
+        value: string;
+    }[];
+    span?: number;
+}
+export declare const viewSettingsItemValue = "418d9556-a046-4623-be0b-4f4f69ccb783";
+export declare function viewSettingsExtract(viewSettings: ViewSettingsItem[]): ViewSettingsItemValue[];
+export declare function valueConversion(type: ViewSettingsItemType, source: any): any;

package/__internal__/view-settings.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueConversion = exports.viewSettingsExtract = exports.viewSettingsItemValue = exports.ViewSettingsItemType = void 0;
+var ViewSettingsItemType;
+(function (ViewSettingsItemType) {
+    ViewSettingsItemType["Input"] = "text";
+    ViewSettingsItemType["Checkbox"] = "checkbox";
+    ViewSettingsItemType["Radio"] = "radio";
+    ViewSettingsItemType["Select"] = "select";
+    ViewSettingsItemType["ColorPicker"] = "color-picker";
+    ViewSettingsItemType["Title"] = "title";
+    ViewSettingsItemType["TextArea"] = "textArea";
+})(ViewSettingsItemType = exports.ViewSettingsItemType || (exports.ViewSettingsItemType = {}));
+exports.viewSettingsItemValue = '418d9556-a046-4623-be0b-4f4f69ccb783';
+function viewSettingsExtract(viewSettings) {
+    return viewSettings
+        .map((item) => item[exports.viewSettingsItemValue])
+        .map((item) => ({
+        type: item.type,
+        key: item.key,
+        label: item.label,
+        defaultValue: valueConversion(item.type, item.defaultValue),
+        options: item.options || [],
+        span: getSpan(item.span),
+    }));
+}
+exports.viewSettingsExtract = viewSettingsExtract;
+function valueConversion(type, source) {
+    switch (type) {
+        case ViewSettingsItemType.Input:
+        case ViewSettingsItemType.Radio:
+        case ViewSettingsItemType.Select:
+        case ViewSettingsItemType.ColorPicker:
+        case ViewSettingsItemType.TextArea:
+            return source ? String(source) : '';
+        case ViewSettingsItemType.Checkbox:
+            return Boolean(source);
+        default:
+            return '';
+    }
+}
+exports.valueConversion = valueConversion;
+function getSpan(source) {
+    source |= 0;
+    if (source > 24)
+        return 24;
+    if (source < 0)
+        return 0;
+    return source;
+}

package/__internal__/widget-io.d.ts

@@ -0,0 +1,56 @@
+import { Locale } from '../config';
+import { Filter, Sort, Target } from '../data';
+import { WidgetRenderEnv } from '../widget';
+import { ThemeProvide } from './theme';
+import { WidgetDataOptionColumn_Server, WidgetRepresent } from './widget';
+export declare enum Input {
+    Change = "ptnl.input.change",
+    ChangeLang = "ptnl.input.changeLang",
+    ChangeTheme = "ptnl.input.changeTheme",
+    ChangeOtherFilters = "ptnl.input.ChangeOtherFilters",
+    ChangeWidgetRenderEnv = "ptnl.input.changeWidgetRenderEnv"
+}
+export declare enum Output {
+    Init = "ptnl.output.init",
+    Ready = "ptnl.output.ready",
+    SetFilter = "ptnl.output.setFilter",
+    RemoveFilterAt = "ptnl.output.RemoveFilterAt",
+    SetSort = "ptnl.output.setSort",
+    RemoveSortAt = "ptnl.output.RemoveSortAt",
+    Interact = "ptnl.output.interact"
+}
+export interface InputParameter extends Record<Input, any> {
+    [Input.Change]: WidgetRepresent;
+    [Input.ChangeLang]: Locale;
+    [Input.ChangeTheme]: ThemeProvide;
+    [Input.ChangeOtherFilters]: WidgetDataOptionColumn_Server[];
+    [Input.ChangeWidgetRenderEnv]: WidgetRenderEnv;
+}
+export interface OutputParameter extends Record<Output, any> {
+    [Output.Init]: void;
+    [Output.Ready]: void;
+    [Output.SetFilter]: {
+        filter: Filter;
+        target: Target;
+        rowIndex: number;
+    };
+    [Output.RemoveFilterAt]: {
+        index: number;
+    };
+    [Output.SetSort]: {
+        sort: Sort;
+        target: Target;
+    };
+    [Output.RemoveSortAt]: {
+        index: number;
+    };
+    [Output.Interact]: {
+        dataOptionId: number;
+        dataIndex: number;
+    };
+}
+export interface OutputData {
+    token: string;
+    type: Output;
+    payload?: any;
+}

package/__internal__/widget-io.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Output = exports.Input = void 0;
+var Input;
+(function (Input) {
+    Input["Change"] = "ptnl.input.change";
+    Input["ChangeLang"] = "ptnl.input.changeLang";
+    Input["ChangeTheme"] = "ptnl.input.changeTheme";
+    Input["ChangeOtherFilters"] = "ptnl.input.ChangeOtherFilters";
+    Input["ChangeWidgetRenderEnv"] = "ptnl.input.changeWidgetRenderEnv";
+})(Input = exports.Input || (exports.Input = {}));
+var Output;
+(function (Output) {
+    Output["Init"] = "ptnl.output.init";
+    Output["Ready"] = "ptnl.output.ready";
+    Output["SetFilter"] = "ptnl.output.setFilter";
+    Output["RemoveFilterAt"] = "ptnl.output.RemoveFilterAt";
+    Output["SetSort"] = "ptnl.output.setSort";
+    Output["RemoveSortAt"] = "ptnl.output.RemoveSortAt";
+    Output["Interact"] = "ptnl.output.interact";
+})(Output = exports.Output || (exports.Output = {}));

package/__internal__/widget-provide-data.d.ts

@@ -0,0 +1,4 @@
+import { DataSettings } from '../widget';
+import { WidgetRepresent } from './widget';
+export declare type DataSettingsMethods = Pick<DataSettings, 'setFilter' | 'removeFilterAt' | 'setSort' | 'removeSortAt' | 'interact'>;
+export declare function provideDataTo(widget: any, { dataOptionsMap, viewOptions }: WidgetRepresent, dataSettingsMethods?: DataSettingsMethods): void;

package/__internal__/widget-provide-data.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideDataTo = void 0;
+const config_1 = require("./config");
+const widget_1 = require("./widget");
+const defaultDataSettingsMethods = {
+    setFilter() { },
+    removeFilterAt() { },
+    setSort() { },
+    removeSortAt() { },
+    interact() { },
+};
+function provideDataTo(widget, { dataOptionsMap, viewOptions }, dataSettingsMethods = defaultDataSettingsMethods) {
+    const widgetMultiData = {};
+    const widgetDataSettingsMap = {};
+    const formatters = window.parent['format']?.[widget.uid] || {};
+    widget.viewSettings = {};
+    Object.values(dataOptionsMap).forEach(({ data_option, rows, total }) => {
+        widgetMultiData[data_option.key] = rows;
+        const columns = data_option.dataset.columns_id.map((source) => ({
+            type: source.base_type,
+            id: source.id,
+            path: source.path,
+            format: formatters[source.path] || ((value) => value),
+            name: source.name,
+        }));
+        const columnsByBlock = {};
+        const filters = [];
+        const sort = [];
+        const colorize = [];
+        data_option.blocks.forEach((block) => {
+            if (block.block_type === config_1.ConfigDataBlockType_Server.Drilldown)
+                return;
+            switch (block.key) {
+                case config_1.blockFilterKey:
+                    block.columns.forEach(({ column_id, action, value }) => {
+                        const column = columns.find(({ id }) => column_id === id);
+                        filters.push({
+                            column,
+                            method: action,
+                            value,
+                        });
+                    });
+                    break;
+                case config_1.blockSortKey:
+                    block.columns.forEach(({ column_id, value: direction }) => {
+                        const column = columns.find(({ id }) => column_id === id);
+                        sort.push({
+                            column,
+                            direction,
+                        });
+                    });
+                    break;
+                case config_1.blockColorizeKey:
+                    block.columns.forEach(({ value }) => {
+                        const source = value;
+                        const column = columns.find(({ id }) => source.columnId === id);
+                        colorize.push((0, widget_1.createColorizeItem)(widget, column, source));
+                    });
+                    break;
+                default:
+                    columnsByBlock[block.key] = block.columns.map(({ column_id }) => {
+                        return columns.find((item) => item.id === column_id);
+                    });
+            }
+        });
+        const dataSettingsItem = {
+            columns,
+            columnsByBlock,
+            filters,
+            sort,
+            colorize,
+            total,
+            limit: data_option.limit_rows,
+            offset: data_option.offset,
+            ...{
+                ...dataSettingsMethods,
+                interact: dataSettingsMethods.interact.bind(data_option),
+            },
+            ...getDataSettingsEvents(widget, data_option.key),
+        };
+        widgetDataSettingsMap[data_option.key] = dataSettingsItem;
+    });
+    if (widget_1.widgetDefaultKey in widgetDataSettingsMap) {
+        Object.assign(widget, {
+            data: widgetMultiData[widget_1.widgetDefaultKey],
+            dataSettings: widgetDataSettingsMap[widget_1.widgetDefaultKey],
+        });
+    }
+    else {
+        Object.assign(widget, {
+            data: widgetMultiData,
+            dataSettings: widgetDataSettingsMap,
+        });
+    }
+    widget.viewSettings = {};
+    viewOptions.forEach(({ key, value }) => (widget.viewSettings[key] = value));
+}
+exports.provideDataTo = provideDataTo;
+function getDataSettingsEvents(widget, key) {
+    const dataSettings = key === widget_1.widgetDefaultKey
+        ? widget.dataSettings
+        : widget.dataSettings[key];
+    if (dataSettings)
+        return {
+            events: dataSettings.events,
+        };
+    else
+        return {
+            events: {},
+        };
+}

package/__internal__/widget.d.ts

@@ -0,0 +1,64 @@
+import { DataQueryMethod, DataQueryFunction } from '../config';
+import { Dataset_Server } from './dataset';
+import { ConfigDataBlockType_Server } from './config';
+import { ColorizeItem, Widget } from '../widget';
+import { Column, DataItem } from '../data';
+export declare const widgetDefaultKey = "ffed0a4d-4a9d-417f-b502-eb50142c6956";
+export interface Widget_Server {
+    data_options: WidgetDataOption_Server[];
+    view_options: WidgetViewOption_Server[];
+}
+export interface WidgetRepresent {
+    dataOptionsMap: DatasetMultiData_Server;
+    viewOptions: WidgetViewOption_Server[];
+}
+export interface DatasetMultiData_Server {
+    [key: string]: {
+        data_option: WidgetDataOption_Server;
+        rows: DataItem[];
+        total: number;
+    };
+}
+export interface WidgetDataOption_Server {
+    key: string;
+    id: number;
+    dataset: Dataset_Server;
+    method: DataQueryMethod;
+    limit_rows: number;
+    offset: number;
+    blocks: WidgetDataOptionBlock_Server[];
+}
+export interface WidgetDataOptionParams_Server {
+    id?: number;
+    dataset_id: number;
+    method: DataQueryMethod;
+    limit_rows?: number;
+    offset?: number;
+    key?: string;
+    blocks: WidgetDataOptionBlock_Server[];
+}
+export interface WidgetDataOptionColumn_Server {
+    column_id: number;
+    value?: any;
+    action?: string;
+}
+export interface WidgetDataOptionBlock_Server {
+    key: string;
+    block_type: ConfigDataBlockType_Server;
+    function: DataQueryFunction;
+    columns: WidgetDataOptionColumn_Server[];
+}
+export interface WidgetViewOption_Server {
+    key: string;
+    value: any;
+}
+export interface ColorizeSettings_Server {
+    columnId: number;
+    max?: number;
+    min?: number;
+    threshold?: number;
+    colorAbove?: number;
+    colorBelow?: number;
+}
+export declare function createColorizeItem(widget: Widget, column: Column, source: ColorizeSettings_Server): ColorizeItem;
+export declare function dispatchChangeOtherFilters(widget: any, source: WidgetDataOptionColumn_Server[]): void;

package/__internal__/widget.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchChangeOtherFilters = exports.createColorizeItem = exports.widgetDefaultKey = void 0;
+const data_1 = require("../data");
+exports.widgetDefaultKey = 'ffed0a4d-4a9d-417f-b502-eb50142c6956';
+function createColorizeItem(widget, column, source) {
+    const max = +source.max || 0;
+    const min = +source.min || 0;
+    const threshold = +source.threshold || 0;
+    const colorAbove = source.colorAbove;
+    const colorBelow = source.colorBelow;
+    const deltaAbove = max - threshold;
+    const deltaBelow = threshold - min;
+    return {
+        column,
+        getColor(value) {
+            value = +value || 0;
+            if (value > max || value < min)
+                return color();
+            if (value >= threshold) {
+                const colors = widget.theme.colorize[colorAbove] || [];
+                if (value === max)
+                    return color(colors[colors.length - 1]);
+                const i = Math.floor(((value - threshold) / deltaAbove) * colors.length);
+                return color(colors[i]);
+            }
+            else {
+                const colors = widget.theme.colorize[colorBelow] || [];
+                if (value === min)
+                    return color(colors[colors.length - 1]);
+                const i = Math.floor(((threshold - value) / deltaBelow) * colors.length);
+                return color(colors[i]);
+            }
+        },
+    };
+}
+exports.createColorizeItem = createColorizeItem;
+function color(source) {
+    return source || 'transparent';
+}
+function dispatchChangeOtherFilters(widget, source) {
+    source.forEach(({ column_id, value }) => {
+        const dataSettings = getDataSettingsByColumnId(widget, column_id);
+        if (dataSettings &&
+            typeof dataSettings.events.onOtherFilterChange === 'function') {
+            const column = dataSettings.columns.find(({ id }) => id === column_id);
+            if (column)
+                dataSettings.events.onOtherFilterChange({
+                    column,
+                    method: data_1.FilterMethod.InList,
+                    value,
+                });
+        }
+    });
+}
+exports.dispatchChangeOtherFilters = dispatchChangeOtherFilters;
+function getDataSettingsByColumnId(widget, columnId) {
+    if (Array.isArray(widget.data))
+        return widget.dataSettings;
+    for (let dataSettings of Object.values(widget.dataSettings))
+        if (dataSettings.columns.find(({ id }) => id === columnId))
+            return dataSettings;
+    return null;
+}