@controleonline/ui-default 1.0.263

package/src/store/default/getters.js

@@ -0,0 +1,28 @@
+export const error = state => state.error;
+export const isLoading = state => state.isLoading;
+export const isSaving = state => state.isSaving;
+export const totalItems = state => state.totalItems;
+export const summary = state => state.summary;
+export const items = state => state.items;
+export const item = state => state.item;
+export const columns = state => state.columns;
+export const filters = state => state.filters;
+export const resourceEndpoint = state => state.resourceEndpoint;
+export const selected = state => state.selected;
+export const visibleColumns = state => state.visibleColumns;
+export const isLoadingList = state => state.isLoadingList;
+export const reload = state => state.reload;
+export const store = state => state.store;
+export const offline = state => state.offline;
+export const payable = state => state.payable;
+export const loadedKey = state => state.loadedKey || '';
+export const loadedAt = state => Number(state.loadedAt) || 0;
+export const print = state => state.print;
+export const message = state => state.message;
+export const messages = state => state.messages;
+export const selections = state => state.selections || {};
+export const selectorModalKey = state => state.selectorModalKey || '';
+export const activeRequestKey = state => state.activeRequestKey || '';
+export const lastCompletedRequest = state => state.lastCompletedRequest || null;
+export const filterId = state => state?.filters?.id || null;
+export const filterDueDate = state => state?.filters?.dueDate || null;

package/src/store/default/mutation_types.js

@@ -0,0 +1,26 @@
+export const SET_ERROR = 'SET_ERROR';
+export const SET_ISLOADING = 'SET_ISLOADING';
+export const SET_ISSAVING = 'SET_ISSAVING';
+export const SET_TOTALITEMS = 'SET_TOTALITEMS';
+export const SET_SUMMARY = 'SET_SUMMARY';
+export const SET_ITEMS = 'SET_ITEMS';
+export const SET_ITEM = 'SET_ITEM';
+export const SET_COLUMNS = 'SET_COLUMNS';
+export const SET_FILTERS = 'SET_FILTERS';
+export const SET_RESOURCE_ENDPOINT = 'SET_RESOURCE_ENDPOINT';
+export const SET_SELECTED = 'SET_SELECTED';
+export const SET_VISIBLECOLUMNS = 'SET_VISIBLECOLUMNS';
+export const SET_ISLOADINGLIST = 'SET_ISLOADINGLIST';
+export const SET_RELOAD = 'SET_RELOAD';
+export const SET_STORE = 'SET_STORE';
+export const SET_OFFLINE = 'SET_OFFLINE';
+export const SET_PAYABLE = 'SET_PAYABLE';
+export const SET_LOADED_KEY = 'SET_LOADED_KEY';
+export const SET_LOADED_AT = 'SET_LOADED_AT';
+export const SET_PRINT = 'SET_PRINT';
+export const SET_MESSAGE = 'SET_MESSAGE';
+export const SET_MESSAGES = 'SET_MESSAGES';
+export const SET_SELECTIONS = 'SET_SELECTIONS';
+export const SET_SELECTOR_MODAL_KEY = 'SET_SELECTOR_MODAL_KEY';
+export const SET_ACTIVE_REQUEST_KEY = 'SET_ACTIVE_REQUEST_KEY';
+export const SET_LAST_COMPLETED_REQUEST = 'SET_LAST_COMPLETED_REQUEST';

package/src/store/default/mutations.js

