@controleonline/ui-default 1.0.277 → 1.0.278

package/src/tests/react/components/table/DefaultTableToolbar.waiter.test.js

@@ -1,3 +1,4 @@
+jest.mock('../../../../react/components/table/DefaultTableCompactToolbar', () => () => null);
 const React = require('react');
 const renderer = require('react-test-renderer');
 global.IS_REACT_ACT_ENVIRONMENT = true;

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

@@ -0,0 +1,53 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+let mockStore;
+const mockGetItems = jest.fn();
+jest.mock('@store', () => ({useStore: () => mockStore, getAllStores: () => ({people: {actions: {getItems: mockGetItems}}})}));
+jest.mock('react-native', () => {
+  const React = require('react'); const component = name => p => React.createElement(name, p, p.children);
+  return {View: component('View'), Text: component('Text'), TouchableOpacity: component('Button'), ScrollView: component('Scroll'), Modal: component('Modal'),
+    TextInput: component('Input'), Image: component('Image'), StyleSheet: {create: v => v}, Platform: {select: v => v.web}, useWindowDimensions: () => ({width: 393, height: 852})};
+});
+jest.mock('react-native-vector-icons/Feather', () => () => null);
+jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({formatStoreColumnLabel: ({fallbackLabel}) => fallbackLabel}));
+jest.mock('../../../../react/components/table/useDefaultTableTheme', () => () => ({themeColors: {compact: true, border: '#ddd', textPrimary: '#123'}, checkboxSelectedMarkColor: '#987', modalColors: {textColor: '#123'}}));
+jest.mock('../../../../react/components/filters/CompactFilterSelector', () => p => require('react').createElement('Picker', p));
+jest.mock('../../../../react/components/filters/DateShortcutFilter', () => () => null);
+const Columns = require('../../../../react/components/table/DefaultColumnMenu').default;
+const Filter = require('../../../../react/components/filters/DefaultColumnFilter').default;
+let tree;
+beforeEach(() => {
+  global.t = {t: (_store, _kind, key) => key};
+  mockGetItems.mockReset().mockResolvedValue([{id: 22, name: 'Ana'}]);
+  mockStore = {getters: {currentCompany: {id: 14}, columns: [{name: 'id', isIdentity: true, compactLabel: 'Pedido'}, {name: 'price', compactLabel: 'Valor'}],
+    configs: {appearance: 'compact', tablePreferenceScope: {storeName: 'test'}}, visibleColumns: {}}, actions: {setVisibleColumns: jest.fn()}};
+});
+afterEach(() => {if (tree) renderer.act(() => tree.unmount()); tree = null;});
+it('shows selectable columns in a noncollapsed scroll body, preserving required identity', () => {
+  renderer.act(() => {tree = renderer.create(React.createElement(Columns, {storeName: 'orders', visible: true}));});
+  const buttons = tree.root.findAllByType('Button');
+  const id = buttons.find(b => b.props.accessibilityLabel === 'Pedido');
+  expect(id.props.disabled).toBe(true);
+  const amount = buttons.find(b => b.props.accessibilityLabel === 'Valor');
+  renderer.act(() => amount.props.onPress());
+  expect(mockStore.actions.setVisibleColumns).toHaveBeenCalledWith(expect.objectContaining({price: false, id: true}));
+  expect(tree.root.findByType('Scroll').props.style.height).toBeGreaterThan(0);
+});
+it('uses fixed channel options without remote loading and emits the selected channel', () => {
+  const onChange = jest.fn();
+  renderer.act(() => {tree = renderer.create(React.createElement(Filter, {storeName: 'orders', column: {name: 'app', compactLabel: 'Canal', list: [{value: 'POS', label: 'POS'}]}, onChange}));});
+  const picker = tree.root.findByType('Picker');
+  expect(picker.props.options).toEqual(expect.arrayContaining([expect.objectContaining({key: 'POS', label: 'POS'})]));
+  expect(picker.props.onSearchChange).toBeUndefined();
+  expect(mockGetItems).not.toHaveBeenCalled();
+  renderer.act(() => picker.props.onSelect('POS'));
+  expect(onChange).toHaveBeenCalledWith('app', 'POS');
+});
+it('loads remote options only on opening, using the existing list action', async () => {
+  renderer.act(() => {tree = renderer.create(React.createElement(Filter, {storeName: 'orders', column: {name: 'client', list: 'people/getItems'}}));});
+  expect(mockGetItems).not.toHaveBeenCalled();
+  await renderer.act(async () => {await tree.root.findByType('Picker').props.onBeforeOpen();});
+  expect(mockGetItems).toHaveBeenCalledTimes(1);
+  expect(tree.root.findByType('Picker').props.options).toEqual(expect.arrayContaining([expect.objectContaining({key: '22'})]));
+});

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

