@controleonline/ui-default 1.0.272 → 1.0.273

package/src/tests/react/components/help/DefaultTooltip.test.js

@@ -0,0 +1,93 @@
+/* global jest */
+
+const React = require('react');
+const TestRenderer = require('react-test-renderer');
+const {act} = TestRenderer;
+const {describe, expect, it} = global;
+
+jest.mock('react-native', () => {
+  const React = require('react');
+  const component = name => props => React.createElement(name, props, props.children);
+
+  return {
+    Modal: props =>
+      React.createElement('modal', props, props.visible ? props.children : null),
+    Pressable: component('pressable'),
+    StyleSheet: {create: styles => styles},
+    Text: component('text'),
+    TouchableOpacity: component('touchable-opacity'),
+    View: component('view'),
+  };
+});
+
+const DefaultTooltip = require('../../../../react/components/help/DefaultTooltip').default;
+
+describe('DefaultTooltip', () => {
+  it('keeps the existing text message contract', () => {
+    let renderer;
+    act(() => {
+      renderer = TestRenderer.create(
+        React.createElement(DefaultTooltip, {
+          message: 'Ajuda já existente',
+          testID: 'message-trigger',
+        }),
+      );
+    });
+
+    const trigger = renderer.root
+      .findAllByType('touchable-opacity')
+      .find(node => node.props.testID === 'message-trigger');
+
+    act(() => trigger.props.onPress());
+
+    const renderedText = renderer.root
+      .findAllByType('text')
+      .flatMap(node => node.children)
+      .join(' ');
+    expect(renderedText).toContain('Ajuda já existente');
+  });
+
+  it('renders structured rows and closes from the action or backdrop', () => {
+    let renderer;
+    act(() => {
+      renderer = TestRenderer.create(
+        React.createElement(DefaultTooltip, {
+          backdropTestID: 'tooltip-backdrop',
+          closeAccessibilityLabel: 'Fechar detalhes',
+          dialogTestID: 'tooltip-dialog',
+          label: 'i',
+          rows: [
+            {key: 'company', label: 'Empresa', value: 'GYROS'},
+            {key: 'device', label: 'Device', value: null},
+          ],
+          testID: 'tooltip-trigger',
+          title: 'Detalhes',
+        }),
+      );
+    });
+
+    expect(renderer.root.findAllByProps({testID: 'tooltip-dialog'})).toHaveLength(0);
+
+    const trigger = renderer.root
+      .findAllByType('touchable-opacity')
+      .find(node => node.props.testID === 'tooltip-trigger');
+
+    act(() => trigger.props.onPress());
+
+    const renderedText = renderer.root
+      .findAllByType('text')
+      .flatMap(node => node.children)
+      .join(' ');
+    expect(renderedText).toContain('GYROS');
+    expect(renderedText).toContain('Não configurado');
+
+    act(() =>
+      renderer.root.findByProps({accessibilityLabel: 'Fechar detalhes'}).props.onPress(),
+    );
+    expect(renderer.root.findAllByProps({testID: 'tooltip-dialog'})).toHaveLength(0);
+
+    act(() => trigger.props.onPress());
+    act(() => renderer.root.findByProps({testID: 'tooltip-backdrop'}).props.onPress());
+    expect(renderer.root.findAllByProps({testID: 'tooltip-dialog'})).toHaveLength(0);
+  });
+});

package/src/tests/react/components/table/DefaultTable.utils.test.js

@@ -21,6 +21,7 @@ jest.mock('@controleonline/ui-common/src/react/utils/dateRangeFilter', () => ({
 const {
   getColumnMinWidth,
   getColumnStyle,
+  parseSortNumber,
 } = require('../../../../react/components/table/DefaultTable.utils');
 
 describe('DefaultTable utils', () => {
@@ -34,4 +35,13 @@ describe('DefaultTable utils', () => {
       ]),
     );
   });
+
+  it('parses Brazilian thousand and decimal masks as numbers', () => {
+    expect(parseSortNumber('1.234,56')).toBeCloseTo(1234.56);
+    expect(parseSortNumber('10')).toBe(10);
+    expect(parseSortNumber('2')).toBe(2);
+    expect(parseSortNumber('1.234')).toBe(1234);
+    expect(parseSortNumber('12/03/2024')).toBeNaN();
+    expect(parseSortNumber('abc')).toBeNaN();
+  });
 });