@@ -0,0 +1,138 @@
+import * as types from './mutation_types';
+import Filters from '@controleonline/ui-default/src/utils/filters';
+
+export default {
+  [types.SET_ERROR](state, error) {
+    state.error = error;
+    return 'error';
+  },
+
+  [types.SET_ISLOADING](state, isLoading = true) {
+    state.isLoading = isLoading;
+    return 'isLoading';
+  },
+
+  [types.SET_ISSAVING](state, isSaving = true) {
+    state.isSaving = isSaving;
+    return 'isSaving';
+  },
+
+  [types.SET_ISLOADINGLIST](state, isLoadingList = true) {
+    state.isLoadingList = isLoadingList;
+    return 'isLoadingList';
+  },
+
+  [types.SET_PRINT](state, print) {
+    state.print = print;
+    return 'print';
+  },
+
+  [types.SET_TOTALITEMS](state, totalItems) {
+    state.totalItems = totalItems || 0;
+    return 'totalItems';
+  },
+
+  [types.SET_SUMMARY](state, summary) {
+    state.summary = summary || {};
+    return 'summary';
+  },
+
+  [types.SET_ITEMS](state, items) {
+    state.items = items;
+    return 'items';
+  },
+
+  [types.SET_ITEM](state, item) {
+    state.item = item;
+    return 'item';
+  },
+  [types.SET_MESSAGE](state, message) {
+    state.message = message;
+    return 'message';
+  },
+  [types.SET_MESSAGES](state, messages) {
+    state.messages = messages;
+    return 'messages';
+  },
+  [types.SET_SELECTIONS](state, selections) {
+    state.selections = selections || {};
+    return 'selections';
+  },
+  [types.SET_SELECTOR_MODAL_KEY](state, selectorModalKey) {
+    state.selectorModalKey = selectorModalKey || '';
+    return 'selectorModalKey';
+  },
+  [types.SET_ACTIVE_REQUEST_KEY](state, activeRequestKey) {
+    state.activeRequestKey = activeRequestKey || '';
+    return 'activeRequestKey';
+  },
+  [types.SET_LAST_COMPLETED_REQUEST](state, lastCompletedRequest) {
+    state.lastCompletedRequest = lastCompletedRequest || null;
+    return 'lastCompletedRequest';
+  },
+  [types.SET_COLUMNS](state, columns) {
+    state.columns = columns;
+    return 'columns';
+  },
+  [types.SET_OFFLINE](state, offline) {
+    state.offline = offline;
+    return 'offline';
+  },
+  [types.SET_STORE](state, store) {
+    state.store = store;
+    return 'store';
+  },
+
+  [types.SET_FILTERS](state, filters) {
+    const routeName = this?.$router?.currentRoute?.value?.name;
+    if (routeName) {
+      const persistentFilter = new Filters(
+        routeName,
+        state.store || state.resourceEndpoint,
+      );
+      persistentFilter.setFilters(filters);
+    }
+    state.filters = filters;
+    return 'filters';
+  },
+
+  [types.SET_RESOURCE_ENDPOINT](state, resourceEndpoint) {
+    state.resourceEndpoint = resourceEndpoint;
+    return 'resourceEndpoint';
+  },
+
+  [types.SET_SELECTED](state, selected) {
+    state.selected = selected;
+    return 'selected';
+  },
+
+  [types.SET_PAYABLE](state, payable) {
+    state.payable = payable;
+    return 'payable';
+  },
+
+  [types.SET_LOADED_KEY](state, loadedKey) {
+    state.loadedKey = loadedKey || '';
+    return 'loadedKey';
+  },
+
+  [types.SET_LOADED_AT](state, loadedAt) {
+    state.loadedAt = Number(loadedAt) || 0;
+    return 'loadedAt';
+  },
+
+  [types.SET_RELOAD](state, reload) {
+    state.reload = reload;
+    return 'reload';
+  },
+
+  [types.SET_VISIBLECOLUMNS](state, visibleColumns) {
+    state.visibleColumns = visibleColumns;
+    const persistentFilter = new Filters(
+      state.$router?.currentRoute?.value?.name,
+      state.store || state.resourceEndpoint,
+    );
+    persistentFilter.setVisibleColumns(visibleColumns);
+    return 'visibleColumns';
+  },
+};

package/src/tests/react/components/DateShortcutFilter.test.js