@@ -0,0 +1,47 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+let mockStore;
+jest.mock('@store', () => ({useStore: () => mockStore}));
+jest.mock('react-native', () => {
+  const React = require('react');
+  const component = name => props => React.createElement(name, props, props.children);
+  return {View: component('View'), Text: component('Text'), TouchableOpacity: component('Button'), Modal: component('Modal'),
+    ScrollView: component('Scroll'), StyleSheet: {create: value => value}, Platform: {select: value => value.web}};
+});
+jest.mock('react-native-vector-icons/Feather', () => () => null);
+jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({formatStoreColumnLabel: ({fallbackLabel}) => fallbackLabel}));
+jest.mock('../../../../react/components/filters/DefaultColumnFilter', () => props => require('react').createElement('Filter', props));
+jest.mock('../../../../react/components/table/useDefaultTableTheme', () => () => ({modalColors: {}, resolvedAccentColor: 'theme-accent'}));
+jest.mock('../../../../react/utils/tableVisibleColumnsPreferences', () => ({
+  persistTableFiltersPreference: jest.fn(), resolveDefaultTablePreferenceScope: () => ({}), sanitizeTableFiltersPreference: ({filters}) => filters,
+}));
+const Filters = require('../../../../react/components/table/DefaultFiltersModal').default;
+let tree;let close;
+const render = visible => React.createElement(Filters, {storeName: 'orders', visible, deferred: true, onClose: close});
+beforeEach(() => {
+  global.t = {t: (_store, _kind, key) => key};
+  close = jest.fn();
+  mockStore = {getters: {columns: [{name: 'status'}], filters: {status: 'paid', search: 'Marina'}, configs: {onFilterChange: jest.fn()}}, actions: {setFilters: jest.fn()}};
+  renderer.act(() => {tree = renderer.create(render(true));});
+});
+afterEach(() => renderer.act(() => tree.unmount()));
+const click = label => tree.root.findAllByType('Button').find(button => button.findAllByType('Text').some(text => text.props.children === label)).props.onPress();
+it('applies edited filters once and retains search only after Apply', () => {
+  renderer.act(() => tree.root.findByType('Filter').props.onChange('status', 'closed'));
+  expect(mockStore.actions.setFilters).not.toHaveBeenCalled();
+  expect(mockStore.getters.configs.onFilterChange).not.toHaveBeenCalled();
+  renderer.act(() => click('Aplicar filtros'));
+  expect(mockStore.getters.configs.onFilterChange).toHaveBeenCalledTimes(1);
+  expect(mockStore.getters.configs.onFilterChange).toHaveBeenCalledWith({status: 'closed', search: 'Marina'});
+  expect(close).toHaveBeenCalledTimes(1);
+});
+it('closing discards draft changes and clearing stays deferred', () => {
+  renderer.act(() => click('Limpar'));
+  expect(tree.root.findByType('Filter').props.filters).toEqual({});
+  expect(mockStore.actions.setFilters).not.toHaveBeenCalled();
+  renderer.act(() => tree.root.findByType('Modal').props.onRequestClose());
+  renderer.act(() => tree.update(render(false)));
+  renderer.act(() => tree.update(render(true)));
+  expect(tree.root.findByType('Filter').props.filters).toEqual({status: 'paid', search: 'Marina'});
+});

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

