@datarailsshared/dr_renderer 1.5.150 → 1.5.159

package/tests/pivot-table/freeze-panes/constants.test.js

@@ -0,0 +1,92 @@
+const {
+    FREEZE_PANES_MODES,
+    TRANSFORM_CSS_CLASSES,
+    STICKY_CSS_CLASSES,
+    FREEZE_PANES_THRESHOLD,
+    FREEZE_PANES_THRESHOLD_CHECK_DEBOUNCE_MS,
+} = require('../../../src/pivot-table/freeze-panes/constants');
+
+describe('freeze-panes/constants', () => {
+    describe('FREEZE_PANES_MODES', () => {
+        it('should have TRANSFORM mode with value "transform"', () => {
+            expect(FREEZE_PANES_MODES.TRANSFORM).toBe('transform');
+        });
+
+        it('should have STICKY mode with value "sticky"', () => {
+            expect(FREEZE_PANES_MODES.STICKY).toBe('sticky');
+        });
+
+        it('should only have two modes', () => {
+            expect(Object.keys(FREEZE_PANES_MODES)).toHaveLength(2);
+        });
+    });
+
+    describe('TRANSFORM_CSS_CLASSES', () => {
+        it('should have AXIS class', () => {
+            expect(TRANSFORM_CSS_CLASSES.AXIS).toBe('axis-freeze-pane');
+        });
+
+        it('should have VERTICAL class', () => {
+            expect(TRANSFORM_CSS_CLASSES.VERTICAL).toBe('vertical-freeze-pane');
+        });
+
+        it('should have HORIZONTAL class', () => {
+            expect(TRANSFORM_CSS_CLASSES.HORIZONTAL).toBe('horizontal-freeze-pane');
+        });
+
+        it('should have exactly three classes', () => {
+            expect(Object.keys(TRANSFORM_CSS_CLASSES)).toHaveLength(3);
+        });
+    });
+
+    describe('STICKY_CSS_CLASSES', () => {
+        it('should have CONTAINER class', () => {
+            expect(STICKY_CSS_CLASSES.CONTAINER).toBe('sticky-freeze-panes-container');
+        });
+
+        it('should have AXIS class', () => {
+            expect(STICKY_CSS_CLASSES.AXIS).toBe('sticky-axis-freeze-pane');
+        });
+
+        it('should have VERTICAL class', () => {
+            expect(STICKY_CSS_CLASSES.VERTICAL).toBe('sticky-vertical-freeze-pane');
+        });
+
+        it('should have HORIZONTAL class', () => {
+            expect(STICKY_CSS_CLASSES.HORIZONTAL).toBe('sticky-horizontal-freeze-pane');
+        });
+
+        it('should have ROWS_DISABLED class', () => {
+            expect(STICKY_CSS_CLASSES.ROWS_DISABLED).toBe('freeze-panes-rows-disabled');
+        });
+
+        it('should have COLUMNS_DISABLED class', () => {
+            expect(STICKY_CSS_CLASSES.COLUMNS_DISABLED).toBe('freeze-panes-columns-disabled');
+        });
+
+        it('should have exactly six classes', () => {
+            expect(Object.keys(STICKY_CSS_CLASSES)).toHaveLength(6);
+        });
+    });
+
+    describe('FREEZE_PANES_THRESHOLD', () => {
+        it('should be 0.7 (70%)', () => {
+            expect(FREEZE_PANES_THRESHOLD).toBe(0.7);
+        });
+
+        it('should be a number between 0 and 1', () => {
+            expect(FREEZE_PANES_THRESHOLD).toBeGreaterThan(0);
+            expect(FREEZE_PANES_THRESHOLD).toBeLessThanOrEqual(1);
+        });
+    });
+
+    describe('FREEZE_PANES_THRESHOLD_CHECK_DEBOUNCE_MS', () => {
+        it('should be 150 milliseconds', () => {
+            expect(FREEZE_PANES_THRESHOLD_CHECK_DEBOUNCE_MS).toBe(150);
+        });
+
+        it('should be a positive number', () => {
+            expect(FREEZE_PANES_THRESHOLD_CHECK_DEBOUNCE_MS).toBeGreaterThan(0);
+        });
+    });
+});