package/src/tests/react/components/table/DefaultTableRowActions.test.js

@@ -0,0 +1,23 @@
+const React = require('react');
+const {describe, expect, it} = require('@jest/globals');
+
+const {
+  hasDefaultTableRowActionsComponent,
+  resolveDefaultTableRowActionsWidth,
+} = require('../../../../react/components/table/DefaultTableRowActions');
+
+describe('DefaultTableRowActions helpers', () => {
+  it('accepts function and element types as custom row actions', () => {
+    expect(hasDefaultTableRowActionsComponent(() => null)).toBe(true);
+    expect(hasDefaultTableRowActionsComponent(React.createElement('span'))).toBe(true);
+    expect(hasDefaultTableRowActionsComponent(null)).toBe(false);
+    expect(hasDefaultTableRowActionsComponent('pdf')).toBe(false);
+  });
+
+  it('uses configured width and falls back to 140', () => {
+    expect(resolveDefaultTableRowActionsWidth({rowActionsWidth: 168})).toBe(168);
+    expect(resolveDefaultTableRowActionsWidth({actionsColumnWidth: 96})).toBe(96);
+    expect(resolveDefaultTableRowActionsWidth({rowActionsWidth: 0})).toBe(140);
+    expect(resolveDefaultTableRowActionsWidth({})).toBe(140);
+  });
+});

package/src/tests/react/components/table/DefaultTableRows.rowActions.test.js

@@ -0,0 +1,152 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {describe, expect, it, beforeEach} = require('@jest/globals');
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+let mockStores = {};
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => mockStores[name] || {actions: {}, getters: {}}),
+}));
+
+jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({
+  formatStoreColumnLabel: ({fallbackLabel, fieldName}) => fallbackLabel || fieldName,
+}));
+
+jest.mock('react-native-vector-icons/Feather', () => {
+  const React = require('react');
+  return props => React.createElement('icon', props);
+});
+
+jest.mock('react-native', () => {
+  const React = require('react');
+  const createComponent = name => props =>
+    React.createElement(name, props, props.children);
+  const FlatList = props => {
+    const items = Array.isArray(props.data) ? props.data : [];
+    return React.createElement(
+      'FlatList',
+      props,
+      items.map((item, index) =>
+        props.renderItem ? props.renderItem({item, index}) : null,
+      ),
+    );
+  };
+  return {
+    FlatList,
+    ScrollView: createComponent('ScrollView'),
+    Text: createComponent('Text'),
+    TouchableOpacity: createComponent('TouchableOpacity'),
+    View: createComponent('View'),
+    StyleSheet: {create: value => value},
+    Platform: {select: value => value.web || value.default},
+  };
+});
+
+jest.mock('../../../../react/components/filters/DefaultColumnFilter', () => () => null);
+jest.mock('../../../../react/components/table/DefaultTable.styles', () => ({
+  cell: {},
+  actionsCell: {},
+  pinnedActionsCell: {},
+  stickyActionsCell: {},
+  stickyHeaderCell: {},
+  stickyIdentityCell: {},
+  rowActionsGroup: {},
+  headerRow: {},
+  headerText: {},
+  sortableHeader: {},
+  row: {},
+  scroll: {},
+  content: {},
+  tableList: {},
+  tableListContent: {},
+  filterRow: {},
+  filterCell: {},
+  iconButton: {},
+  horizontalScrollContent: {},
+}));
+jest.mock('../../../../react/components/table/DefaultTableEmptyState', () => () => null);
+jest.mock('../../../../react/components/table/DefaultTableInput', () => {
+  const React = require('react');
+  return ({column, row}) =>
+    React.createElement('cell', {
+      field: column?.key || column?.name,
+      value: row?.[column?.key || column?.name],
+    });
+});
+jest.mock('../../../../react/components/table/useDefaultTableTheme', () => () => ({
+  palette: {background: '#fff', text: '#111', textSecondary: '#666'},
+  resolvedAccentColor: '#eee',
+  tableBorderColors: {rowBorderColor: '#ddd', headerBorderColor: '#ccc'},
+  themeTokens: {},
+}));
+
+const DefaultTableRows = require('../../../../react/components/table/DefaultTableRows').default;
+
+const collectTestIds = tree =>
+  [
+    ...tree.root.findAllByType('View'),
+    ...tree.root.findAllByType('TouchableOpacity'),
+    ...tree.root.findAllByType('Text'),
+  ]
+    .map(node => node.props.testID)
+    .filter(Boolean);
+
+describe('DefaultTableRows row actions column', () => {
+  beforeEach(() => {
+    mockStores = {};
+    global.t = {t: (_store, _kind, key) => ({actions: 'Ações', edit: 'Editar'}[key])};
+  });
+
+  it('renders header + cell when rowActionsComponent is set', () => {
+    mockStores.orders = {
+      getters: {
+        columns: [{key: 'name', label: 'Nome'}],
+        items: [{id: 7, name: 'CT-e'}],
+        visibleColumns: {},
+        configs: {
+          rowActionsComponent: () => React.createElement('row-actions'),
+          showRowActions: true,
+        },
+      },
+    };
+
+    let tree;
+    renderer.act(() => {
+      tree = renderer.create(React.createElement(DefaultTableRows, {storeName: 'orders'}));
+    });
+
+    expect(collectTestIds(tree)).toEqual(
+      expect.arrayContaining([
+        'default-table-row-actions-header',
+        'default-table-row-actions-7',
+      ]),
+    );
+    expect(tree.root.findAllByType('row-actions')).toHaveLength(1);
+  });
+
+  it('does not render an actions column when showRowActions is false', () => {
+    mockStores.orders = {
+      getters: {
+        columns: [{key: 'name', label: 'Nome'}],
+        items: [{id: 7, name: 'CT-e'}],
+        visibleColumns: {},
+        configs: {
+          rowActionsComponent: () => React.createElement('row-actions'),
+          showRowActions: false,
+        },
+      },
+    };
+
+    let tree;
+    renderer.act(() => {
+      tree = renderer.create(React.createElement(DefaultTableRows, {storeName: 'orders'}));
+    });
+
+    expect(collectTestIds(tree)).not.toEqual(
+      expect.arrayContaining(['default-table-row-actions-header']),
+    );
+    expect(tree.root.findAllByType('row-actions')).toHaveLength(0);
+  });
+});