@@ -0,0 +1,66 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+jest.mock('react-native', () => ({StyleSheet: {create: value => value}, Platform: {select: value => value.web}}));
+jest.mock('@store', () => ({getAllStores: () => ({})}));
+jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({formatStoreColumnValue: () => ''}));
+const {useDefaultTablePagination} = require('../../../../react/components/table/useDefaultTablePagination');
+const {getVisiblePageNumbers, isActiveTableFilter} = require('../../../../react/components/table/DefaultTableCompact.helpers');
+let tree;
+let result;
+let options;
+const Harness = () => {result = useDefaultTablePagination(options); return null;};
+beforeEach(() => {
+  options = {autoMode: true, columnsForTable: [], filters: {}, isFocused: true, pageSize: 20,
+    paginationMode: 'pages', requestParams: {provider: '/people/1'}, resolvedTotalItems: 45,
+    resolvedSort: {field: 'id', direction: 'desc'}, storeName: 'orders', showError: jest.fn(),
+    store: {getters: {items: [], resourceEndpoint: 'orders'}},
+    resolvedActions: {getItems: jest.fn(async query => {
+      const member = [{id: query.page * 100}];
+      options.store.getters.items = query.append ? [...options.store.getters.items, ...member] : member;
+      return {member, totalItems: 45};
+    })}};
+});
+afterEach(() => renderer.act(() => tree?.unmount()));
+const mount = async () => {await renderer.act(async () => {tree = renderer.create(React.createElement(Harness));});};
+it('loads numbered pages with the same scope, filters and server sort, replacing records', async () => {
+  options.filters = {search: 'Marina'};
+  await mount();
+  await renderer.act(async () => {await result.goToPage(2);});
+  expect(options.resolvedActions.getItems).toHaveBeenLastCalledWith({provider: '/people/1', itemsPerPage: 20, page: 2, 'order[id]': 'desc', search: 'Marina'});
+  expect(result.currentPage).toBe(2);
+  expect(result.resolvedData).toEqual([{id: 200}]);
+  renderer.act(() => result.handleEndReached());
+  expect(options.resolvedActions.getItems).toHaveBeenCalledTimes(2);
+});
+it('resets to page one when filters change and rejects invalid pages', async () => {
+  await mount();
+  await renderer.act(async () => {await result.goToPage(3);});
+  options = {...options, filters: {search: 'Carlos'}};
+  await renderer.act(async () => {tree.update(React.createElement(Harness));});
+  expect(result.currentPage).toBe(1);
+  expect(options.resolvedActions.getItems.mock.calls.at(-1)[0].search).toBe('Carlos');
+  const count = options.resolvedActions.getItems.mock.calls.length;
+  await result.goToPage(0); await result.goToPage(4); await result.goToPage(1.5);
+  expect(options.resolvedActions.getItems).toHaveBeenCalledTimes(count);
+});
+it('preserves infinite append for consumers that did not opt into numbered pages', async () => {
+  options.paginationMode = 'infinite';
+  await mount();
+  await renderer.act(async () => {result.handleEndReached();});
+  expect(options.resolvedActions.getItems.mock.calls.at(-1)[0]).toMatchObject({page: 2, append: true});
+  expect(result.resolvedData).toHaveLength(2);
+});
+it('does not advance the page after an API error', async () => {
+  await mount();
+  options.resolvedActions.getItems.mockRejectedValueOnce(new Error('Falha demonstrativa'));
+  await renderer.act(async () => {await result.goToPage(2);});
+  expect(result.currentPage).toBe(1);
+  expect(options.showError).toHaveBeenCalledWith('Falha demonstrativa');
+});
+it('keeps compact page controls bounded and ignores empty date shortcuts', () => {
+  expect(getVisiblePageNumbers(1, 50)).toEqual([1, 2, 3]);
+  expect(getVisiblePageNumbers(50, 50)).toEqual([48, 49, 50]);
+  expect(isActiveTableFilter({shortcut: 'all'})).toBe(false);
+  expect(isActiveTableFilter({shortcut: 'today'})).toBe(true);
+});

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

