@tcn/ui-table 2.2.0 → 2.3.0

package/src/components/table_filter_panel/field_filters/number_range_field_filter_presenter.test.ts

@@ -0,0 +1,582 @@
+import { Node } from 'clarity-pattern-parser';
+import { NumberRangeFieldFilterPresenter } from './number_range_field_filter_presenter.js';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+describe('NumberRangeFieldFilterPresenter', () => {
+  let presenter: NumberRangeFieldFilterPresenter;
+  let mockFieldRegistry: any;
+
+  beforeEach(() => {
+    presenter = new NumberRangeFieldFilterPresenter('test_field');
+    mockFieldRegistry = {
+      registerFieldFilter: vi.fn(),
+      unregisterFieldFilter: vi.fn(),
+    };
+  });
+
+  describe('constructor', () => {
+    it('should initialize with the correct field name', () => {
+      const presenter = new NumberRangeFieldFilterPresenter('custom_field');
+      expect(presenter.getFilterString()).toBe('');
+    });
+
+    it('should initialize with default values', () => {
+      expect(presenter.getFilterString()).toBe('');
+    });
+  });
+
+  describe('setMinValue', () => {
+    it('should set the minimum value when setMinValue is called with a number', () => {
+      presenter.setMinValue(10);
+      expect(presenter.getFilterString()).toBe('test_field >= 10');
+    });
+
+    it('should set the minimum value when setMinValue is called with null', () => {
+      presenter.setMinValue(10);
+      presenter.setMinValue(null);
+      expect(presenter.getFilterString()).toBe('');
+    });
+
+    it('should handle zero values', () => {
+      presenter.setMinValue(0);
+      expect(presenter.getFilterString()).toBe('test_field >= 0');
+    });
+
+    it('should handle negative values', () => {
+      presenter.setMinValue(-10);
+      expect(presenter.getFilterString()).toBe('test_field >= -10');
+    });
+
+    it('should handle decimal values', () => {
+      presenter.setMinValue(3.14);
+      expect(presenter.getFilterString()).toBe('test_field >= 3.14');
+    });
+
+    it('should trigger onChange handlers when min value is set', () => {
+      const onChangeHandler = vi.fn();
+      presenter.onChange(onChangeHandler);
+
+      presenter.setMinValue(10);
+
+      expect(onChangeHandler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('setMaxValue', () => {
+    it('should set the maximum value when setMaxValue is called with a number', () => {
+      presenter.setMaxValue(100);
+      expect(presenter.getFilterString()).toBe('test_field <= 100');
+    });
+
+    it('should set the maximum value when setMaxValue is called with null', () => {
+      presenter.setMaxValue(100);
+      presenter.setMaxValue(null);
+      expect(presenter.getFilterString()).toBe('');
+    });
+
+    it('should handle zero values', () => {
+      presenter.setMaxValue(0);
+      expect(presenter.getFilterString()).toBe('test_field <= 0');
+    });
+
+    it('should handle negative values', () => {
+      presenter.setMaxValue(-5);
+      expect(presenter.getFilterString()).toBe('test_field <= -5');
+    });
+
+    it('should handle decimal values', () => {
+      presenter.setMaxValue(2.718);
+      expect(presenter.getFilterString()).toBe('test_field <= 2.718');
+    });
+
+    it('should trigger onChange handlers when max value is set', () => {
+      const onChangeHandler = vi.fn();
+      presenter.onChange(onChangeHandler);
+
+      presenter.setMaxValue(100);
+
+      expect(onChangeHandler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('getFilterString', () => {
+    it('should return empty string when both values are null', () => {
+      expect(presenter.getFilterString()).toBe('');
+    });
+
+    it('should return min value filter when only min is set', () => {
+      presenter.setMinValue(10);
+      expect(presenter.getFilterString()).toBe('test_field >= 10');
+    });
+
+    it('should return max value filter when only max is set', () => {
+      presenter.setMaxValue(100);
+      expect(presenter.getFilterString()).toBe('test_field <= 100');
+    });
+
+    it('should return range filter when both values are set', () => {
+      presenter.setMinValue(10);
+      presenter.setMaxValue(100);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 10 AND test_field <= 100)'
+      );
+    });
+
+    it('should handle zero values correctly', () => {
+      presenter.setMinValue(0);
+      presenter.setMaxValue(0);
+      expect(presenter.getFilterString()).toBe('(test_field >= 0 AND test_field <= 0)');
+    });
+
+    it('should handle negative values correctly', () => {
+      presenter.setMinValue(-100);
+      presenter.setMaxValue(-10);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= -100 AND test_field <= -10)'
+      );
+    });
+
+    it('should handle decimal values correctly', () => {
+      presenter.setMinValue(1.5);
+      presenter.setMaxValue(9.9);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 1.5 AND test_field <= 9.9)'
+      );
+    });
+
+    it('should handle large numbers', () => {
+      presenter.setMinValue(1000000);
+      presenter.setMaxValue(9999999);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 1000000 AND test_field <= 9999999)'
+      );
+    });
+  });
+
+  describe('onChange', () => {
+    it('should register onChange handler and return unsubscribe function', () => {
+      const onChangeHandler = vi.fn();
+      const unsubscribe = presenter.onChange(onChangeHandler);
+
+      presenter.setMinValue(10);
+      expect(onChangeHandler).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      presenter.setMaxValue(100);
+      expect(onChangeHandler).toHaveBeenCalledTimes(1); // Should not be called again
+    });
+
+    it('should handle multiple onChange handlers', () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      presenter.onChange(handler1);
+      presenter.onChange(handler2);
+
+      presenter.setMinValue(10);
+
+      expect(handler1).toHaveBeenCalledTimes(1);
+      expect(handler2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle removing onChange handlers', () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      const unsubscribe1 = presenter.onChange(handler1);
+      presenter.onChange(handler2);
+
+      unsubscribe1();
+      presenter.setMaxValue(100);
+
+      expect(handler1).not.toHaveBeenCalled();
+      expect(handler2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should trigger handlers for both min and max value changes', () => {
+      const onChangeHandler = vi.fn();
+      presenter.onChange(onChangeHandler);
+
+      presenter.setMinValue(10);
+      presenter.setMaxValue(100);
+
+      expect(onChangeHandler).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('setFieldRegistry', () => {
+    it('should register the field filter with the registry', () => {
+      presenter.setFieldRegistry(mockFieldRegistry);
+
+      expect(mockFieldRegistry.registerFieldFilter).toHaveBeenCalledWith(
+        'test_field',
+        presenter
+      );
+    });
+
+    it('should store the field registry reference', () => {
+      presenter.setFieldRegistry(mockFieldRegistry);
+
+      // Test that dispose can call unregisterFieldFilter
+      presenter.dispose();
+      expect(mockFieldRegistry.unregisterFieldFilter).toHaveBeenCalledWith('test_field');
+    });
+  });
+
+  describe('setFilterState', () => {
+    it('should parse single min value filter from AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '>=' },
+                { name: 'number', value: '10' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe('test_field >= 10');
+    });
+
+    it('should parse single max value filter from AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '<=' },
+                { name: 'number', value: '100' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe('test_field <= 100');
+    });
+
+    it('should parse range filter with min >= and max <= from AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '>=' },
+                { name: 'number', value: '10' },
+              ],
+            },
+          },
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '<=' },
+                { name: 'number', value: '100' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 10 AND test_field <= 100)'
+      );
+    });
+
+    it('should parse range filter with max <= and min >= from AST (reversed order)', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '<=' },
+                { name: 'number', value: '100' },
+              ],
+            },
+          },
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '>=' },
+                { name: 'number', value: '10' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 10 AND test_field <= 100)'
+      );
+    });
+
+    it('should handle case when field is not found in AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([]),
+      } as unknown as Node;
+
+      presenter.setMinValue(10);
+      presenter.setMaxValue(100);
+
+      presenter.setFilterState(mockAst);
+
+      // Should not change existing state
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 10 AND test_field <= 100)'
+      );
+    });
+
+    it('should handle case when field node has no parent', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: null,
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setMinValue(10);
+      presenter.setMaxValue(100);
+
+      presenter.setFilterState(mockAst);
+
+      // Should not change existing state
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 10 AND test_field <= 100)'
+      );
+    });
+
+    it('should handle decimal values from AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '>=' },
+                { name: 'number', value: '1.5' },
+              ],
+            },
+          },
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '<=' },
+                { name: 'number', value: '9.9' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 1.5 AND test_field <= 9.9)'
+      );
+    });
+
+    it('should handle negative values from AST', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '>=' },
+                { name: 'number', value: '-100' },
+              ],
+            },
+          },
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '<=' },
+                { name: 'number', value: '-10' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= -100 AND test_field <= -10)'
+      );
+    });
+
+    it('should ignore non-range operators', () => {
+      const mockAst = {
+        findAll: vi.fn().mockReturnValue([
+          {
+            name: 'plain-field',
+            value: 'test_field',
+            parent: {
+              name: 'infix-expression',
+              children: [
+                { name: 'plain-field', value: 'test_field' },
+                { name: 'operator', value: '=' },
+                { name: 'number', value: '42' },
+              ],
+            },
+          },
+        ]),
+      } as unknown as Node;
+
+      presenter.setFilterState(mockAst);
+
+      // Should not change existing state
+      expect(presenter.getFilterString()).toBe('');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should unregister field filter from registry when registry is set', () => {
+      presenter.setFieldRegistry(mockFieldRegistry);
+      presenter.dispose();
+
+      expect(mockFieldRegistry.unregisterFieldFilter).toHaveBeenCalledWith('test_field');
+    });
+
+    it('should not call unregisterFieldFilter when no registry is set', () => {
+      presenter.dispose();
+
+      expect(mockFieldRegistry.unregisterFieldFilter).not.toHaveBeenCalled();
+    });
+
+    it('should clear onChange handlers', () => {
+      const onChangeHandler = vi.fn();
+      presenter.onChange(onChangeHandler);
+
+      presenter.dispose();
+      presenter.setMinValue(10);
+
+      expect(onChangeHandler).not.toHaveBeenCalled();
+    });
+
+    it('should clear field registry reference', () => {
+      presenter.setFieldRegistry(mockFieldRegistry);
+      presenter.dispose();
+
+      // Should not call unregisterFieldFilter again
+      presenter.dispose();
+      expect(mockFieldRegistry.unregisterFieldFilter).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('edge cases and error handling', () => {
+    it('should handle rapid successive value changes', () => {
+      const onChangeHandler = vi.fn();
+      presenter.onChange(onChangeHandler);
+
+      presenter.setMinValue(10);
+      presenter.setMaxValue(100);
+      presenter.setMinValue(20);
+      presenter.setMaxValue(200);
+
+      expect(onChangeHandler).toHaveBeenCalledTimes(4);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= 20 AND test_field <= 200)'
+      );
+    });
+
+    it('should handle very large numbers', () => {
+      presenter.setMinValue(Number.MAX_SAFE_INTEGER);
+      presenter.setMaxValue(Number.MAX_SAFE_INTEGER);
+      expect(presenter.getFilterString()).toBe(
+        `(test_field >= ${Number.MAX_SAFE_INTEGER} AND test_field <= ${Number.MAX_SAFE_INTEGER})`
+      );
+    });
+
+    it('should handle very small numbers', () => {
+      presenter.setMinValue(Number.MIN_SAFE_INTEGER);
+      presenter.setMaxValue(Number.MIN_SAFE_INTEGER);
+      expect(presenter.getFilterString()).toBe(
+        `(test_field >= ${Number.MIN_SAFE_INTEGER} AND test_field <= ${Number.MIN_SAFE_INTEGER})`
+      );
+    });
+
+    it('should handle NaN values gracefully', () => {
+      presenter.setMinValue(NaN);
+      presenter.setMaxValue(NaN);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= NaN AND test_field <= NaN)'
+      );
+    });
+
+    it('should handle Infinity values', () => {
+      presenter.setMinValue(Infinity);
+      presenter.setMaxValue(Infinity);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= Infinity AND test_field <= Infinity)'
+      );
+    });
+
+    it('should handle negative Infinity values', () => {
+      presenter.setMinValue(-Infinity);
+      presenter.setMaxValue(-Infinity);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= -Infinity AND test_field <= -Infinity)'
+      );
+    });
+
+    it('should handle mixed edge cases', () => {
+      presenter.setMinValue(-Infinity);
+      presenter.setMaxValue(Infinity);
+      expect(presenter.getFilterString()).toBe(
+        '(test_field >= -Infinity AND test_field <= Infinity)'
+      );
+    });
+  });
+});