package/src/tests/react/components/upload/defaultUploadLibrary.test.js

@@ -4,6 +4,7 @@
 const {
   fetchLibraryFiles,
   filesFromPeopleMediaRelations,
+  normalizeSeedLibraryFiles,
 } = require('../../../../react/components/upload/defaultUploadLibrary');
 
 describe('filesFromPeopleMediaRelations', () => {
@@ -20,22 +21,42 @@ describe('filesFromPeopleMediaRelations', () => {
   });
 });
 
+describe('normalizeSeedLibraryFiles', () => {
+  it('accepts people_media rows and plain file objects', () => {
+    const files = normalizeSeedLibraryFiles([
+      {id: 1, file: {id: 10, fileName: 'a.png'}},
+      {id: 20, fileName: 'b.png'},
+      '/files/30',
+    ]);
+    expect(files.map(f => String(f.id)).sort()).toEqual(['10', '20', '30']);
+  });
+});
+
 describe('fetchLibraryFiles', () => {
-  it('returns empty when getItems is missing', async () => {
+  it('returns empty when getItems is missing and no seed', async () => {
     const result = await fetchLibraryFiles({fileActions: {}});
     expect(result).toEqual([]);
   });
 
-  it('sends itemsPerPage and merges people_media relations', async () => {
+  it('returns seed files when getItems is missing', async () => {
+    const result = await fetchLibraryFiles({
+      fileActions: {},
+      additionalLibraryFiles: [
+        {id: 1, file: {id: 10, fileName: 'seed.png'}},
+        {id: 11, fileName: 'seed2.png'},
+      ],
+    });
+    expect(result.map(f => String(f.id)).sort()).toEqual(['10', '11']);
+  });
+
+  it('sends itemsPerPage and merges people_media relations + seed', async () => {
     const getItems = jest.fn().mockResolvedValue({
       member: [{id: 10, fileName: 'from-files.png', context: 'people_media'}],
     });
-    const getPeopleMedia = jest.fn().mockResolvedValue({
-      member: [
-        {id: 1, file: {id: 10, fileName: 'from-files.png'}},
-        {id: 2, file: {id: 11, fileName: 'only-relation.png'}},
-      ],
-    });
+    const getPeopleMedia = jest.fn().mockResolvedValue([
+      {id: 1, file: {id: 10, fileName: 'from-files.png'}},
+      {id: 2, file: {id: 11, fileName: 'only-relation.png'}},
+    ]);
 
     const files = await fetchLibraryFiles({
       fileActions: {getItems},
@@ -43,6 +64,7 @@ describe('fetchLibraryFiles', () => {
       fileType: 'image',
       libraryContexts: ['people_media'],
       peopleActions: {getPeopleMedia},
+      additionalLibraryFiles: [{id: 3, file: {id: 12, fileName: 'seeded.png'}}],
     });
 
     expect(getItems).toHaveBeenCalledWith(
@@ -60,7 +82,7 @@ describe('fetchLibraryFiles', () => {
       }),
     );
     const ids = files.map(f => String(f.id)).sort();
-    expect(ids).toEqual(['10', '11']);
+    expect(ids).toEqual(['10', '11', '12']);
   });
 
   it('still returns /files results if people_media fetch fails', async () => {

package/src/tests/react/filters/filterValue.test.js

@@ -0,0 +1,46 @@
+import {
+  countActiveFilters,
+  isFilledFilterValue,
+  omitEmptyFilters,
+} from '../../../react/components/filters/filterValue';
+
+describe('filterValue', () => {
+  it('treats empty strings, null and empty collections as inactive', () => {
+    expect(isFilledFilterValue('')).toBe(false);
+    expect(isFilledFilterValue('   ')).toBe(false);
+    expect(isFilledFilterValue(null)).toBe(false);
+    expect(isFilledFilterValue(undefined)).toBe(false);
+    expect(isFilledFilterValue([])).toBe(false);
+    expect(isFilledFilterValue({})).toBe(false);
+  });
+
+  it('does not count date shortcut all or empty custom range', () => {
+    expect(isFilledFilterValue({shortcut: 'all'})).toBe(false);
+    expect(
+      isFilledFilterValue({
+        shortcut: 'custom',
+        customRange: {from: '', to: ''},
+      }),
+    ).toBe(false);
+    expect(isFilledFilterValue({shortcut: '7d'})).toBe(true);
+    expect(
+      isFilledFilterValue({
+        shortcut: 'custom',
+        customRange: {from: '2026-01-01', to: ''},
+      }),
+    ).toBe(true);
+  });
+
+  it('clears leftover empty filters when counting and omitting', () => {
+    const filters = {
+      status: '',
+      search: '   ',
+      period: {shortcut: 'all', customRange: {from: '', to: ''}},
+      page: 1,
+      category: 'sales',
+    };
+
+    expect(countActiveFilters(filters)).toBe(1);
+    expect(omitEmptyFilters(filters)).toEqual({category: 'sales'});
+  });
+});

package/src/tests/react/hooks/usePostalCodeLookup.test.js

@@ -38,3 +38,70 @@ describe('CEP lookup race contract', () => {
     expect(form.nickname).toBe('X');
   });
 });
+
+import {
+  GEOCODE_MISS_MESSAGE,
+  isGeocodeMiss,
+  mergePostalCodeData,
+  parseOptionalCoordinate,
+} from '../../../react/services/addressFormUtils';
+
+describe('geocode miss (#696)', () => {
+  test('isGeocodeMiss when address text exists and coords are null', () => {
+    expect(
+      isGeocodeMiss({
+        street: 'Rua Lotus',
+        district: 'Condomínio Jardim das Palmeiras',
+        city: 'Bragança Paulista',
+        uf: 'SP',
+        latitude: null,
+        longitude: null,
+      }),
+    ).toBe(true);
+  });
+
+  test('isGeocodeMiss false when Nominatim returns coords', () => {
+    expect(
+      isGeocodeMiss({
+        street: 'Rua Antônio Bonini',
+        city: 'Atibaia',
+        uf: 'SP',
+        latitude: -23.12,
+        longitude: -46.55,
+      }),
+    ).toBe(false);
+  });
+
+  test('mergePostalCodeData clears previous coords when lookup returns null', () => {
+    const prev = {
+      street: 'Old',
+      latitude: -23.1,
+      longitude: -46.5,
+      number: '10',
+      complement: '',
+      nickname: 'X',
+      cep: '12941040',
+    };
+    const next = mergePostalCodeData(prev, {
+      cep: '12924022',
+      street: 'Rua Lotus',
+      city: 'Bragança Paulista',
+      uf: 'SP',
+      latitude: null,
+      longitude: null,
+    });
+    expect(next.street).toBe('Rua Lotus');
+    expect(next.latitude).toBeNull();
+    expect(next.longitude).toBeNull();
+    expect(next.number).toBe('10');
+  });
+
+  test('parseOptionalCoordinate accepts comma decimals', () => {
+    expect(parseOptionalCoordinate('-23,5505')).toBeCloseTo(-23.5505);
+  });
+
+  test('GEOCODE_MISS_MESSAGE is PT', () => {
+    expect(GEOCODE_MISS_MESSAGE).toMatch(/localização no mapa/);
+    expect(GEOCODE_MISS_MESSAGE).toMatch(/latitude e longitude/);
+  });
+});

package/src/tests/react/inputs/defaultInputUtils.test.js

@@ -12,11 +12,19 @@ jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({
 
 const {
   buildReadPresentationStyles,
+  isIconColumn,
   mapOptions,
   resolveCellPresentation,
 } = require('../../../react/components/inputs/defaultInputUtils');
-
+
 describe('defaultInputUtils', () => {
+  it('identifies icon columns by input type or field name', () => {
+    expect(isIconColumn({inputType: 'icon', name: 'symbol'})).toBe(true);
+    expect(isIconColumn({type: 'ICON', name: 'symbol'})).toBe(true);
+    expect(isIconColumn({name: 'icon'})).toBe(true);
+    expect(isIconColumn({name: 'status'})).toBe(false);
+  });
+
   it('deduplicates list options by normalized key', () => {
     const column = {
       formatList(item) {

package/src/tests/react/services/addressFormUtils.test.js

@@ -1,5 +1,6 @@
 import {
   mergePostalCodeData,
+  clearPostalCodeDerivedFields,
   onlyDigits,
   hydrateAddressFromRow,
   hasCoordinates,
@@ -47,13 +48,13 @@ describe('addressFormUtils', () => {
     expect(next.city).toBe('São Paulo');
     expect(next.uf).toBe('SP');
     expect(next.cep).toBe('01310100');
-    expect(next.number).toBe('100');
+    expect(next.number).toBe(''); // cleared on CEP lookup (#746)
     expect(next.complement).toBe('Apto 1');
     expect(next.nickname).toBe('Casa');
     expect(next.countryCode).toBe('BR');
   });
 
-  test('mergePostalCodeData never clears number/complement/nickname', () => {
+  test('mergePostalCodeData clears number but keeps complement/nickname (#746)', () => {
     const prev = {
       nickname: 'Trabalho',
       number: '42',
@@ -75,7 +76,7 @@ describe('addressFormUtils', () => {
       country: 'Brazil',
     };
     const next = mergePostalCodeData(prev, data);
-    expect(next.number).toBe('42');
+    expect(next.number).toBe('');
     expect(next.complement).toBe('Sala 3');
     expect(next.nickname).toBe('Trabalho');
     expect(next.street).toBe('Av Paulista');
@@ -137,6 +138,8 @@ describe('addressFormUtils', () => {
   test('hasCoordinates requires finite lat/lng', () => {
     expect(hasCoordinates({latitude: -23, longitude: -46})).toBe(true);
     expect(hasCoordinates({latitude: null, longitude: -46})).toBe(false);
+    expect(hasCoordinates({latitude: 0, longitude: 0})).toBe(false);
+    expect(hasCoordinates({latitude: '0', longitude: '0'})).toBe(false);
   });
 
   test('parseOptionalCoordinate returns null for empty/invalid', () => {

package/src/tests/react/utils/tableVisibleColumnsPreferences.test.js

@@ -5,6 +5,7 @@ const {
   TABLE_VISIBLE_COLUMNS_PREFERENCES_KEY,
   TABLE_VIEW_MODE_PREFERENCES_KEY,
   buildDefaultVisibleColumns,
+  canHideVisibleColumn,
   persistTableFiltersPreference,
   persistTableSortPreference,
   persistTableViewModePreference,
@@ -71,12 +72,22 @@ describe('tableVisibleColumnsPreferences', () => {
         },
       }),
     ).toEqual({
-      id: false,
+      id: true,
       status: true,
       price: false,
     });
   });
 
+  it('does not allow hiding the last remaining column', () => {
+    expect(
+      canHideVisibleColumn({
+        columns,
+        fieldName: 'status',
+        visibleColumns: {id: true, status: false, price: false},
+      }),
+    ).toBe(false);
+  });
+
   it('builds the company, route and store preference scope', () => {
     global.location = {pathname: '/order-history-page'};