@@ -0,0 +1,34 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+const mockColors = {primary: '#123456', background: '#abcdef', text: '#654321', modalBackground: '#fedcba'};
+jest.mock('@store', () => ({useStore: () => ({getters: {colors: mockColors}})}));
+const {default: useTheme, DefaultTableThemeContext} = require('../../../../react/components/table/useDefaultTableTheme');
+const {resolveDomainThemeColors} = require('@controleonline/ui-common/src/react/components/resolveDomainThemeColors');
+let result;
+function Probe({appearance}) {result = useTheme(null, appearance); return null;}
+it('uses configured theme colors in compact mode and responds to changes without a fixed palette', () => {
+  let tree;
+  renderer.act(() => {tree = renderer.create(React.createElement(Probe, {appearance: 'compact'}));});
+  expect(result.themeColors).toEqual({...mockColors, compact: true});
+  mockColors.background = '#998877';
+  renderer.act(() => tree.update(React.createElement(Probe, {appearance: 'default'})));
+  expect(result.themeColors.background).toBe('#998877');
+  renderer.act(() => tree.unmount());
+});
+it('shares configured theme colors with nested controls', () => {
+  const colors = {primary: '#abcdef', modalBackground: '#123abc'};
+  let tree;
+  renderer.act(() => {tree = renderer.create(React.createElement(DefaultTableThemeContext.Provider, {value: colors}, React.createElement(Probe)));});
+  expect(result.themeColors).toBe(colors);
+  expect(result.modalColors.backgroundColor).toBe('#123abc');
+  renderer.act(() => tree.unmount());
+});
+it('preserves domain branding regardless of the selected franchise', () => {
+  const main = {theme: {colors: {primary: '#000001', text: '#000002'}}};
+  const domain = {primary: '#000003'};
+  const result = resolveDomainThemeColors(domain, main);
+  expect(result).toEqual({primary: '#000003', text: '#000002'});
+  expect(resolveDomainThemeColors({}, main).primary).toBe('#000001');
+  expect(domain).toEqual({primary: '#000003'});
+});

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

@@ -0,0 +1,41 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+global.IS_REACT_ACT_ENVIRONMENT = true;
+let mockStore;
+jest.mock('@store', () => ({useStore: () => mockStore, getAllStores: () => ({})}));
+jest.mock('react-native', () => {
+  const React = require('react');
+  const component = name => props => React.createElement(name, props, props.children);
+  return {View: component('View'), Text: component('Text'), TextInput: component('Input'), TouchableOpacity: component('Button'),
+    Modal: component('Modal'), ScrollView: component('Scroll'), useWindowDimensions: () => ({width: 393}),
+    StyleSheet: {create: value => value}, Platform: {select: value => value.web}};
+});
+jest.mock('react-native-vector-icons/Feather', () => () => null);
+jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({formatStoreColumnLabel: ({fallbackLabel}) => fallbackLabel}));
+jest.mock('../../../../react/components/table/DefaultFiltersModal', () => () => null);
+jest.mock('../../../../react/components/table/DefaultColumnMenu', () => () => null);
+jest.mock('../../../../react/components/table/DefaultDebug', () => () => null);
+jest.mock('../../../../react/components/table/DefaultToolbarAction', () => () => null);
+jest.mock('../../../../react/components/table/useDefaultTableTheme', () => () => ({themeColors: {textPrimary: 'theme-text', inputBackground: 'theme-input'}}));
+const Toolbar = require('../../../../react/components/table/DefaultTableCompactToolbar').default;
+let tree;
+beforeEach(() => {
+  mockStore = {getters: {add: true, columns: [{name: 'id', sortable: true}], filters: {status: 'paid'}, configs: {
+    add: false, onAdd: jest.fn(), effectiveViewMode: 'cards', tablePreferenceScope: {}, onFilterChange: jest.fn(), resolvedSort: {field: 'id', direction: 'desc'},
+  }}, actions: {setFilters: jest.fn(), setConfigs: jest.fn()}};
+  renderer.act(() => {tree = renderer.create(React.createElement(Toolbar, {storeName: 'orders'}));});
+});
+afterEach(() => renderer.act(() => tree.unmount()));
+it('submits search through the history callback, retaining existing filters', () => {
+  renderer.act(() => tree.root.findByType('Input').props.onChangeText('  Marina  '));
+  renderer.act(() => tree.root.findAllByType('Button').find(b => b.props.accessibilityLabel === 'Pesquisar').props.onPress());
+  expect(mockStore.getters.configs.onFilterChange).toHaveBeenCalledWith({status: 'paid', search: 'Marina'});
+  expect(mockStore.actions.setFilters).not.toHaveBeenCalled();
+  expect(tree.root.findByType('Input').props.style.flat().some(s => s?.fontSize === 16)).toBe(true);
+});
+it('lets explicit add=false override the store default and switches view without clearing filters', () => {
+  expect(tree.root.findAllByType('Button').some(b => b.props.accessibilityLabel === 'Adicionar')).toBe(false);
+  renderer.act(() => tree.root.findAllByType('Button').find(b => b.props.accessibilityLabel === 'Tabela').props.onPress());
+  expect(mockStore.actions.setConfigs).toHaveBeenCalledWith(expect.objectContaining({effectiveViewMode: 'table'}));
+  expect(mockStore.getters.filters).toEqual({status: 'paid'});
+});