package/src/components/table_filter_panel/field_filters/number_range_field_filter_presenter.ts

@@ -0,0 +1,110 @@
+import { Signal } from '@tcn/state';
+import { Node } from 'clarity-pattern-parser';
+import { FieldFilterRegistry, FieldFilterStrategy } from './field_filter_strategy.js';
+
+export class NumberRangeFieldFilterPresenter implements FieldFilterStrategy {
+  private _fieldName: string;
+  private _fieldFilterRegistry: FieldFilterRegistry | null = null;
+  private _minValue = new Signal<number | null>(null);
+  private _maxValue = new Signal<number | null>(null);
+  private _onChangeHandlers = new Set<() => void>();
+
+  private _broadcasts = {
+    minValue: this._minValue.broadcast,
+    maxValue: this._maxValue.broadcast,
+  };
+
+  constructor(fieldName: string) {
+    this._fieldName = fieldName;
+  }
+
+  get broadcasts() {
+    return this._broadcasts;
+  }
+
+  getFilterString() {
+    const minValue = this._minValue.get();
+    const maxValue = this._maxValue.get();
+    if (minValue !== null && maxValue !== null) {
+      return `(${this._fieldName} >= ${minValue} AND ${this._fieldName} <= ${maxValue})`;
+    } else if (minValue !== null) {
+      return `${this._fieldName} >= ${minValue}`;
+    } else if (maxValue !== null) {
+      return `${this._fieldName} <= ${maxValue}`;
+    }
+    return '';
+  }
+
+  onChange(handler: () => void) {
+    this._onChangeHandlers.add(handler);
+    return () => {
+      this._onChangeHandlers.delete(handler);
+    };
+  }
+
+  setMinValue(minValue: number | null) {
+    this._minValue.set(minValue);
+    this._onChangeHandlers.forEach(handler => handler());
+  }
+
+  setMaxValue(maxValue: number | null) {
+    this._maxValue.set(maxValue);
+    this._onChangeHandlers.forEach(handler => handler());
+  }
+
+  setFieldRegistry(fieldRegistry: FieldFilterRegistry) {
+    this._fieldFilterRegistry = fieldRegistry;
+    fieldRegistry.registerFieldFilter(this._fieldName, this);
+  }
+
+  setFilterState(filterAst: Node) {
+    const fieldNodes = filterAst.findAll(
+      (n: Node) => n.name === 'plain-field' && n.value === this._fieldName
+    );
+
+    if (fieldNodes.length === 0) {
+      return;
+    }
+
+    if (fieldNodes.length === 1) {
+      const operatorNode = fieldNodes[0].parent?.children[1];
+      const valueNode = fieldNodes[0].parent?.children[2];
+      if (operatorNode?.value === '>=' && valueNode != null) {
+        this.setMinValue(Number(valueNode?.value));
+      } else if (operatorNode?.value === '<=' && valueNode != null) {
+        this.setMaxValue(Number(valueNode?.value));
+      }
+      return;
+    }
+
+    if (fieldNodes.length === 2) {
+      const operatorOneNode = fieldNodes[0].parent?.children[1];
+      const operatorTwoNode = fieldNodes[1].parent?.children[1];
+      const valueOneNode = fieldNodes[0].parent?.children[2];
+      const valueTwoNode = fieldNodes[1].parent?.children[2];
+      if (
+        operatorOneNode?.value === '>=' &&
+        operatorTwoNode?.value === '<=' &&
+        valueOneNode != null &&
+        valueTwoNode != null
+      ) {
+        this.setMinValue(Number(valueOneNode?.value));
+        this.setMaxValue(Number(valueTwoNode?.value));
+      } else if (
+        operatorOneNode?.value === '<=' &&
+        operatorTwoNode?.value === '>=' &&
+        valueOneNode != null &&
+        valueTwoNode != null
+      ) {
+        this.setMaxValue(Number(valueOneNode?.value));
+        this.setMinValue(Number(valueTwoNode?.value));
+      }
+    }
+  }
+
+  dispose() {
+    this._fieldFilterRegistry?.unregisterFieldFilter(this._fieldName);
+    this._fieldFilterRegistry = null;
+    this._onChangeHandlers.clear();
+  }
+}