@@ -0,0 +1,96 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {beforeEach, describe, expect, it} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+jest.mock('react-native', () => {
+  const React = require('react');
+  const createComponent = name => props =>
+    React.createElement(name, props, props.children);
+
+  return {
+    StyleSheet: {create: value => value},
+    Text: createComponent('Text'),
+    TextInput: createComponent('TextInput'),
+    TouchableOpacity: createComponent('TouchableOpacity'),
+    View: createComponent('View'),
+  };
+});
+
+jest.mock(
+  '../../../react/components/filters/CompactFilterSelector',
+  () => props => {
+    const React = require('react');
+    const content =
+      typeof props.children === 'function'
+        ? props.children({close: props.onClose || (() => {})})
+        : props.children;
+
+    return React.createElement('CompactFilterSelector', props, content);
+  },
+);
+
+jest.mock(
+  '@controleonline/ui-common/src/react/utils/storeColumns',
+  () => ({
+    formatStoreColumnLabel: () => 'Periodo',
+    resolveStoreColumn: () => ({}),
+    resolveStoreConfigByName: () => ({columns: []}),
+  }),
+);
+
+const DateShortcutFilter =
+  require('../../../react/components/filters/DateShortcutFilter').default;
+
+describe('DateShortcutFilter', () => {
+  beforeEach(() => {
+    global.t = {
+      t: (_store, group, key) => {
+        if (group === 'orders' && key === 'apply_period') return 'Aplicar';
+        if (group === 'orders' && key === 'clear') return 'Limpar';
+        if (group === 'orders' && key === 'date_from') return 'Data inicial';
+        if (group === 'orders' && key === 'date_to') return 'Data final';
+        return key;
+      },
+    };
+  });
+
+  it('keeps the freshly typed custom range when applying it', () => {
+    const onChange = jest.fn();
+    const onCustomRangeChange = jest.fn();
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DateShortcutFilter, {
+          customRange: {from: '', to: ''},
+          onChange,
+          onCustomRangeChange,
+          value: 'custom',
+        }),
+      );
+    });
+
+    const inputs = tree.root.findAllByType('TextInput');
+    const buttons = tree.root.findAllByType('TouchableOpacity');
+
+    renderer.act(() => {
+      inputs[0].props.onChangeText('2026-06-01');
+      inputs[1].props.onChangeText('2026-06-28');
+    });
+
+    renderer.act(() => {
+      buttons[1].props.onPress();
+    });
+
+    expect(onCustomRangeChange).toHaveBeenCalledTimes(1);
+    expect(onCustomRangeChange).toHaveBeenCalledWith({
+      from: '2026-06-01',
+      to: '2026-06-28',
+    });
+    expect(onChange).not.toHaveBeenCalledWith('custom');
+  });
+});

package/src/tests/react/components/errors/DefaultErrors.test.js

