@datarailsshared/dr_renderer 1.5.159 → 1.5.168

package/tests/options-builder.test.js

@@ -1,1698 +0,0 @@
-/**
- * @fileoverview Unit tests for the options builder module.
- *
- * Tests the standalone options builder module components:
- * - Constants
- * - Element factories
- * - Builders
- * - Presets
- * - Helpers
- * - Index exports
- */
-
-const options = require('../src/options');
-
-// Destructure for easier testing
-const {
-    // Constants
-    CHART_TYPES,
-    CHART_COLORS,
-    SUBOPTIONS_FONTS,
-    HIGHCHARTS_FONT_FAMILY,
-    HIGHCHARTS_FONT_FAMILY_CSS,
-    TOOLTIP_DEFAULT_SETTINGS,
-    TOOLTIP_DEFAULT_OPTIONS,
-    LABEL_DEFAULT_SETTINGS,
-    LABEL_DEFAULT_OPTIONS,
-    SUBOPTIONS_FONT_SIZE_VALUES,
-    DEFAULT_CATEGORY_CLASS,
-
-    // Element factories
-    createToggle,
-    createCheckbox,
-    createInput,
-    createSelect,
-    createRadio,
-    createColorPicker,
-    createDivider,
-    createTextarea,
-    createTag,
-    createFontStylingGroup,
-    createLabelStyleGroup,
-    createTooltipStyleGroup,
-
-    // Builders
-    withLabel,
-    withLabelPie,
-    withLabelGauge,
-    withLabelWithPercentage,
-    withLabelWithPercentagePercentStacked,
-    withTooltip,
-    withTooltipPie,
-    withTooltipGauge,
-    withAxisY,
-    withAxisYPercentStacked,
-    withAxisX,
-    withTableOptions,
-    withTableOptionsTranspose,
-    withTableOptionsGauge,
-    withTableDesignOptions,
-    withChart,
-    withChartGrid,
-    withChartForecast,
-    withChartPosition,
-    withWidgetLibrary,
-    withSubtitle,
-    withName,
-    withNegativeNumberFormat,
-    withValue,
-    withRange,
-    withTicks,
-    withLegends,
-    withDeltaColumn,
-    withDeltaColumnForDrillDown,
-    withAdvanced,
-    withTotalValueLabelDonut,
-    withGaugeGoal,
-    withGaugeSegments,
-    withGaugeIsAbsolute,
-
-    // Presets
-    CHART_PRESETS,
-    BUILDER_KEY_MAP,
-    getBuilderKey,
-    getPresetForChart,
-    buildSuboptionsForChart,
-    buildSuboptions,
-    getChartTypes,
-    hasPreset,
-
-    // Helpers
-    chartHasVerticalDataLabelsOption,
-
-    // Disabled conditions
-    LABEL_DISABLED_CONDITION,
-    LABEL_PIE_DISABLED_CONDITION,
-    TOOLTIP_DISABLED_CONDITION,
-    TOOLTIP_PIE_DISABLED_CONDITION,
-
-    // Reusable elements
-    LABEL_SHOW_TOGGLE,
-    LABEL_PIE_SHOW_TOGGLE,
-    LABEL_OVERLAP_TOGGLE,
-    TOOLTIP_SHOW_TOGGLE,
-    TOOLTIP_PIE_SHOW_TOGGLE,
-    GAUGE_SHOW_TOGGLE,
-
-    // Factory
-    createDefaultSuboptions,
-} = options;
-
-describe('Options Builder Module', () => {
-
-    // =========================================================================
-    // Constants Tests
-    // =========================================================================
-
-    describe('Constants', () => {
-        describe('CHART_TYPES', () => {
-            it('should contain all expected chart types', () => {
-                expect(CHART_TYPES.LINE_CHART).toBe('line-chart');
-                expect(CHART_TYPES.LINE_CHART_SMOOTH).toBe('line-chart-smooth');
-                expect(CHART_TYPES.LINE_CHART_FORECAST).toBe('line-chart-forecast');
-                expect(CHART_TYPES.COLUMN_CHART).toBe('column-chart');
-                expect(CHART_TYPES.COLUMN_CHART_STACKED).toBe('column-chart-stacked');
-                expect(CHART_TYPES.COLUMN_CHART_STACKED_PERCENT).toBe('column-chart-stacked-percent');
-                expect(CHART_TYPES.COMBO_CHART).toBe('combo-chart');
-                expect(CHART_TYPES.COMBO_COLUMN_CHART).toBe('combo-column-chart');
-                expect(CHART_TYPES.COMBO_STACKED_CHART).toBe('combo-stacked-chart');
-                expect(CHART_TYPES.BAR_CHART).toBe('bar-chart');
-                expect(CHART_TYPES.BAR_CHART_STACKED).toBe('bar-chart-stacked');
-                expect(CHART_TYPES.BAR_CHART_STACKED_PERCENT).toBe('bar-chart-stacked-percent');
-                expect(CHART_TYPES.SCATTER_CHART).toBe('scatter-chart');
-                expect(CHART_TYPES.AREA_CHART).toBe('area-chart');
-                expect(CHART_TYPES.AREA_CHART_SMOOTH).toBe('area-chart-smooth');
-                expect(CHART_TYPES.TABLE_ONLY).toBe('table_only');
-                expect(CHART_TYPES.POLYGON_CHART).toBe('polygon-chart');
-                expect(CHART_TYPES.PIE_CHART).toBe('pie-chart');
-                expect(CHART_TYPES.PIE_CHART_DRILLDOWN).toBe('pie-chart-drilldown');
-                expect(CHART_TYPES.GAUGE_CHART_ENHANCED).toBe('gauge-chart-enhanced');
-                expect(CHART_TYPES.GAUGE_CHART_DYNAMIC_GOAL).toBe('gauge-chart-dynamic-goal');
-                expect(CHART_TYPES.GAUGE_CHART_CATEGORIES_SUMMARY).toBe('gauge-chart-categories-summary');
-                expect(CHART_TYPES.KPI_WIDGET).toBe('kpi-widget');
-                expect(CHART_TYPES.SMART_KPI).toBe('smart-kpi');
-                expect(CHART_TYPES.TEXT_WIDGET).toBe('text-widget');
-                expect(CHART_TYPES.WATERFALL_BREAKDOWN).toBe('waterfall-chart-breakdown');
-                expect(CHART_TYPES.WATERFALL_WALKTHROUGH).toBe('waterfall-chart-walkthrough');
-                expect(CHART_TYPES.DONUT_CHART).toBe('donut-chart');
-            });
-
-            it('should have all values as strings', () => {
-                Object.values(CHART_TYPES).forEach(value => {
-                    expect(typeof value).toBe('string');
-                });
-            });
-        });
-
-        describe('CHART_COLORS', () => {
-            it('should contain expected color keys', () => {
-                expect(CHART_COLORS.BACKGROUND).toBeDefined();
-                expect(CHART_COLORS.TEXT).toBeDefined();
-                expect(CHART_COLORS.LABEL).toBeDefined();
-                expect(CHART_COLORS.TICK_COLOR).toBeDefined();
-            });
-
-            it('should have valid color values', () => {
-                // All values should be strings (hex, rgba, or named colors)
-                Object.values(CHART_COLORS).forEach(value => {
-                    expect(typeof value).toBe('string');
-                    // Should be hex, rgba, or valid color name
-                    expect(value).toMatch(/^(#|rgba|white|black|red|green|blue)/);
-                });
-            });
-        });
-
-        describe('SUBOPTIONS_FONTS', () => {
-            it('should be an array of font names', () => {
-                expect(Array.isArray(SUBOPTIONS_FONTS)).toBe(true);
-                expect(SUBOPTIONS_FONTS.length).toBeGreaterThan(0);
-            });
-
-            it('should contain common fonts', () => {
-                expect(SUBOPTIONS_FONTS).toContain('Arial');
-                expect(SUBOPTIONS_FONTS).toContain('Poppins');
-                expect(SUBOPTIONS_FONTS).toContain('Helvetica');
-            });
-        });
-
-        describe('SUBOPTIONS_FONT_SIZE_VALUES', () => {
-            it('should contain 19 font size options (6-24)', () => {
-                expect(SUBOPTIONS_FONT_SIZE_VALUES).toHaveLength(19);
-            });
-
-            it('should have correct structure for each option', () => {
-                SUBOPTIONS_FONT_SIZE_VALUES.forEach(option => {
-                    expect(option).toHaveProperty('label');
-                    expect(option).toHaveProperty('value');
-                    expect(option.label).toBe(option.value);
-                });
-            });
-
-            it('should start at 6 and end at 24', () => {
-                expect(SUBOPTIONS_FONT_SIZE_VALUES[0].value).toBe(6);
-                expect(SUBOPTIONS_FONT_SIZE_VALUES[18].value).toBe(24);
-            });
-        });
-
-        describe('DEFAULT_CATEGORY_CLASS', () => {
-            it('should be the correct CSS class', () => {
-                expect(DEFAULT_CATEGORY_CLASS).toBe('google-visualization-charteditor-mini-more');
-            });
-        });
-
-        describe('HIGHCHARTS_FONT_FAMILY', () => {
-            it('should be Poppins', () => {
-                expect(HIGHCHARTS_FONT_FAMILY).toBe('Poppins');
-            });
-        });
-
-        describe('HIGHCHARTS_FONT_FAMILY_CSS', () => {
-            it('should include fallback', () => {
-                expect(HIGHCHARTS_FONT_FAMILY_CSS).toBe('Poppins, sans-serif');
-            });
-        });
-
-        describe('LABEL_DEFAULT_SETTINGS', () => {
-            it('should have correct structure', () => {
-                expect(LABEL_DEFAULT_SETTINGS).toHaveProperty('FONT_COLOR');
-                expect(LABEL_DEFAULT_SETTINGS).toHaveProperty('FONT_SIZE');
-                expect(LABEL_DEFAULT_SETTINGS).toHaveProperty('FONT_FAMILY');
-            });
-
-            it('should have correct default values', () => {
-                expect(LABEL_DEFAULT_SETTINGS.FONT_FAMILY).toBe('Poppins');
-                expect(LABEL_DEFAULT_SETTINGS.FONT_SIZE).toBe('11');
-            });
-        });
-
-        describe('TOOLTIP_DEFAULT_SETTINGS', () => {
-            it('should have correct structure', () => {
-                expect(TOOLTIP_DEFAULT_SETTINGS).toHaveProperty('FONT_COLOR');
-                expect(TOOLTIP_DEFAULT_SETTINGS).toHaveProperty('FONT_SIZE');
-                expect(TOOLTIP_DEFAULT_SETTINGS).toHaveProperty('FONT_FAMILY');
-            });
-
-            it('should have correct default values', () => {
-                expect(TOOLTIP_DEFAULT_SETTINGS.FONT_FAMILY).toBe('Poppins');
-                expect(TOOLTIP_DEFAULT_SETTINGS.FONT_SIZE).toBe('12');
-                expect(TOOLTIP_DEFAULT_SETTINGS.FONT_COLOR).toBe('#545a6b');
-            });
-        });
-
-        describe('LABEL_DEFAULT_OPTIONS', () => {
-            it('should have correct structure', () => {
-                expect(LABEL_DEFAULT_OPTIONS).toHaveProperty('style');
-                expect(LABEL_DEFAULT_OPTIONS).toHaveProperty('color');
-                expect(LABEL_DEFAULT_OPTIONS.style).toHaveProperty('fontSize');
-                expect(LABEL_DEFAULT_OPTIONS.style).toHaveProperty('fontFamily');
-                expect(LABEL_DEFAULT_OPTIONS.style).toHaveProperty('fontWeight');
-            });
-        });
-
-        describe('TOOLTIP_DEFAULT_OPTIONS', () => {
-            it('should have correct structure', () => {
-                expect(TOOLTIP_DEFAULT_OPTIONS).toHaveProperty('borderColor');
-                expect(TOOLTIP_DEFAULT_OPTIONS).toHaveProperty('shadow');
-                expect(TOOLTIP_DEFAULT_OPTIONS).toHaveProperty('style');
-                expect(TOOLTIP_DEFAULT_OPTIONS).toHaveProperty('enabled');
-            });
-
-            it('should be enabled by default', () => {
-                expect(TOOLTIP_DEFAULT_OPTIONS.enabled).toBe(true);
-            });
-        });
-
-        describe('Reusable Disabled Conditions', () => {
-            describe('LABEL_DISABLED_CONDITION', () => {
-                it('should have disabled_str and disabled_fn', () => {
-                    expect(LABEL_DISABLED_CONDITION).toHaveProperty('disabled_str');
-                    expect(LABEL_DISABLED_CONDITION).toHaveProperty('disabled_fn');
-                    expect(typeof LABEL_DISABLED_CONDITION.disabled_str).toBe('string');
-                    expect(typeof LABEL_DISABLED_CONDITION.disabled_fn).toBe('function');
-                });
-
-                it('disabled_fn should return true when no options are enabled', () => {
-                    const result = LABEL_DISABLED_CONDITION.disabled_fn({
-                        show_out_of_x_axis: false,
-                        show_out_of_data_series: false,
-                        show_value: false,
-                    });
-                    expect(result).toBe(true);
-                });
-
-                it('disabled_fn should return false when at least one option is enabled', () => {
-                    expect(LABEL_DISABLED_CONDITION.disabled_fn({ show_value: true })).toBe(false);
-                    expect(LABEL_DISABLED_CONDITION.disabled_fn({ show_out_of_x_axis: true })).toBe(false);
-                    expect(LABEL_DISABLED_CONDITION.disabled_fn({ show_out_of_data_series: true })).toBe(false);
-                });
-            });
-
-            describe('LABEL_PIE_DISABLED_CONDITION', () => {
-                it('should have disabled_str and disabled_fn', () => {
-                    expect(LABEL_PIE_DISABLED_CONDITION).toHaveProperty('disabled_str');
-                    expect(LABEL_PIE_DISABLED_CONDITION).toHaveProperty('disabled_fn');
-                });
-
-                it('disabled_fn should return true when no pie label options are enabled', () => {
-                    const result = LABEL_PIE_DISABLED_CONDITION.disabled_fn({
-                        show_percentage_in_labels: false,
-                        show_value_in_labels: false,
-                    });
-                    expect(result).toBe(true);
-                });
-
-                it('disabled_fn should return false when at least one pie label option is enabled', () => {
-                    expect(LABEL_PIE_DISABLED_CONDITION.disabled_fn({ show_value_in_labels: true })).toBe(false);
-                    expect(LABEL_PIE_DISABLED_CONDITION.disabled_fn({ show_percentage_in_labels: true })).toBe(false);
-                });
-            });
-
-            describe('TOOLTIP_DISABLED_CONDITION', () => {
-                it('should have disabled_str and disabled_fn', () => {
-                    expect(TOOLTIP_DISABLED_CONDITION).toHaveProperty('disabled_str');
-                    expect(TOOLTIP_DISABLED_CONDITION).toHaveProperty('disabled_fn');
-                });
-
-                it('disabled_fn should return true when no tooltip options are enabled', () => {
-                    const result = TOOLTIP_DISABLED_CONDITION.disabled_fn({
-                        show_out_of_x_axis: false,
-                        show_out_of_data_series: false,
-                        show_value: false,
-                        show_x_axis: false,
-                        show_data_series: false,
-                    });
-                    expect(result).toBe(true);
-                });
-
-                it('disabled_fn should return false when at least one tooltip option is enabled', () => {
-                    expect(TOOLTIP_DISABLED_CONDITION.disabled_fn({ show_x_axis: true })).toBe(false);
-                    expect(TOOLTIP_DISABLED_CONDITION.disabled_fn({ show_data_series: true })).toBe(false);
-                    expect(TOOLTIP_DISABLED_CONDITION.disabled_fn({ show_value: true })).toBe(false);
-                });
-            });
-
-            describe('TOOLTIP_PIE_DISABLED_CONDITION', () => {
-                it('should have disabled_str and disabled_fn', () => {
-                    expect(TOOLTIP_PIE_DISABLED_CONDITION).toHaveProperty('disabled_str');
-                    expect(TOOLTIP_PIE_DISABLED_CONDITION).toHaveProperty('disabled_fn');
-                });
-
-                it('disabled_fn should return true when no pie tooltip options are enabled', () => {
-                    const result = TOOLTIP_PIE_DISABLED_CONDITION.disabled_fn({
-                        show_percentage: false,
-                        show_value: false,
-                    });
-                    expect(result).toBe(true);
-                });
-
-                it('disabled_fn should return false when at least one pie tooltip option is enabled', () => {
-                    expect(TOOLTIP_PIE_DISABLED_CONDITION.disabled_fn({ show_percentage: true })).toBe(false);
-                    expect(TOOLTIP_PIE_DISABLED_CONDITION.disabled_fn({ show_value: true })).toBe(false);
-                });
-            });
-        });
-
-        describe('Reusable Elements', () => {
-            describe('LABEL_SHOW_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(LABEL_SHOW_TOGGLE.element_type).toBe('toggle');
-                    expect(LABEL_SHOW_TOGGLE.value_name).toBe('show');
-                    expect(LABEL_SHOW_TOGGLE.element_label).toBe('Show');
-                    expect(LABEL_SHOW_TOGGLE.default_value).toBe(true);
-                });
-
-                it('should use LABEL_DISABLED_CONDITION', () => {
-                    expect(LABEL_SHOW_TOGGLE.disabled_str).toBe(LABEL_DISABLED_CONDITION.disabled_str);
-                    expect(LABEL_SHOW_TOGGLE.disabled_fn).toBe(LABEL_DISABLED_CONDITION.disabled_fn);
-                });
-            });
-
-            describe('LABEL_PIE_SHOW_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(LABEL_PIE_SHOW_TOGGLE.element_type).toBe('toggle');
-                    expect(LABEL_PIE_SHOW_TOGGLE.value_name).toBe('show');
-                    expect(LABEL_PIE_SHOW_TOGGLE.default_value).toBe(false);
-                });
-
-                it('should use LABEL_PIE_DISABLED_CONDITION', () => {
-                    expect(LABEL_PIE_SHOW_TOGGLE.disabled_str).toBe(LABEL_PIE_DISABLED_CONDITION.disabled_str);
-                });
-            });
-
-            describe('LABEL_OVERLAP_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(LABEL_OVERLAP_TOGGLE.element_type).toBe('toggle');
-                    expect(LABEL_OVERLAP_TOGGLE.value_name).toBe('overlap');
-                    expect(LABEL_OVERLAP_TOGGLE.element_label).toBe('Overlap');
-                    expect(LABEL_OVERLAP_TOGGLE.default_value).toBe(false);
-                });
-            });
-
-            describe('TOOLTIP_SHOW_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(TOOLTIP_SHOW_TOGGLE.element_type).toBe('toggle');
-                    expect(TOOLTIP_SHOW_TOGGLE.value_name).toBe('show');
-                    expect(TOOLTIP_SHOW_TOGGLE.default_value).toBe(true);
-                });
-
-                it('should use TOOLTIP_DISABLED_CONDITION', () => {
-                    expect(TOOLTIP_SHOW_TOGGLE.disabled_str).toBe(TOOLTIP_DISABLED_CONDITION.disabled_str);
-                });
-            });
-
-            describe('TOOLTIP_PIE_SHOW_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(TOOLTIP_PIE_SHOW_TOGGLE.element_type).toBe('toggle');
-                    expect(TOOLTIP_PIE_SHOW_TOGGLE.value_name).toBe('show');
-                    expect(TOOLTIP_PIE_SHOW_TOGGLE.default_value).toBe(true);
-                });
-
-                it('should use TOOLTIP_PIE_DISABLED_CONDITION', () => {
-                    expect(TOOLTIP_PIE_SHOW_TOGGLE.disabled_str).toBe(TOOLTIP_PIE_DISABLED_CONDITION.disabled_str);
-                });
-            });
-
-            describe('GAUGE_SHOW_TOGGLE', () => {
-                it('should be a toggle element with correct properties', () => {
-                    expect(GAUGE_SHOW_TOGGLE.element_type).toBe('toggle');
-                    expect(GAUGE_SHOW_TOGGLE.value_name).toBe('show');
-                    expect(GAUGE_SHOW_TOGGLE.default_value).toBe(true);
-                });
-
-                it('should NOT have disabled condition', () => {
-                    expect(GAUGE_SHOW_TOGGLE.disabled_str).toBeUndefined();
-                    expect(GAUGE_SHOW_TOGGLE.disabled_fn).toBeUndefined();
-                });
-            });
-        });
-    });
-
-    // =========================================================================
-    // Element Factory Tests
-    // =========================================================================
-
-    describe('Element Factories', () => {
-        describe('createToggle', () => {
-            it('should create a toggle element with required properties', () => {
-                const toggle = createToggle('show', 'Show', true);
-
-                expect(toggle).toEqual({
-                    element_type: 'toggle',
-                    element_label: 'Show',
-                    value_name: 'show',
-                    default_value: true,
-                });
-            });
-
-            it('should use false as default value when not provided', () => {
-                const toggle = createToggle('enabled', 'Enabled');
-                expect(toggle.default_value).toBe(false);
-            });
-
-            it('should merge additional options', () => {
-                const showFn = jest.fn();
-                const toggle = createToggle('show', 'Show', true, { showFn });
-
-                expect(toggle.showFn).toBe(showFn);
-            });
-
-            it('should support disabled_str and disabled_fn options', () => {
-                const disabled_fn = jest.fn();
-                const toggle = createToggle('show', 'Show', true, {
-                    disabled_str: '!{var}.other',
-                    disabled_fn,
-                });
-
-                expect(toggle.disabled_str).toBe('!{var}.other');
-                expect(toggle.disabled_fn).toBe(disabled_fn);
-            });
-        });
-
-        describe('createCheckbox', () => {
-            it('should create a checkbox element with required properties', () => {
-                const checkbox = createCheckbox('enabled', 'Enabled', true);
-
-                expect(checkbox).toEqual({
-                    element_type: 'checkbox',
-                    element_label: 'Enabled',
-                    value_name: 'enabled',
-                    default_value: true,
-                });
-            });
-
-            it('should use false as default value when not provided', () => {
-                const checkbox = createCheckbox('active', 'Active');
-                expect(checkbox.default_value).toBe(false);
-            });
-
-            it('should support clickFn option', () => {
-                const clickFn = jest.fn();
-                const checkbox = createCheckbox('value', 'Value', true, { clickFn });
-
-                expect(checkbox.clickFn).toBe(clickFn);
-            });
-
-            it('should support hidden option', () => {
-                const checkbox = createCheckbox('hidden', 'Hidden', false, { hidden: true });
-                expect(checkbox.hidden).toBe(true);
-            });
-        });
-
-        describe('createInput', () => {
-            it('should create an input element with required properties', () => {
-                const input = createInput('name', 'Name', 'default');
-
-                expect(input).toEqual({
-                    element_type: 'input',
-                    element_label: 'Name',
-                    value_name: 'name',
-                    default_value: 'default',
-                });
-            });
-
-            it('should use empty string as default value when not provided', () => {
-                const input = createInput('title', 'Title');
-                expect(input.default_value).toBe('');
-            });
-
-            it('should support numeric default values', () => {
-                const input = createInput('count', 'Count', 10);
-                expect(input.default_value).toBe(10);
-            });
-
-            it('should support null default values', () => {
-                const input = createInput('optional', 'Optional', null);
-                expect(input.default_value).toBeNull();
-            });
-
-            it('should support label_tooltip option', () => {
-                const input = createInput('value', 'Value', '', { label_tooltip: 'Help text' });
-                expect(input.label_tooltip).toBe('Help text');
-            });
-
-            it('should support show_in_one_row option', () => {
-                const input = createInput('value', 'Value', '', { show_in_one_row: true });
-                expect(input.show_in_one_row).toBe(true);
-            });
-        });
-
-        describe('createSelect', () => {
-            const fontOptions = [
-                { label: 'Arial', value: 'Arial' },
-                { label: 'Poppins', value: 'Poppins' },
-            ];
-
-            it('should create a select element with required properties', () => {
-                const select = createSelect('font', 'Font', fontOptions, 'Arial');
-
-                expect(select.element_type).toBe('select');
-                expect(select.element_label).toBe('Font');
-                expect(select.value_name).toBe('font');
-                expect(select.element_options).toEqual(fontOptions);
-                expect(select.default_value).toBe('Arial');
-            });
-
-            it('should support string array as options', () => {
-                const stringOptions = ['Arial', 'Poppins', 'Helvetica'];
-                const select = createSelect('font', 'Font', stringOptions, 'Arial');
-
-                expect(select.element_options).toEqual(stringOptions);
-            });
-
-            it('should work without default value', () => {
-                const select = createSelect('font', 'Font', fontOptions);
-                expect(select.default_value).toBeUndefined();
-            });
-        });
-
-        describe('createRadio', () => {
-            const alignOptions = [
-                { label: 'Left', value: 'left' },
-                { label: 'Center', value: 'center' },
-                { label: 'Right', value: 'right' },
-            ];
-
-            it('should create a radio element with required properties', () => {
-                const radio = createRadio('align', 'Alignment', alignOptions, 'left');
-
-                expect(radio.element_type).toBe('radio');
-                expect(radio.element_label).toBe('Alignment');
-                expect(radio.value_name).toBe('align');
-                expect(radio.element_options).toEqual(alignOptions);
-                expect(radio.default_value).toBe('left');
-            });
-
-            it('should use empty string as default value when not provided', () => {
-                const radio = createRadio('align', 'Alignment', alignOptions);
-                expect(radio.default_value).toBe('');
-            });
-
-            it('should support element_sub_title option', () => {
-                const radio = createRadio('align', 'Alignment', alignOptions, 'left', {
-                    element_sub_title: 'Choose alignment',
-                });
-                expect(radio.element_sub_title).toBe('Choose alignment');
-            });
-        });
-
-        describe('createColorPicker', () => {
-            it('should create a color picker element with required properties', () => {
-                const colorPicker = createColorPicker('color', 'Color', '#ff0000');
-
-                expect(colorPicker).toEqual({
-                    element_type: 'color_picker',
-                    element_label: 'Color',
-                    value_name: 'color',
-                    default_value: '#ff0000',
-                });
-            });
-
-            it('should use empty string as default value when not provided', () => {
-                const colorPicker = createColorPicker('color', 'Color');
-                expect(colorPicker.default_value).toBe('');
-            });
-        });
-
-        describe('createDivider', () => {
-            it('should create a divider element without label', () => {
-                const divider = createDivider();
-
-                expect(divider.element_type).toBe('devider');
-                expect(divider.element_label).toBeUndefined();
-            });
-
-            it('should create a divider element with label', () => {
-                const divider = createDivider('Section Title');
-
-                expect(divider.element_type).toBe('devider');
-                expect(divider.element_label).toBe('Section Title');
-            });
-        });
-
-        describe('createTextarea', () => {
-            it('should create a textarea element with required properties', () => {
-                const textarea = createTextarea('description', 'Description', 'default text');
-
-                expect(textarea).toEqual({
-                    element_type: 'textarea',
-                    element_label: 'Description',
-                    value_name: 'description',
-                    default_value: 'default text',
-                });
-            });
-
-            it('should use empty string as default value when not provided', () => {
-                const textarea = createTextarea('notes', 'Notes');
-                expect(textarea.default_value).toBe('');
-            });
-        });
-
-        describe('createTag', () => {
-            it('should create a tag element with required properties', () => {
-                const tag = createTag('tags', 'Tags', ['tag1', 'tag2']);
-
-                expect(tag.element_type).toBe('tag');
-                expect(tag.element_label).toBe('Tags');
-                expect(tag.value_name).toBe('tags');
-                expect(tag.default_value).toEqual(['tag1', 'tag2']);
-            });
-
-            it('should use empty array as default value when not provided', () => {
-                const tag = createTag('tags', 'Tags');
-                expect(tag.default_value).toEqual([]);
-            });
-
-            it('should set tag options with defaults', () => {
-                const tag = createTag('tags', 'Tags');
-
-                expect(tag.element_options).toEqual({
-                    add_new_tag: true,
-                    searchable: true,
-                    multiple: true,
-                });
-            });
-
-            it('should allow overriding tag options', () => {
-                const tag = createTag('tags', 'Tags', [], {
-                    add_new_tag: false,
-                    searchable: false,
-                    multiple: false,
-                });
-
-                expect(tag.element_options).toEqual({
-                    add_new_tag: false,
-                    searchable: false,
-                    multiple: false,
-                });
-            });
-        });
-
-        describe('createFontStylingGroup', () => {
-            it('should return array of 3 elements', () => {
-                const group = createFontStylingGroup();
-                expect(group).toHaveLength(3);
-            });
-
-            it('should contain font_style select, font_size select, and font_color picker', () => {
-                const group = createFontStylingGroup();
-
-                expect(group[0].value_name).toBe('font_style');
-                expect(group[0].element_type).toBe('select');
-
-                expect(group[1].value_name).toBe('font_size');
-                expect(group[1].element_type).toBe('select');
-
-                expect(group[2].value_name).toBe('font_color');
-                expect(group[2].element_type).toBe('color_picker');
-            });
-
-            it('should use label defaults when no custom defaults provided', () => {
-                const group = createFontStylingGroup();
-
-                expect(group[0].default_value).toBe(LABEL_DEFAULT_SETTINGS.FONT_FAMILY);
-                expect(group[1].default_value).toBe(LABEL_DEFAULT_SETTINGS.FONT_SIZE);
-                expect(group[2].default_value).toBe(LABEL_DEFAULT_SETTINGS.FONT_COLOR);
-            });
-
-            it('should allow custom defaults', () => {
-                const group = createFontStylingGroup({
-                    fontStyle: 'Arial',
-                    fontSize: '14',
-                    fontColor: '#000000',
-                });
-
-                expect(group[0].default_value).toBe('Arial');
-                expect(group[1].default_value).toBe('14');
-                expect(group[2].default_value).toBe('#000000');
-            });
-        });
-
-        describe('createLabelStyleGroup', () => {
-            it('should return array with dividers and font styling', () => {
-                const group = createLabelStyleGroup();
-
-                // Should have 2 dividers + 3 font styling elements
-                expect(group).toHaveLength(5);
-                expect(group[0].element_type).toBe('devider');
-                expect(group[1].element_type).toBe('devider');
-                expect(group[1].element_label).toBe('Label Style');
-            });
-        });
-
-        describe('createTooltipStyleGroup', () => {
-            it('should return array with dividers and font styling', () => {
-                const group = createTooltipStyleGroup();
-
-                // Should have 2 dividers + 3 font styling elements
-                expect(group).toHaveLength(5);
-                expect(group[0].element_type).toBe('devider');
-                expect(group[1].element_type).toBe('devider');
-                expect(group[1].element_label).toBe('Tooltip Style');
-            });
-
-            it('should use tooltip defaults', () => {
-                const group = createTooltipStyleGroup();
-
-                expect(group[2].default_value).toBe(TOOLTIP_DEFAULT_SETTINGS.FONT_FAMILY);
-                expect(group[3].default_value).toBe(TOOLTIP_DEFAULT_SETTINGS.FONT_SIZE);
-                expect(group[4].default_value).toBe(TOOLTIP_DEFAULT_SETTINGS.FONT_COLOR);
-            });
-        });
-    });
-
-    // =========================================================================
-    // Builder Tests
-    // =========================================================================
-
-    describe('Builders', () => {
-        // Helper to validate SuboptionDefinition structure
-        const expectValidSuboptionDefinition = (def) => {
-            expect(def).toHaveProperty('category_class');
-            expect(def).toHaveProperty('category_label');
-            expect(def).toHaveProperty('category_type');
-            expect(typeof def.category_class).toBe('string');
-            expect(typeof def.category_label).toBe('string');
-            expect(typeof def.category_type).toBe('string');
-        };
-
-        describe('Label builders', () => {
-            describe('withLabel', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLabel();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withLabel();
-                    expect(result.category_type).toBe('label');
-                    expect(result.category_label).toBe('Label');
-                    expect(result.category_class).toBe(DEFAULT_CATEGORY_CLASS);
-                });
-
-                it('should have elements array', () => {
-                    const result = withLabel();
-                    expect(Array.isArray(result.elements)).toBe(true);
-                    expect(result.elements.length).toBeGreaterThan(0);
-                });
-
-                it('should use shared LABEL_SHOW_TOGGLE element', () => {
-                    const result = withLabel();
-                    const showElement = result.elements.find(e => e.value_name === 'show');
-                    // Verify it uses the exact shared element reference
-                    expect(showElement).toBe(LABEL_SHOW_TOGGLE);
-                });
-
-                it('should use shared LABEL_OVERLAP_TOGGLE element', () => {
-                    const result = withLabel();
-                    const overlapElement = result.elements.find(e => e.value_name === 'overlap');
-                    expect(overlapElement).toBe(LABEL_OVERLAP_TOGGLE);
-                });
-
-                it('should include font styling elements', () => {
-                    const result = withLabel();
-                    const fontStyle = result.elements.find(e => e.value_name === 'font_style');
-                    const fontSize = result.elements.find(e => e.value_name === 'font_size');
-                    const fontColor = result.elements.find(e => e.value_name === 'font_color');
-
-                    expect(fontStyle).toBeDefined();
-                    expect(fontSize).toBeDefined();
-                    expect(fontColor).toBeDefined();
-                });
-            });
-
-            describe('withLabelPie', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLabelPie();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category type', () => {
-                    const result = withLabelPie();
-                    expect(result.category_type).toBe('label_pie');
-                });
-
-                it('should include pie-specific options', () => {
-                    const result = withLabelPie();
-                    const useAreaColor = result.elements.find(e => e.value_name === 'use_area_color');
-                    const showPercentage = result.elements.find(e => e.value_name === 'show_percentage_in_labels');
-
-                    expect(useAreaColor).toBeDefined();
-                    expect(showPercentage).toBeDefined();
-                });
-            });
-
-            describe('withLabelGauge', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLabelGauge();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category type', () => {
-                    const result = withLabelGauge();
-                    expect(result.category_type).toBe('label');
-                });
-
-                it('should include gauge-specific options', () => {
-                    const result = withLabelGauge();
-                    const showPercentageInValue = result.elements.find(e => e.value_name === 'show_percentage_in_value');
-                    const showGoalName = result.elements.find(e => e.value_name === 'show_goal_name');
-
-                    expect(showPercentageInValue).toBeDefined();
-                    expect(showGoalName).toBeDefined();
-                });
-
-                it('should use enableGaugeDynamicGoal config for goal_name visibility', () => {
-                    const result = withLabelGauge({ enableGaugeDynamicGoal: true });
-
-                    const goalName = result.elements.find(e => e.value_name === 'goal_name');
-                    expect(goalName).toBeDefined();
-                    expect(goalName.showFn).toBeDefined();
-
-                    expect(goalName.showFn()).toBe(true);
-                });
-            });
-
-            describe('withLabelWithPercentage', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLabelWithPercentage();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should include percentage options', () => {
-                    const result = withLabelWithPercentage();
-                    const presentTotal = result.elements.find(e => e.value_name === 'present_total');
-                    const showPercentage = result.elements.find(e => e.value_name === 'show_percentage');
-
-                    expect(presentTotal).toBeDefined();
-                    expect(showPercentage).toBeDefined();
-                });
-            });
-
-            describe('withLabelWithPercentagePercentStacked', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLabelWithPercentagePercentStacked();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-        });
-
-        describe('Tooltip builders', () => {
-            describe('withTooltip', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTooltip();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withTooltip();
-                    expect(result.category_type).toBe('tooltips');
-                    expect(result.category_label).toBe('Tooltip');
-                });
-
-                it('should include tooltip-specific elements', () => {
-                    const result = withTooltip();
-                    const show = result.elements.find(e => e.value_name === 'show');
-                    const showValue = result.elements.find(e => e.value_name === 'show_value');
-
-                    expect(show).toBeDefined();
-                    expect(showValue).toBeDefined();
-                });
-            });
-
-            describe('withTooltipPie', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTooltipPie();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category type', () => {
-                    const result = withTooltipPie();
-                    // Note: tooltips_pie uses 'tooltips' as category_type but is keyed as 'tooltips_pie'
-                    expect(result.category_type).toBe('tooltips');
-                });
-            });
-
-            describe('withTooltipGauge', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTooltipGauge();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category type', () => {
-                    const result = withTooltipGauge();
-                    expect(result.category_type).toBe('tooltips');
-                });
-            });
-        });
-
-        describe('Axis builders', () => {
-            describe('withAxisY', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withAxisY();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withAxisY();
-                    expect(result.category_type).toBe('axisY');
-                    expect(result.category_label).toBe('Y Axis');
-                });
-
-                it('should include min/max inputs', () => {
-                    const result = withAxisY();
-                    const min = result.elements.find(e => e.value_name === 'min');
-                    const max = result.elements.find(e => e.value_name === 'max');
-
-                    expect(min).toBeDefined();
-                    expect(max).toBeDefined();
-                });
-            });
-
-            describe('withAxisYPercentStacked', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withAxisYPercentStacked();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should NOT include min/max inputs', () => {
-                    const result = withAxisYPercentStacked();
-                    const min = result.elements.find(e => e.value_name === 'min');
-                    const max = result.elements.find(e => e.value_name === 'max');
-
-                    expect(min).toBeUndefined();
-                    expect(max).toBeUndefined();
-                });
-            });
-
-            describe('withAxisX', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withAxisX();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withAxisX();
-                    expect(result.category_type).toBe('axisX');
-                    expect(result.category_label).toBe('X Axis');
-                });
-            });
-        });
-
-        describe('Table builders', () => {
-            describe('withTableOptions', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTableOptions();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withTableOptions();
-                    expect(result.category_type).toBe('table_options');
-                    expect(result.category_label).toBe('Table');
-                });
-
-                it('should include table-specific options', () => {
-                    const result = withTableOptions();
-                    const showColumnTotal = result.elements.find(e => e.value_name === 'show_column_total');
-                    const showRowTotal = result.elements.find(e => e.value_name === 'show_row_total');
-
-                    expect(showColumnTotal).toBeDefined();
-                    expect(showRowTotal).toBeDefined();
-                });
-            });
-
-            describe('withTableOptionsTranspose', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTableOptionsTranspose();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have transpose disabled by default', () => {
-                    const result = withTableOptionsTranspose();
-                    const transpose = result.elements.find(e => e.value_name === 'transpose_table');
-
-                    expect(transpose).toBeDefined();
-                    expect(transpose.default_value).toBe(false);
-                });
-            });
-
-            describe('withTableOptionsGauge', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTableOptionsGauge();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have simplified options', () => {
-                    const result = withTableOptionsGauge();
-                    // Gauge table options should have fewer elements
-                    expect(result.elements.length).toBeLessThan(5);
-                });
-            });
-
-            describe('withTableDesignOptions', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTableDesignOptions();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withTableDesignOptions();
-                    expect(result.category_type).toBe('table_design_options');
-                    expect(result.category_label).toBe('Table design');
-                });
-            });
-        });
-
-        describe('Chart config builders', () => {
-            describe('withChart', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withChart();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should have correct category properties', () => {
-                    const result = withChart();
-                    expect(result.category_type).toBe('chart');
-                });
-            });
-
-            describe('withChartGrid', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withChartGrid();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withChartForecast', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withChartForecast();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withChartPosition', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withChartPosition();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-        });
-
-        describe('Other builders', () => {
-            describe('withWidgetLibrary', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withWidgetLibrary();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should be hidden', () => {
-                    const result = withWidgetLibrary();
-                    expect(result.is_hidden).toBe(true);
-                });
-            });
-
-            describe('withSubtitle', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withSubtitle();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withName', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withName();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withNegativeNumberFormat', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withNegativeNumberFormat();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withValue', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withValue();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withRange', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withRange();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withTicks', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTicks();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withLegends', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withLegends();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withDeltaColumn', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withDeltaColumn();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withDeltaColumnForDrillDown', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withDeltaColumnForDrillDown();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withAdvanced', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withAdvanced();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withTotalValueLabelDonut', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withTotalValueLabelDonut();
-                    expectValidSuboptionDefinition(result);
-                });
-            });
-
-            describe('withGaugeGoal', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withGaugeGoal();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should be hidden', () => {
-                    const result = withGaugeGoal();
-                    expect(result.is_hidden).toBe(true);
-                });
-            });
-
-            describe('withGaugeSegments', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withGaugeSegments();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should be hidden', () => {
-                    const result = withGaugeSegments();
-                    expect(result.is_hidden).toBe(true);
-                });
-
-                it('should use provided default segments', () => {
-                    const customSegments = [
-                        { from: 0, to: 100, color: 'green', title: 'Good' },
-                    ];
-                    const result = withGaugeSegments({ defaultSegments: customSegments });
-
-                    expect(result.default_value).toEqual(customSegments);
-                });
-
-                it('should use fallback segments when not provided', () => {
-                    const result = withGaugeSegments();
-
-                    expect(result.default_value).toBeDefined();
-                    expect(Array.isArray(result.default_value)).toBe(true);
-                    expect(result.default_value.length).toBeGreaterThan(0);
-                });
-            });
-
-            describe('withGaugeIsAbsolute', () => {
-                it('should return valid SuboptionDefinition', () => {
-                    const result = withGaugeIsAbsolute();
-                    expectValidSuboptionDefinition(result);
-                });
-
-                it('should be hidden', () => {
-                    const result = withGaugeIsAbsolute();
-                    expect(result.is_hidden).toBe(true);
-                });
-
-                it('should have false as default value', () => {
-                    const result = withGaugeIsAbsolute();
-                    expect(result.default_value).toBe(false);
-                });
-            });
-        });
-    });
-
-    // =========================================================================
-    // Preset Tests
-    // =========================================================================
-
-    describe('Presets', () => {
-        describe('CHART_PRESETS', () => {
-            it('should be defined', () => {
-                expect(CHART_PRESETS).toBeDefined();
-            });
-
-            it('should have presets for all common chart types', () => {
-                expect(CHART_PRESETS[CHART_TYPES.LINE_CHART]).toBeDefined();
-                expect(CHART_PRESETS[CHART_TYPES.COLUMN_CHART]).toBeDefined();
-                expect(CHART_PRESETS[CHART_TYPES.BAR_CHART]).toBeDefined();
-                expect(CHART_PRESETS[CHART_TYPES.PIE_CHART]).toBeDefined();
-                expect(CHART_PRESETS[CHART_TYPES.GAUGE_CHART_ENHANCED]).toBeDefined();
-            });
-
-            it('should have arrays of builder functions', () => {
-                const lineChartPreset = CHART_PRESETS[CHART_TYPES.LINE_CHART];
-
-                expect(Array.isArray(lineChartPreset)).toBe(true);
-                lineChartPreset.forEach(builder => {
-                    expect(typeof builder).toBe('function');
-                });
-            });
-        });
-
-        describe('BUILDER_KEY_MAP', () => {
-            it('should be a Map', () => {
-                expect(BUILDER_KEY_MAP).toBeInstanceOf(Map);
-            });
-
-            it('should map builder functions to string keys', () => {
-                expect(BUILDER_KEY_MAP.get(withLabel)).toBe('label');
-                expect(BUILDER_KEY_MAP.get(withTooltip)).toBe('tooltips');
-                expect(BUILDER_KEY_MAP.get(withAxisY)).toBe('axisY');
-                expect(BUILDER_KEY_MAP.get(withAxisX)).toBe('axisX');
-            });
-        });
-
-        describe('getBuilderKey', () => {
-            it('should return the key for a known builder', () => {
-                expect(getBuilderKey(withLabel)).toBe('label');
-                expect(getBuilderKey(withLabelPie)).toBe('label_pie');
-                expect(getBuilderKey(withTooltip)).toBe('tooltips');
-                expect(getBuilderKey(withTooltipPie)).toBe('tooltips_pie');
-                expect(getBuilderKey(withAxisY)).toBe('axisY');
-                expect(getBuilderKey(withTableOptions)).toBe('table_options');
-            });
-
-            it('should return undefined for unknown builder', () => {
-                const unknownBuilder = () => ({});
-                expect(getBuilderKey(unknownBuilder)).toBeUndefined();
-            });
-        });
-
-        describe('getPresetForChart', () => {
-            it('should return preset for known chart type', () => {
-                const preset = getPresetForChart(CHART_TYPES.LINE_CHART);
-
-                expect(preset).toBeDefined();
-                expect(Array.isArray(preset)).toBe(true);
-            });
-
-            it('should include expected builders for line chart', () => {
-                const preset = getPresetForChart(CHART_TYPES.LINE_CHART);
-
-                expect(preset).toContain(withLabel);
-                expect(preset).toContain(withTooltip);
-                expect(preset).toContain(withAxisY);
-                expect(preset).toContain(withAxisX);
-                expect(preset).toContain(withSubtitle);
-            });
-
-            it('should include pie-specific builders for pie chart', () => {
-                const preset = getPresetForChart(CHART_TYPES.PIE_CHART);
-
-                expect(preset).toContain(withLabelPie);
-                expect(preset).toContain(withTooltipPie);
-                expect(preset).not.toContain(withLabel);
-                expect(preset).not.toContain(withTooltip);
-            });
-
-            it('should include gauge-specific builders for gauge chart', () => {
-                const preset = getPresetForChart(CHART_TYPES.GAUGE_CHART_ENHANCED);
-
-                expect(preset).toContain(withLabelGauge);
-                expect(preset).toContain(withTooltipGauge);
-                expect(preset).toContain(withGaugeGoal);
-                expect(preset).toContain(withGaugeSegments);
-            });
-
-            it('should return undefined for unknown chart type', () => {
-                const preset = getPresetForChart('unknown-chart');
-                expect(preset).toBeUndefined();
-            });
-        });
-
-        describe('buildSuboptionsForChart', () => {
-            it('should build suboptions object for a chart type', () => {
-                const result = buildSuboptionsForChart(CHART_TYPES.LINE_CHART);
-
-                expect(result).toBeDefined();
-                expect(typeof result).toBe('object');
-            });
-
-            it('should include expected keys for line chart', () => {
-                const result = buildSuboptionsForChart(CHART_TYPES.LINE_CHART);
-
-                expect(result).toHaveProperty('label');
-                expect(result).toHaveProperty('tooltips');
-                expect(result).toHaveProperty('axisY');
-                expect(result).toHaveProperty('axisX');
-            });
-
-            it('should include pie-specific keys for pie chart', () => {
-                const result = buildSuboptionsForChart(CHART_TYPES.PIE_CHART);
-
-                expect(result).toHaveProperty('label_pie');
-                expect(result).toHaveProperty('tooltips_pie');
-                expect(result).not.toHaveProperty('label');
-                expect(result).not.toHaveProperty('tooltips');
-            });
-
-            it('should return empty object for unknown chart type', () => {
-                const result = buildSuboptionsForChart('unknown-chart');
-
-                expect(result).toEqual({});
-            });
-
-            it('should pass config to builders', () => {
-                const config = { CHART_TYPES };
-                const result = buildSuboptionsForChart(CHART_TYPES.COLUMN_CHART, config);
-
-                // Should still work with config
-                expect(result).toHaveProperty('table_options');
-            });
-        });
-
-        describe('buildSuboptions', () => {
-            it('should build suboptions from an array of builders', () => {
-                const result = buildSuboptions([withLabel, withTooltip]);
-
-                expect(Object.keys(result)).toHaveLength(2);
-                expect(result).toHaveProperty('label');
-                expect(result).toHaveProperty('tooltips');
-            });
-
-            it('should handle empty array', () => {
-                const result = buildSuboptions([]);
-                expect(result).toEqual({});
-            });
-
-            it('should pass config to builders', () => {
-                const result = buildSuboptions([withLabelGauge], { enableGaugeDynamicGoal: true });
-
-                expect(result).toHaveProperty('label_gauge');
-            });
-
-            it('should skip unknown builders', () => {
-                const unknownBuilder = () => ({});
-                const result = buildSuboptions([withLabel, unknownBuilder, withTooltip]);
-
-                expect(Object.keys(result)).toHaveLength(2);
-                expect(result).toHaveProperty('label');
-                expect(result).toHaveProperty('tooltips');
-            });
-        });
-
-        describe('getChartTypes', () => {
-            it('should return array of chart types', () => {
-                const result = getChartTypes();
-
-                expect(Array.isArray(result)).toBe(true);
-                expect(result.length).toBeGreaterThan(0);
-            });
-
-            it('should contain all expected chart types', () => {
-                const result = getChartTypes();
-
-                expect(result).toContain('line-chart');
-                expect(result).toContain('column-chart');
-                expect(result).toContain('bar-chart');
-                expect(result).toContain('pie-chart');
-                expect(result).toContain('donut-chart');
-            });
-        });
-
-        describe('hasPreset', () => {
-            it('should return true for chart types with presets', () => {
-                expect(hasPreset(CHART_TYPES.LINE_CHART)).toBe(true);
-                expect(hasPreset(CHART_TYPES.COLUMN_CHART)).toBe(true);
-                expect(hasPreset(CHART_TYPES.PIE_CHART)).toBe(true);
-            });
-
-            it('should return false for unknown chart types', () => {
-                expect(hasPreset('unknown-chart')).toBe(false);
-                expect(hasPreset('')).toBe(false);
-            });
-        });
-    });
-
-    // =========================================================================
-    // Helper Tests
-    // =========================================================================
-
-    describe('Helpers', () => {
-        describe('chartHasVerticalDataLabelsOption', () => {
-            it('should return true for charts that support vertical labels', () => {
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.COLUMN_CHART)).toBe(true);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.COLUMN_CHART_STACKED)).toBe(true);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.PIE_CHART)).toBe(true);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.SCATTER_CHART)).toBe(true);
-            });
-
-            it('should return false for line charts', () => {
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.LINE_CHART)).toBe(false);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.LINE_CHART_SMOOTH)).toBe(false);
-            });
-
-            it('should return false for area charts', () => {
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.AREA_CHART)).toBe(false);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.AREA_CHART_SMOOTH)).toBe(false);
-            });
-
-            it('should return false for bar charts', () => {
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.BAR_CHART)).toBe(false);
-                expect(chartHasVerticalDataLabelsOption(CHART_TYPES.BAR_CHART_STACKED)).toBe(false);
-            });
-        });
-    });
-
-    // =========================================================================
-    // Index/Factory Tests
-    // =========================================================================
-
-    describe('Index Exports and createDefaultSuboptions', () => {
-        describe('createDefaultSuboptions', () => {
-            it('should create a complete suboptions object', () => {
-                const result = createDefaultSuboptions();
-
-                expect(result).toBeDefined();
-                expect(typeof result).toBe('object');
-            });
-
-            it('should include all expected suboption keys', () => {
-                const result = createDefaultSuboptions();
-                const expectedKeys = [
-                    'widget_library',
-                    'table_options',
-                    'table_options_transpose',
-                    'table_options_gauge',
-                    'table_design_options',
-                    'value',
-                    'range',
-                    'name',
-                    'subtitle',
-                    'chart',
-                    'chart_grid',
-                    'chart_forecast',
-                    'total_value_label_donut',
-                    'chart_position',
-                    'label',
-                    'label_pie',
-                    'label_gauge',
-                    'label_with_percentage',
-                    'label_with_percentage_percent_stacked',
-                    'axisY',
-                    'axisY_percent_stacked',
-                    'axisX',
-                    'ticks',
-                    'tooltips',
-                    'tooltips_pie',
-                    'tooltips_gauge',
-                    'negative_number_format',
-                    'delta_column',
-                    'delta_column_for_drill_down',
-                    'advanced',
-                    'legends',
-                    'gauge_goal',
-                    'gauge_segments',
-                    'gauge_is_absolute',
-                ];
-
-                expectedKeys.forEach(key => {
-                    expect(result).toHaveProperty(key);
-                });
-            });
-
-            it('should create 34 suboptions', () => {
-                const result = createDefaultSuboptions();
-                expect(Object.keys(result)).toHaveLength(34);
-            });
-
-            it('should pass config to builders that need it', () => {
-                const customSegments = [{ from: 0, to: 100, color: 'green', title: 'Good' }];
-
-                const result = createDefaultSuboptions({
-                    CHART_TYPES,
-                    enableGaugeDynamicGoal: true,
-                    defaultGaugeSegments: customSegments,
-                });
-
-                // Gauge segments should use custom segments
-                expect(result.gauge_segments.default_value).toEqual(customSegments);
-            });
-
-            it('should create valid SuboptionDefinition for each suboption', () => {
-                const result = createDefaultSuboptions();
-
-                Object.values(result).forEach(suboption => {
-                    expect(suboption).toHaveProperty('category_class');
-                    expect(suboption).toHaveProperty('category_label');
-                    expect(suboption).toHaveProperty('category_type');
-                });
-            });
-        });
-
-        describe('Module exports', () => {
-            it('should export all constants', () => {
-                expect(options.CHART_TYPES).toBeDefined();
-                expect(options.CHART_COLORS).toBeDefined();
-                expect(options.SUBOPTIONS_FONTS).toBeDefined();
-                expect(options.HIGHCHARTS_FONT_FAMILY).toBeDefined();
-                expect(options.HIGHCHARTS_FONT_FAMILY_CSS).toBeDefined();
-                expect(options.TOOLTIP_DEFAULT_SETTINGS).toBeDefined();
-                expect(options.TOOLTIP_DEFAULT_OPTIONS).toBeDefined();
-                expect(options.LABEL_DEFAULT_SETTINGS).toBeDefined();
-                expect(options.LABEL_DEFAULT_OPTIONS).toBeDefined();
-                expect(options.SUBOPTIONS_FONT_SIZE_VALUES).toBeDefined();
-                expect(options.DEFAULT_CATEGORY_CLASS).toBeDefined();
-            });
-
-            it('should export all element factories as functions', () => {
-                expect(typeof options.createToggle).toBe('function');
-                expect(typeof options.createCheckbox).toBe('function');
-                expect(typeof options.createInput).toBe('function');
-                expect(typeof options.createSelect).toBe('function');
-                expect(typeof options.createRadio).toBe('function');
-                expect(typeof options.createColorPicker).toBe('function');
-                expect(typeof options.createDivider).toBe('function');
-                expect(typeof options.createTextarea).toBe('function');
-                expect(typeof options.createTag).toBe('function');
-                expect(typeof options.createFontStylingGroup).toBe('function');
-                expect(typeof options.createLabelStyleGroup).toBe('function');
-                expect(typeof options.createTooltipStyleGroup).toBe('function');
-            });
-
-            it('should export all label builders as functions', () => {
-                expect(typeof options.withLabel).toBe('function');
-                expect(typeof options.withLabelPie).toBe('function');
-                expect(typeof options.withLabelGauge).toBe('function');
-                expect(typeof options.withLabelWithPercentage).toBe('function');
-                expect(typeof options.withLabelWithPercentagePercentStacked).toBe('function');
-            });
-
-            it('should export all tooltip builders as functions', () => {
-                expect(typeof options.withTooltip).toBe('function');
-                expect(typeof options.withTooltipPie).toBe('function');
-                expect(typeof options.withTooltipGauge).toBe('function');
-            });
-
-            it('should export all axis builders as functions', () => {
-                expect(typeof options.withAxisY).toBe('function');
-                expect(typeof options.withAxisYPercentStacked).toBe('function');
-                expect(typeof options.withAxisX).toBe('function');
-            });
-
-            it('should export all table builders as functions', () => {
-                expect(typeof options.withTableOptions).toBe('function');
-                expect(typeof options.withTableOptionsTranspose).toBe('function');
-                expect(typeof options.withTableOptionsGauge).toBe('function');
-                expect(typeof options.withTableDesignOptions).toBe('function');
-            });
-
-            it('should export all chart config builders as functions', () => {
-                expect(typeof options.withChart).toBe('function');
-                expect(typeof options.withChartGrid).toBe('function');
-                expect(typeof options.withChartForecast).toBe('function');
-                expect(typeof options.withChartPosition).toBe('function');
-            });
-
-            it('should export all other builders as functions', () => {
-                expect(typeof options.withWidgetLibrary).toBe('function');
-                expect(typeof options.withSubtitle).toBe('function');
-                expect(typeof options.withName).toBe('function');
-                expect(typeof options.withNegativeNumberFormat).toBe('function');
-                expect(typeof options.withValue).toBe('function');
-                expect(typeof options.withRange).toBe('function');
-                expect(typeof options.withTicks).toBe('function');
-                expect(typeof options.withLegends).toBe('function');
-                expect(typeof options.withDeltaColumn).toBe('function');
-                expect(typeof options.withDeltaColumnForDrillDown).toBe('function');
-                expect(typeof options.withAdvanced).toBe('function');
-                expect(typeof options.withTotalValueLabelDonut).toBe('function');
-                expect(typeof options.withGaugeGoal).toBe('function');
-                expect(typeof options.withGaugeSegments).toBe('function');
-                expect(typeof options.withGaugeIsAbsolute).toBe('function');
-            });
-
-            it('should export preset utilities', () => {
-                expect(options.CHART_PRESETS).toBeDefined();
-                expect(options.BUILDER_KEY_MAP).toBeDefined();
-                expect(typeof options.getBuilderKey).toBe('function');
-                expect(typeof options.getPresetForChart).toBe('function');
-                expect(typeof options.buildSuboptionsForChart).toBe('function');
-                expect(typeof options.buildSuboptions).toBe('function');
-                expect(typeof options.getChartTypes).toBe('function');
-                expect(typeof options.hasPreset).toBe('function');
-            });
-
-            it('should export helper functions', () => {
-                expect(typeof options.chartHasVerticalDataLabelsOption).toBe('function');
-            });
-
-            it('should export reusable disabled conditions', () => {
-                expect(options.LABEL_DISABLED_CONDITION).toBeDefined();
-                expect(options.LABEL_PIE_DISABLED_CONDITION).toBeDefined();
-                expect(options.TOOLTIP_DISABLED_CONDITION).toBeDefined();
-                expect(options.TOOLTIP_PIE_DISABLED_CONDITION).toBeDefined();
-            });
-
-            it('should export reusable elements', () => {
-                expect(options.LABEL_SHOW_TOGGLE).toBeDefined();
-                expect(options.LABEL_PIE_SHOW_TOGGLE).toBeDefined();
-                expect(options.LABEL_OVERLAP_TOGGLE).toBeDefined();
-                expect(options.TOOLTIP_SHOW_TOGGLE).toBeDefined();
-                expect(options.TOOLTIP_PIE_SHOW_TOGGLE).toBeDefined();
-                expect(options.GAUGE_SHOW_TOGGLE).toBeDefined();
-            });
-
-            it('should export createDefaultSuboptions', () => {
-                expect(typeof options.createDefaultSuboptions).toBe('function');
-            });
-        });
-    });
-});