package/src/tests/react/components/table/defaultTableStoreHarness.cjs

@@ -0,0 +1,35 @@
+const React = require('react');
+// Mirror store subscriptions: config publication happens in effects, never render.
+module.exports = function createStoreHarness(getStores) {
+  let registry;
+  let fallback = {};
+  const states = new WeakMap();
+  return function useStore(name) {
+    const next = getStores();
+    if (next !== registry) {registry = next; fallback = {};}
+    const store = next[name] || (fallback[name] ||= {actions: {}, getters: {}});
+    if (!states.has(store)) {
+      const state = {version: 0, listeners: new Set()};
+      states.set(store, state);
+      store.actions ||= {};
+      store.getters ||= {};
+      for (const field of ['configs', 'columns', 'items', 'viewMode', 'filters', 'visibleColumns']) {
+        const action = `set${field[0].toUpperCase()}${field.slice(1)}`;
+        const original = store.actions[action];
+        store.actions[action] = value => {
+          original?.(value);
+          if (store.getters[field] === value) return;
+          store.getters[field] = value;
+          state.version += 1;
+          state.listeners.forEach(notify => notify());
+        };
+      }
+    }
+    const state = states.get(store);
+    React.useSyncExternalStore(notify => {
+      state.listeners.add(notify);
+      return () => state.listeners.delete(notify);
+    }, () => state.version, () => state.version);
+    return store;
+  };
+};

package/src/tests/react/components/table/defaultTableTestSetup.cjs