@@ -0,0 +1,162 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {afterEach, beforeEach, describe, expect, it} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+let mockStores = {};
+let consoleErrorSpy = null;
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => {
+    if (name === 'theme') {
+      return {
+        getters: {
+          colors: {
+            inputErrorBackground: '#FEF2F2',
+            inputErrorBorder: '#DC2626',
+            inputErrorText: '#B91C1C',
+            modalBackground: '#FFFFFF',
+            modalBorder: '#DC2626',
+            modalCloseIcon: '#B91C1C',
+            modalOverlay: 'rgba(15, 23, 42, 0.55)',
+            modalText: '#334155',
+            primary: '#0EA5E9',
+            textDanger: '#DC2626',
+          },
+        },
+      };
+    }
+
+    return mockStores[name] || {actions: {}, getters: {}};
+  }),
+  useStores: jest.fn(selector =>
+    (typeof selector === 'function' ? selector(mockStores) : mockStores),
+  ),
+}));
+
+jest.mock('react-native', () => {
+  const React = require('react');
+  const createComponent = name => props =>
+    React.createElement(name, props, props.children);
+
+  return {
+    Modal: props => React.createElement('modal', props, props.children),
+    Pressable: props => React.createElement('pressable', props, props.children),
+    StyleSheet: {
+      create: styles => styles,
+    },
+    Text: createComponent('text'),
+    TouchableOpacity: createComponent('touchable-opacity'),
+    View: createComponent('view'),
+  };
+});
+
+const DefaultErrors =
+  require('../../../../react/components/errors/DefaultErrors').default;
+
+const getTextNodes = tree =>
+  tree.root
+    .findAllByType('text')
+    .map(node => (Array.isArray(node.children) ? node.children.join('') : ''))
+    .filter(Boolean);
+
+describe('DefaultErrors', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    mockStores = {
+      orders: {
+        actions: {
+          setError: jest.fn(),
+        },
+        getters: {
+          error: 'Falha ao salvar.',
+        },
+      },
+    };
+  });
+
+  afterEach(() => {
+    if (consoleErrorSpy) {
+      consoleErrorSpy.mockRestore();
+      consoleErrorSpy = null;
+    }
+
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it('renders the store error in a popup and clears the store when closed', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DefaultErrors, {
+          store: 'orders',
+          title: 'Nao foi possivel concluir',
+        }),
+      );
+    });
+
+    expect(tree.root.findByType('modal').props.visible).toBe(true);
+    expect(getTextNodes(tree)).toEqual(
+      expect.arrayContaining([
+        'Nao foi possivel concluir',
+        'Falha ao salvar.',
+        '×',
+      ]),
+    );
+
+    const closeButton = tree.root.findByProps({testID: 'default-errors-close'});
+
+    renderer.act(() => {
+      closeButton.props.onPress();
+    });
+
+    expect(mockStores.orders.actions.setError).toHaveBeenCalledWith('');
+    expect(tree.toJSON()).toBeNull();
+  });
+
+  it('renders an explicit popup even without a store binding', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DefaultErrors, {
+          title: 'Pedido nao informado.',
+        }),
+      );
+    });
+
+    expect(tree.root.findByType('modal').props.visible).toBe(true);
+    expect(getTextNodes(tree)).toEqual(
+      expect.arrayContaining([
+        'Pedido nao informado.',
+        '×',
+      ]),
+    );
+  });
+
+  it('auto closes after five seconds and clears the store error', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DefaultErrors, {
+          store: 'orders',
+          title: 'Nao foi possivel concluir',
+        }),
+      );
+    });
+
+    renderer.act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    expect(mockStores.orders.actions.setError).toHaveBeenCalledWith('');
+    expect(tree.toJSON()).toBeNull();
+  });
+});

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

@@ -0,0 +1,80 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {afterEach, beforeEach, describe, expect, it} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+jest.mock('@env', () => ({
+  env: {
+    API_ENTRYPOINT: 'https://api.controleonline.com',
+    DOMAIN: 'manager.controleonline.com',
+  },
+}));
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(() => ({
+    getters: {},
+  })),
+}));
+
+jest.mock('react-native', () => ({
+  Image: props => React.createElement('image', props, props.children),
+}));
+
+const DefaultFile =
+  require('../../../../react/components/files/DefaultFile').default;
+
+describe('DefaultFile', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  it('renders backend download files with app-domain query and headers', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(DefaultFile, {
+          file: {
+            id: 3,
+            url: '/files/3/download',
+          },
+          company: {
+            domain: 'maincompany.controleonline.com',
+          },
+          headers: {
+            Authorization: 'Bearer token',
+          },
+          resizeMode: 'contain',
+        }),
+      );
+    });
+
+    const image = tree.root.findByType('image');
+
+    expect(image.props.source).toEqual({
+      uri: 'https://api.controleonline.com/files/3/download?app-domain=maincompany.controleonline.com',
+      headers: {
+        Authorization: 'Bearer token',
+        'app-domain': 'maincompany.controleonline.com',
+      },
+    });
+    expect(image.props.resizeMode).toBe('contain');
+  });
+
+  it('returns null when there is no file source', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(React.createElement(DefaultFile, null));
+    });
+
+    expect(tree.toJSON()).toBeNull();
+  });
+});

package/src/tests/react/components/map/DefaultMap.shared.test.js

