@controleonline/ui-default 1.0.272 → 1.0.274

package/src/tests/react/components/files/DefaultFile.test.js

@@ -20,6 +20,7 @@ jest.mock('@store', () => ({
 }));
 
 jest.mock('react-native', () => ({
+  Platform: {OS: 'android'},
   Image: props => React.createElement('image', props, props.children),
 }));
 
@@ -78,3 +79,18 @@ describe('DefaultFile', () => {
     expect(tree.toJSON()).toBeNull();
   });
 });
+
+it('uses the domain company from the store when another company is selected', () => {
+  require('@store').useStore.mockReturnValue({getters: {
+    mainCompany: {id: 1, domain: 'domain.example'},
+    currentCompany: {id: 2, domain: 'selected.example'},
+  }});
+  let tree;
+  renderer.act(() => {
+    tree = renderer.create(React.createElement(DefaultFile, {file: {id: 7, url: '/files/7/download'}}));
+  });
+  const source = tree.root.findByType('image').props.source;
+  expect(source.uri).toBe('https://api.controleonline.com/domain.example/files/7/download');
+  expect(source.headers['app-domain']).toBe('domain.example');
+  renderer.act(() => tree.unmount());
+});

package/src/tests/react/components/files/DefaultFileColumn.company.test.js

@@ -0,0 +1,24 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {expect, it, jest} = require('@jest/globals');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+jest.mock('react-native', () => ({View: 'View', Text: 'Text', TouchableOpacity: 'TouchableOpacity',
+  Linking: {openURL: jest.fn()}, StyleSheet: {create: x => x}}));
+jest.mock('react-native-vector-icons/Feather', () => 'Icon');
+jest.mock('@store', () => ({useStore: jest.fn()}));
+jest.mock('../../../../react/components/files/DefaultFile', () => 'Preview');
+jest.mock('../../../../react/components/files/DefaultFileColumn.utils', () => ({
+  normalizeDefaultFileColumnItems: jest.fn(() => []), normalizeFileColumnText: value => value,
+}));
+const {useStore} = require('@store');
+const {normalizeDefaultFileColumnItems} = require('../../../../react/components/files/DefaultFileColumn.utils');
+const Column = require('../../../../react/components/files/DefaultFileColumn').default;
+it('passes the domain company to file URL resolution when B is selected', () => {
+  const mainCompany = {id: 1, domain: 'domain.example'};
+  useStore.mockImplementation(name => name === 'people'
+    ? {getters: {mainCompany, currentCompany: {id: 2}}} : {getters: {colors: {}}});
+  let tree;
+  renderer.act(() => { tree = renderer.create(React.createElement(Column, {})); });
+  expect(normalizeDefaultFileColumnItems.mock.calls.at(-1)[0].company).toEqual(mainCompany);
+  renderer.act(() => tree.unmount());
+});

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.test.js

@@ -287,6 +287,43 @@ describe('DefaultTable', () => {
     }
   });
 
+  it('can show only search in the toolbar while hiding configured actions and controls', () => {
+    mockWindowDimensions = {width: 375, height: 667};
+    mockStores.categories = {
+      actions: {},
+      getters: {
+        columns: [{key: 'name', label: 'Nome', searchable: true}],
+        configs: {
+          import: {enabled: true, importType: 'product', label: 'Importar CSV'},
+          showSearch: true,
+        },
+        items: [],
+        totalItems: 17,
+      },
+    };
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DefaultTable, {
+          columns: [{key: 'name', label: 'Nome', searchable: true}],
+          data: [],
+          showToolbarActions: false,
+          showToolbarControls: false,
+          showTotalItemsInFooter: false,
+          storeName: 'categories',
+        }),
+      );
+    });
+
+    const iconNames = tree.root.findAllByType('icon').map(node => node.props.name);
+    expect(iconNames).toContain('search');
+    expect(iconNames).not.toEqual(
+      expect.arrayContaining(['upload', 'code', 'filter', 'list', 'columns']),
+    );
+    expect(tree.root.findAllByType('Text').map(node => node.props.children)).not.toContain('Importar CSV');
+  });
+
   it('keeps the list/card toggle visible on compact layouts even when cards are forced', () => {
     let tree;
 

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/table/DefaultTableToolbar.waiter.test.js

@@ -0,0 +1,42 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+let mockConfigs;
+jest.mock('@store', () => ({useStore: () => ({getters: {configs: mockConfigs}})}));
+jest.mock('react-native', () => ({
+ View: props => require('react').createElement('view', props, props.children),
+ Text: props => require('react').createElement('text', props, props.children),
+ StyleSheet: {create: value => value},
+ Platform: {select: value => value.web || value.default || null},
+ useWindowDimensions: () => ({width: 400}),
+}));
+jest.mock('../../../../react/components/table/DefaultTableControls', () => () => require('react').createElement('controls'));
+jest.mock('../../../../react/components/table/DefaultToolbarAction', () => props => require('react').createElement('action', props));
+jest.mock('../../../../react/components/table/DefaultTableImportModal', () => () => null);
+jest.mock('../../../../react/components/table/DefaultTableSearch', () => ({
+ DefaultTableCollapsedSearch: () => null, DefaultTableCompactSearch: () => null, DefaultTableInlineSearch: () => require('react').createElement('search'),
+}));
+jest.mock('../../../../react/components/table/useDefaultTableTheme', () => () => ({tableBorderColors: {}, toolbarColors: {}}));
+const Toolbar = require('../../../../react/components/table/DefaultTableToolbar').default;
+let tree;
+beforeEach(() => {mockConfigs = {toolbarActions: [{key: 'custom', onPress: jest.fn()}], importAction: jest.fn(), exportAction: jest.fn()};});
+afterEach(() => {if(tree) renderer.act(() => tree.unmount());});
+it('keeps generic actions and controls enabled by default', () => {
+ renderer.act(() => {tree = renderer.create(React.createElement(Toolbar, {storeName: 'categories'}));});
+ expect(tree.root.findAllByType('action')).toHaveLength(3);
+ expect(tree.root.findAllByType('controls')).toHaveLength(1);
+});
+it('hides actions and administrative controls while keeping waiter search', () => {
+ renderer.act(() => {tree = renderer.create(React.createElement(Toolbar, {storeName: 'categories', showToolbarActions: false, showToolbarControls: false}));});
+ expect(tree.root.findAllByType('action')).toHaveLength(0);
+ expect(tree.root.findAllByType('controls')).toHaveLength(0);
+ expect(tree.root.findAllByType('search')).toHaveLength(1);
+});
+it('honors stored flags and allows an explicit screen override', () => {
+ mockConfigs.showToolbarActions = false; mockConfigs.showToolbarControls = false;
+ renderer.act(() => {tree = renderer.create(React.createElement(Toolbar, {storeName: 'categories'}));});
+ expect(tree.root.findAllByType('controls')).toHaveLength(0);
+ renderer.act(() => tree.update(React.createElement(Toolbar, {storeName: 'categories', showToolbarActions: true, showToolbarControls: true})));
+ expect(tree.root.findAllByType('controls')).toHaveLength(1);
+ expect(tree.root.findAllByType('action')).toHaveLength(3);
+});

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) {