@@ -0,0 +1,207 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+
+const {afterEach, beforeEach, describe, expect, it} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+let consoleErrorSpy = null;
+const mockState = {stores: {}, windowDimensions: {width: 480, height: 800}, capturedColumnFilterProps: [], capturedDefaultFormProps: [], capturedDefaultInputProps: []};
+
+const createLocalStorageMock = () => {
+  let storage = {};
+
+  return {
+    clear: () => {
+      storage = {};
+    },
+    getItem: key => (key in storage ? storage[key] : null),
+    removeItem: key => {
+      delete storage[key];
+    },
+    setItem: (key, value) => {
+      storage[key] = String(value);
+    },
+  };
+};
+
+global.localStorage = createLocalStorageMock();
+
+jest.mock('@store', () => ({
+  getAllStores: jest.fn(() => ({})),
+  useStore: require('./defaultTableStoreHarness.cjs')(() => mockState.stores),
+}));
+
+jest.mock('@react-navigation/native', () => ({
+  NavigationRouteContext: require('react').createContext({name: 'OrderHistoryPage'}),
+  useIsFocused: jest.fn(() => false),
+  useRoute: jest.fn(() => ({
+    key: 'OrderHistoryPage-key',
+    name: 'OrderHistoryPage',
+  })),
+}));
+
+jest.mock('@controleonline/ui-common/src/react/components/MessageService', () => ({
+  useMessage: jest.fn(() => ({
+    showError: jest.fn(),
+  })),
+}));
+
+jest.mock('react-native-vector-icons/Feather', () => {
+  const React = require('react');
+  return props => React.createElement('icon', props, props.children);
+});
+
+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,
+      ),
+      items.length === 0 && props.ListEmptyComponent ? props.ListEmptyComponent : null,
+      props.ListFooterComponent || null,
+    );
+  };
+
+  return {
+    FlatList,
+    Modal: createComponent('Modal'),
+    Platform: {
+      OS: 'web',
+      select: value => value.web || value.default || null,
+    },
+    ScrollView: createComponent('ScrollView'),
+    StyleSheet: {create: value => value},
+    Text: createComponent('Text'),
+    TouchableOpacity: createComponent('TouchableOpacity'),
+    View: createComponent('View'),
+    useWindowDimensions: jest.fn(() => mockState.windowDimensions),
+  };
+});
+
+jest.mock('../../../../react/components/filters/DefaultColumnFilter', () => props => {
+  const React = require('react');
+  mockState.capturedColumnFilterProps.push(props);
+  return React.createElement('DefaultColumnFilter', props);
+});
+
+jest.mock('../../../../react/components/filters/DefaultSearch', () => props => {
+  const React = require('react');
+  return React.createElement('DefaultSearch', props);
+});
+
+jest.mock('../../../../react/components/table/DefaultTableImportModal', () => props => {
+  const React = require('react');
+  return React.createElement('DefaultTableImportModal', props);
+});
+
+jest.mock('../../../../react/components/form/DefaultForm', () => props => {
+  const React = require('react');
+  mockState.capturedDefaultFormProps.push(props);
+  return React.createElement('DefaultForm', props);
+});
+
+jest.mock('../../../../react/components/inputs/DefaultInput', () => props => {
+  const React = require('react');
+  mockState.capturedDefaultInputProps.push(props);
+  return React.createElement('DefaultInput', props);
+});
+
+jest.mock('@controleonline/ui-common/src/react/components/StateStore', () => props => {
+  const React = require('react');
+  return React.createElement('StateStore', props, props.children);
+});
+
+const {
+  default: DefaultTable,
+  mergeSortedDataWithLiveItems,
+  resolveColumnListLoadParams,
+  shouldTriggerEndReachedFromScroll,
+} = require('../../../../react/components/table/DefaultTable');
+const {
+  DEFAULT_TABLE_PREFERENCES_STORAGE_KEY,
+} = require('../../../../react/utils/tableVisibleColumnsPreferences');
+const reactNavigation = require('@react-navigation/native');
+const {getAllStores} = require('@store');
+const STORE_ACTION_META_KEY = '__storeMeta';
+
+const flattenStyle = style => {
+  if (Array.isArray(style)) {
+    return style.reduce(
+      (acc, item) => ({
+        ...acc,
+        ...flattenStyle(item),
+      }),
+      {},
+    );
+  }
+
+  return style && typeof style === 'object' ? style : {};
+};
+
+
+function registerDefaultTableTests(register) {
+  describe('DefaultTable', () => {
+beforeEach(() => {
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    mockState.windowDimensions = {width: 480, height: 800};
+    mockState.capturedColumnFilterProps = [];
+    mockState.capturedDefaultFormProps = [];
+    mockState.capturedDefaultInputProps = [];
+    getAllStores.mockImplementation(() => ({}));
+    global.localStorage = createLocalStorageMock();
+    global.t = {
+      t: jest.fn((store, type, key) => {
+        if (type === 'label' && key === 'search') return 'Buscar';
+        if (type === 'label' && key === 'items') return 'registros';
+        if (type === 'label' && key === 'loading') return 'Carregando...';
+        if (type === 'label' && key === 'empty') return 'Nenhum registro encontrado';
+        if (type === 'label' && key === 'filters') return 'Filtros';
+        if (type === 'label' && key === 'select') return 'Selecionar';
+        if (type === 'button' && key === 'add') return 'Adicionar';
+        if (type === 'button' && key === 'edit') return 'Editar';
+        if (type === 'button' && key === 'apply') return 'Aplicar';
+        if (type === 'button' && key === 'clear') return 'Limpar';
+        if (type === 'input' && key === 'search') return 'Buscar...';
+        return undefined;
+      }),
+    };
+    reactNavigation.useIsFocused.mockImplementation(() => false);
+
+    mockState.stores = {
+      people: {
+        getters: {
+          currentCompany: {
+            id: 1,
+            theme: {
+              colors: {},
+            },
+          },
+        },
+      },
+      theme: {
+        getters: {
+          colors: {},
+        },
+      },
+    };
+  });
+afterEach(() => {
+    delete global.t;
+    if (consoleErrorSpy) {
+      consoleErrorSpy.mockRestore();
+      consoleErrorSpy = null;
+    }
+  });
+    register();
+  });
+}
+module.exports = {registerDefaultTableTests, React, renderer, mockState, DefaultTable, mergeSortedDataWithLiveItems, resolveColumnListLoadParams, shouldTriggerEndReachedFromScroll, DEFAULT_TABLE_PREFERENCES_STORAGE_KEY, reactNavigation, getAllStores, STORE_ACTION_META_KEY, flattenStyle};

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