package/tests/pivot-table/freeze-panes/index.test.js

@@ -0,0 +1,193 @@
+const freezePanes = require('../../../src/pivot-table/freeze-panes/index');
+const { FREEZE_PANES_MODES, STICKY_CSS_CLASSES, TRANSFORM_CSS_CLASSES } = require('../../../src/pivot-table/freeze-panes/constants');
+
+describe('freeze-panes/index', () => {
+    beforeEach(() => {
+        // Reset mode to default before each test
+        freezePanes.setMode(FREEZE_PANES_MODES.STICKY);
+    });
+
+    describe('setMode / getMode', () => {
+        it('should return sticky as default mode', () => {
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+
+        it('should set mode to transform', () => {
+            freezePanes.setMode(FREEZE_PANES_MODES.TRANSFORM);
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.TRANSFORM);
+        });
+
+        it('should set mode to sticky', () => {
+            freezePanes.setMode(FREEZE_PANES_MODES.TRANSFORM);
+            freezePanes.setMode(FREEZE_PANES_MODES.STICKY);
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+
+        it('should not change mode for invalid value', () => {
+            freezePanes.setMode('invalid');
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+
+        it('should not change mode for null', () => {
+            freezePanes.setMode(null);
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+
+        it('should not change mode for undefined', () => {
+            freezePanes.setMode(undefined);
+            expect(freezePanes.getMode()).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+    });
+
+    describe('parseOptions', () => {
+        it('should parse enabled option when freeze_panes is true', () => {
+            const result = freezePanes.parseOptions({ freeze_panes: true });
+            expect(result.enabled).toBe(true);
+            expect(result.mode).toBe(FREEZE_PANES_MODES.STICKY);
+        });
+
+        it('should parse disabled option when freeze_panes is false', () => {
+            const result = freezePanes.parseOptions({ freeze_panes: false });
+            expect(result.enabled).toBe(false);
+        });
+
+        it('should parse disabled option when freeze_panes is undefined', () => {
+            const result = freezePanes.parseOptions({});
+            expect(result.enabled).toBe(false);
+        });
+
+        it('should parse disabled option when freeze_panes is null', () => {
+            const result = freezePanes.parseOptions({ freeze_panes: null });
+            expect(result.enabled).toBe(false);
+        });
+
+        it('should use global mode configuration', () => {
+            freezePanes.setMode(FREEZE_PANES_MODES.TRANSFORM);
+            const result = freezePanes.parseOptions({ freeze_panes: true });
+            expect(result.mode).toBe(FREEZE_PANES_MODES.TRANSFORM);
+        });
+
+        it('should handle truthy values for freeze_panes', () => {
+            const result = freezePanes.parseOptions({ freeze_panes: 1 });
+            expect(result.enabled).toBe(true);
+        });
+
+        it('should handle falsy values for freeze_panes', () => {
+            const result = freezePanes.parseOptions({ freeze_panes: 0 });
+            expect(result.enabled).toBe(false);
+        });
+    });
+
+    describe('getClassStrings', () => {
+        describe('sticky mode', () => {
+            it('should return sticky class strings when enabled', () => {
+                const options = { enabled: true, mode: FREEZE_PANES_MODES.STICKY };
+                const result = freezePanes.getClassStrings(options);
+
+                expect(result.horizontal).toBe(' ' + STICKY_CSS_CLASSES.HORIZONTAL);
+                expect(result.vertical).toBe(' ' + STICKY_CSS_CLASSES.VERTICAL);
+                expect(result.axis).toBe(' ' + STICKY_CSS_CLASSES.AXIS);
+            });
+
+            it('should return empty strings when disabled', () => {
+                const options = { enabled: false, mode: FREEZE_PANES_MODES.STICKY };
+                const result = freezePanes.getClassStrings(options);
+
+                expect(result.horizontal).toBe('');
+                expect(result.vertical).toBe('');
+                expect(result.axis).toBe('');
+            });
+        });
+
+        describe('transform mode', () => {
+            it('should return transform class strings when enabled', () => {
+                const options = { enabled: true, mode: FREEZE_PANES_MODES.TRANSFORM };
+                const result = freezePanes.getClassStrings(options);
+
+                expect(result.horizontal).toBe(' ' + TRANSFORM_CSS_CLASSES.HORIZONTAL);
+                expect(result.vertical).toBe(' ' + TRANSFORM_CSS_CLASSES.VERTICAL);
+                expect(result.axis).toBe(' ' + TRANSFORM_CSS_CLASSES.AXIS);
+            });
+
+            it('should return empty strings when disabled', () => {
+                const options = { enabled: false, mode: FREEZE_PANES_MODES.TRANSFORM };
+                const result = freezePanes.getClassStrings(options);
+
+                expect(result.horizontal).toBe('');
+                expect(result.vertical).toBe('');
+                expect(result.axis).toBe('');
+            });
+        });
+    });
+
+    describe('initialize', () => {
+        let container;
+
+        beforeEach(() => {
+            container = document.createElement('div');
+            document.body.appendChild(container);
+        });
+
+        afterEach(() => {
+            document.body.removeChild(container);
+        });
+
+        it('should return undefined when not enabled', () => {
+            const options = { enabled: false, mode: FREEZE_PANES_MODES.STICKY };
+            const result = freezePanes.initialize(container, options, { rowAttrsLength: 2 });
+            expect(result).toBeUndefined();
+        });
+
+        it('should return destroy function for sticky mode when enabled', () => {
+            const table = document.createElement('table');
+            table.className = 'pvtTable';
+            table.innerHTML = '<thead><tr><th>Header</th></tr></thead><tbody><tr><td>Cell</td></tr></tbody>';
+            container.appendChild(table);
+
+            // Mock ResizeObserver
+            const mockDisconnect = jest.fn();
+            global.ResizeObserver = jest.fn().mockImplementation(() => ({
+                observe: jest.fn(),
+                disconnect: mockDisconnect,
+            }));
+
+            const options = { enabled: true, mode: FREEZE_PANES_MODES.STICKY };
+            const result = freezePanes.initialize(container, options, { rowAttrsLength: 1 });
+
+            expect(result).toBeDefined();
+            expect(result.destroy).toBeInstanceOf(Function);
+
+            result.destroy();
+            expect(mockDisconnect).toHaveBeenCalled();
+        });
+
+        it('should return object with destroy function for transform mode when enabled', () => {
+            const table = document.createElement('table');
+            table.className = 'pvtTable';
+            container.appendChild(table);
+
+            const options = { enabled: true, mode: FREEZE_PANES_MODES.TRANSFORM };
+            const result = freezePanes.initialize(container, options, { rowAttrsLength: 1 });
+
+            expect(result).toBeDefined();
+            expect(result).toHaveProperty('destroy');
+            expect(typeof result.destroy).toBe('function');
+        });
+
+        it('should apply container class for sticky mode', () => {
+            const table = document.createElement('table');
+            table.className = 'pvtTable';
+            container.appendChild(table);
+
+            global.ResizeObserver = jest.fn().mockImplementation(() => ({
+                observe: jest.fn(),
+                disconnect: jest.fn(),
+            }));
+
+            const options = { enabled: true, mode: FREEZE_PANES_MODES.STICKY };
+            freezePanes.initialize(container, options, { rowAttrsLength: 1 });
+
+            expect(container.classList.contains(STICKY_CSS_CLASSES.CONTAINER)).toBe(true);
+        });
+    });
+});