@@ -0,0 +1,162 @@
+const {
+  buildOpenStreetMapEmbedUrl,
+  buildOpenStreetMapHtml,
+  resolveDefaultMapPayload,
+} = require('../../../../react/components/map/DefaultMap.shared');
+
+const {describe, expect, it} = global;
+
+describe('DefaultMap.shared', () => {
+  it('normalizes addresses into markers, user coordinates and derived paths', () => {
+    const payload = resolveDefaultMapPayload({
+      addresses: {
+        origin: {
+          id: 'origin-1',
+          latitude: -23.55052,
+          longitude: -46.633308,
+          title: 'Origem',
+        },
+        destination: {
+          id: 'destination-1',
+          latitude: -23.563987,
+          longitude: -46.654321,
+          title: 'Destino',
+        },
+        markers: [
+          {
+            id: 'pickup-1',
+            latitude: -23.551,
+            longitude: -46.634,
+            title: 'Parada extra',
+          },
+        ],
+        user: {
+          latitude: -23.549,
+          longitude: -46.632,
+        },
+      },
+    });
+
+    expect(payload.userCoordinates).toEqual({
+      latitude: -23.549,
+      longitude: -46.632,
+    });
+    expect(payload.markerPayloads).toHaveLength(3);
+    expect(payload.paths).toHaveLength(1);
+    expect(payload.paths[0].from.title).toBe('Origem');
+    expect(payload.paths[0].to.title).toBe('Destino');
+  });
+
+  it('builds an OpenStreetMap embed URL from the available points', () => {
+    const url = buildOpenStreetMapEmbedUrl({
+      markerPayloads: [
+        {
+          id: 'marker-1',
+          latitude: -23.55052,
+          longitude: -46.633308,
+        },
+      ],
+      paths: [
+        {
+          id: 'path-1',
+          from: {
+            latitude: -23.551,
+            longitude: -46.634,
+          },
+          to: {
+            latitude: -23.563987,
+            longitude: -46.654321,
+          },
+        },
+      ],
+      userCoordinates: {
+        latitude: -23.549,
+        longitude: -46.632,
+      },
+    });
+
+    expect(url).toContain('openstreetmap.org/export/embed.html?bbox=');
+    expect(url).toContain('layer=mapnik');
+    expect(url).toContain('marker=');
+  });
+
+  it('builds an OpenStreetMap html fallback with markers and paths', () => {
+    const html = buildOpenStreetMapHtml({
+      markerPayloads: [
+        {
+          id: 'marker-1',
+          latitude: -23.55052,
+          longitude: -46.633308,
+          title: 'Origem',
+          markerIconUrl:
+            'https://app.lave-go.com/assets/src/assets/go_google_maps_pin.png',
+        },
+      ],
+      paths: [
+        {
+          id: 'path-1',
+          from: {
+            latitude: -23.551,
+            longitude: -46.634,
+          },
+          to: {
+            latitude: -23.563987,
+            longitude: -46.654321,
+          },
+        },
+      ],
+      userCoordinates: {
+        latitude: -23.549,
+        longitude: -46.632,
+      },
+    });
+
+    expect(html).toContain('leaflet');
+    expect(html).toContain('window.__SHOP_MAP_MARKERS__');
+    expect(html).toContain('Origem');
+    expect(html).toContain('markerIconUrl');
+    expect(html).toContain('resolveMarkerIcon');
+    expect(html).toContain('L.Icon.Default.mergeOptions');
+    expect(html).toContain('marker-icon.png');
+    expect(html).toContain("item.__mapRole === 'origin'");
+    expect(html).toContain("item.__mapRole === 'destination'");
+    expect(html).toContain('return L.marker([point.lat, point.lng]).addTo(map);');
+    expect(html).toContain('window.__SHOP_MAP_PATHS__');
+    expect(html).toContain('router.project-osrm.org');
+  });
+
+  it('resolves nested config addresses and api key from a single JSON payload', () => {
+    const payload = resolveDefaultMapPayload({
+      config: {
+        googleMapsApiKey: 'config-key',
+        addresses: {
+          origin: {
+            id: 'origin-1',
+            latitude: -23.55,
+            longitude: -46.63,
+            nickname: 'Origem',
+          },
+          markers: [
+            {
+              id: 'marker-1',
+              latitude: -23.56,
+              longitude: -46.64,
+              nickname: 'Destino',
+            },
+          ],
+          user: {
+            latitude: -23.54,
+            longitude: -46.62,
+          },
+        },
+      },
+    });
+
+    expect(payload.apiKey).toBe('config-key');
+    expect(payload.markerPayloads).toHaveLength(2);
+    expect(payload.userCoordinates).toEqual({
+      latitude: -23.54,
+      longitude: -46.62,
+    });
+  });
+});