@@ -12,6 +12,7 @@ const mockSanitizeTableFiltersPreference = jest.fn((args) => {
 });
 
 jest.mock('../../../../react/utils/tableVisibleColumnsPreferences', () => ({
+  persistTableFiltersPreference: jest.fn(),
   resolveStoredTableFiltersPreference: (...args) =>
     mockResolveStoredTableFiltersPreference(...args),
   resolveStoredVisibleColumnsPreference: jest.fn(() => null),
@@ -25,8 +26,10 @@ const {
   useDefaultTableStoreSync,
 } = require('../../../../react/components/table/useDefaultTableStoreSync');
 
-function Harness({data, store, storeFilters, columnsForTable, tablePreferenceScope, configsSignature = 'sig', configs = {}}) {
+function Harness({data, store, storeFilters, columnsForTable, tablePreferenceScope, filters, onFilterChange, configsSignature = 'sig', configs = {}}) {
   useDefaultTableStoreSync({
+    filters,
+    onFilterChange,
     columns: [],
     columnsForTable: columnsForTable || [],
     data,
@@ -161,6 +164,7 @@ describe('useDefaultTableStoreSync', () => {
 
   it('publishes changed same-count table configs but ignores equivalent snapshots', () => {
     const setConfigs = jest.fn();
+    const setItems = jest.fn();
     const store = {actions: {setConfigs, setItems}, getters: {}};
     const first = [{id: 'device:396', configs: [{id: 487}]}];
     const second = [{id: 'device:403', configs: [{id: 510}]}];
@@ -195,3 +199,36 @@ describe('useDefaultTableStoreSync', () => {
     tree.unmount();
   });
 });
+
+
+describe('controlled history filters and persisted preferences', () => {
+  it('keeps the initial date shown by the dialog aligned with the request owner', () => {
+    mockResolveStoredTableFiltersPreference.mockReturnValue(null);
+    const filters = {alterDate: {shortcut: 'today'}};
+    const store = {getters: {filters: {}}, actions: {setFilters: jest.fn()}};
+    const onFilterChange = jest.fn();
+    let tree;
+    renderer.act(() => {tree = renderer.create(React.createElement(Harness, {
+      store, filters, onFilterChange, columnsForTable: [{key: 'alterDate'}],
+    }));});
+    expect(store.actions.setFilters).toHaveBeenCalledWith(filters);
+    expect(onFilterChange).not.toHaveBeenCalled();
+    renderer.act(() => tree.unmount());
+  });
+  it.each([{}, {alterDate: {shortcut: 'all'}}])('notifies the query owner when restoring all periods: %j', saved => {
+    mockResolveStoredTableFiltersPreference.mockReturnValue(saved);
+    const store = {getters: {}, actions: {setFilters: jest.fn()}};
+    const onFilterChange = jest.fn();
+    const props = {store, storeFilters: {alterDate: {shortcut: 'today'}},
+      filters: {alterDate: {shortcut: 'today'}}, onFilterChange,
+      columnsForTable: [{key: 'alterDate'}]};
+    let tree;
+    renderer.act(() => {tree = renderer.create(React.createElement(Harness, props));});
+    expect(store.actions.setFilters).toHaveBeenCalledWith(saved);
+    expect(onFilterChange).toHaveBeenCalledTimes(1);
+    expect(onFilterChange).toHaveBeenCalledWith(saved);
+    renderer.act(() => {tree.update(React.createElement(Harness, {...props, filters: saved, storeFilters: saved}));});
+    expect(onFilterChange).toHaveBeenCalledTimes(1);
+    renderer.act(() => tree.unmount());
+  });
+});