@controleonline/ui-default 1.0.270 → 1.0.273

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

@@ -0,0 +1,161 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+
+const {beforeEach, describe, expect, it} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const mockResolveStoredTableFiltersPreference = jest.fn(() => null);
+const mockSanitizeTableFiltersPreference = jest.fn((args) => {
+  if (args && args.filters) return args.filters;
+  return args || {};
+});
+
+jest.mock('../../../../react/utils/tableVisibleColumnsPreferences', () => ({
+  resolveStoredTableFiltersPreference: (...args) =>
+    mockResolveStoredTableFiltersPreference(...args),
+  resolveStoredVisibleColumnsPreference: jest.fn(() => null),
+  sanitizeTableFiltersPreference: (...args) =>
+    mockSanitizeTableFiltersPreference(...args),
+  sanitizeVisibleColumnsPreference: jest.fn(v => v?.visibleColumns || []),
+}));
+
+const {
+  areTableFiltersEqual,
+  useDefaultTableStoreSync,
+} = require('../../../../react/components/table/useDefaultTableStoreSync');
+
+function Harness({data, store, storeFilters, columnsForTable, tablePreferenceScope}) {
+  useDefaultTableStoreSync({
+    columns: [],
+    columnsForTable: columnsForTable || [],
+    data,
+    defaultTableConfigs: {},
+    defaultTableConfigsSignature: 'sig',
+    store,
+    storeColumnsLength: 0,
+    storeFilters: storeFilters || {},
+    storeName: 'device_config',
+    tablePreferenceScope: tablePreferenceScope || {
+      companyKey: 'c1',
+      storeKey: 'orders',
+      routeKey: 'order-history-page',
+    },
+  });
+  return null;
+}
+
+describe('useDefaultTableStoreSync', () => {
+  beforeEach(() => {
+    mockResolveStoredTableFiltersPreference.mockReset();
+    mockResolveStoredTableFiltersPreference.mockReturnValue(null);
+    mockSanitizeTableFiltersPreference.mockClear();
+  });
+
+  it('publishes controlled data once per array reference (avoids #185 loop)', () => {
+    const setItems = jest.fn();
+    const store = {
+      actions: {setItems},
+      getters: {},
+    };
+    const data = [{id: 1}];
+
+    let tree;
+    renderer.act(() => {
+      tree = renderer.create(React.createElement(Harness, {data, store}));
+    });
+
+    expect(setItems).toHaveBeenCalledTimes(1);
+    expect(setItems).toHaveBeenCalledWith(data);
+
+    // New store identity (zustand commit) with same data reference must NOT re-publish
+    const storeAfterCommit = {
+      actions: {setItems},
+      getters: {items: data},
+    };
+    renderer.act(() => {
+      tree.update(React.createElement(Harness, {data, store: storeAfterCommit}));
+    });
+    expect(setItems).toHaveBeenCalledTimes(1);
+
+    // New data reference must publish again
+    const data2 = [{id: 2}];
+    renderer.act(() => {
+      tree.update(
+        React.createElement(Harness, {data: data2, store: storeAfterCommit}),
+      );
+    });
+    expect(setItems).toHaveBeenCalledTimes(2);
+    expect(setItems).toHaveBeenLastCalledWith(data2);
+
+    tree.unmount();
+  });
+
+  it('hydrates stored filters once and does not re-setFilters when storeFilters churns (period toggle #185)', () => {
+    const setFilters = jest.fn();
+    const setItems = jest.fn();
+    const stored = {
+      alterDate: {shortcut: 'today', customRange: {from: '', to: ''}},
+    };
+    mockResolveStoredTableFiltersPreference.mockReturnValue(stored);
+    mockSanitizeTableFiltersPreference.mockImplementation(({filters}) => filters || {});
+
+    const columnsForTable = [{name: 'alterDate', externalFilter: true}];
+    const store = {actions: {setFilters, setItems}, getters: {}};
+
+    let tree;
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(Harness, {
+          data: [],
+          store,
+          storeFilters: {},
+          columnsForTable,
+        }),
+      );
+    });
+
+    expect(setFilters).toHaveBeenCalledTimes(1);
+    expect(setFilters).toHaveBeenCalledWith(stored);
+
+    // Simulate user toggle today → all → today: storeFilters identity changes each time
+    const afterAll = {};
+    const afterToday = {
+      alterDate: {shortcut: 'today', customRange: {from: '', to: ''}},
+    };
+
+    renderer.act(() => {
+      tree.update(
+        React.createElement(Harness, {
+          data: [],
+          store: {actions: {setFilters, setItems}, getters: {filters: afterAll}},
+          storeFilters: afterAll,
+          columnsForTable,
+        }),
+      );
+    });
+    renderer.act(() => {
+      tree.update(
+        React.createElement(Harness, {
+          data: [],
+          store: {actions: {setFilters, setItems}, getters: {filters: afterToday}},
+          storeFilters: afterToday,
+          columnsForTable,
+        }),
+      );
+    });
+
+    // Must remain a single hydrate — no chase of storeFilters
+    expect(setFilters).toHaveBeenCalledTimes(1);
+
+    tree.unmount();
+  });
+
+  it('areTableFiltersEqual treats equivalent period payloads as equal', () => {
+    const a = {alterDate: {shortcut: 'today', customRange: {from: '', to: ''}}};
+    const b = {alterDate: {shortcut: 'today', customRange: {from: '', to: ''}}};
+    expect(areTableFiltersEqual(a, b)).toBe(true);
+    expect(areTableFiltersEqual(a, {alterDate: {shortcut: 'all'}})).toBe(false);
+    expect(areTableFiltersEqual({}, {})).toBe(true);
+  });
+});

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

@@ -0,0 +1,353 @@
+const mockReact = require('react');
+const renderer = require('react-test-renderer');
+
+const {describe, expect, it, beforeEach} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const mockFileActions = {
+  getItems: jest.fn(),
+};
+
+const mockRelationActions = {
+  save: jest.fn(),
+  remove: jest.fn(),
+};
+
+jest.mock('@env', () => ({
+  env: {
+    API_ENTRYPOINT: 'https://api.controleonline.com',
+    DOMAIN: 'manager.controleonline.com',
+  },
+}), {virtual: true});
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => {
+    if (name === 'file') {
+      return {
+        actions: mockFileActions,
+        getters: {},
+      };
+    }
+
+    if (name === 'product_file' || name === 'category_file') {
+      return {
+        actions: mockRelationActions,
+        getters: {},
+      };
+    }
+
+    return {
+      actions: {},
+      getters: {},
+    };
+  }),
+}), {virtual: true});
+
+jest.mock(
+  '@expo/vector-icons',
+  () => ({
+    MaterialCommunityIcons: props =>
+      mockReact.createElement('icon', props, props.children),
+  }),
+  {virtual: true},
+);
+
+jest.mock('react-native-vector-icons/Feather', () => props =>
+  mockReact.createElement('feathericon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('@controleonline/ui-common/src/react/components/AnimatedModal', () => {
+  return props => (props.visible ? mockReact.createElement('modal', props, props.children) : null);
+}, {virtual: true});
+
+jest.mock('@controleonline/ui-default/src/react/components/files/DefaultFile', () => {
+  return props => mockReact.createElement('defaultfile', props, props.children);
+}, {virtual: true});
+
+jest.mock('../../../../react/components/upload/fileUpload', () => ({
+  selectFile: jest.fn(),
+  uploadFileToApi: jest.fn(),
+  toFileIri: jest.fn(),
+  extractFileId: value => value?.id || value,
+}), {virtual: true});
+
+jest.mock('react-native', () => ({
+  ActivityIndicator: props => mockReact.createElement('activityindicator', props, props.children),
+  Platform: {OS: 'web'},
+  ScrollView: props => mockReact.createElement('scrollview', props, props.children),
+  Text: props => mockReact.createElement('text', props, props.children),
+  TextInput: props => mockReact.createElement('textinput', props, props.children),
+  TouchableOpacity: props => mockReact.createElement('touchableopacity', props, props.children),
+  View: props => mockReact.createElement('view', props, props.children),
+}), {virtual: true});
+
+const {selectFile, uploadFileToApi, toFileIri} = require('../../../../react/components/upload/fileUpload');
+const DefaultUpload = require('../../../../react/components/upload/DefaultUpload').default;
+
+const flush = () => new Promise(resolve => setImmediate(resolve));
+
+const collectText = node =>
+  node
+    .findAllByType('text')
+    .map(textNode => {
+      const children = textNode.props.children;
+      if (Array.isArray(children)) {
+        return children.flat(Infinity).join('');
+      }
+      return children || '';
+    })
+    .join('');
+
+const findButtonByLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => collectText(button).includes(label));
+
+const findButtonByAccessibilityLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => button.props.accessibilityLabel === label);
+
+describe('DefaultUpload', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('abre a biblioteca, carrega arquivos e envia um arquivo pelo helper centralizado', async () => {
+    mockFileActions.getItems.mockResolvedValue({
+      member: [
+        {id: 10, fileName: 'Biblioteca 1', context: 'products', fileType: 'image'},
+      ],
+    });
+    mockRelationActions.save.mockResolvedValue({id: 42});
+    selectFile.mockResolvedValue({
+      name: 'nova-imagem.png',
+      uri: 'file:///nova-imagem.png',
+      mimeType: 'image/png',
+    });
+    uploadFileToApi.mockResolvedValue({id: 77, fileName: 'nova-imagem.png'});
+    toFileIri.mockReturnValue('/files/77');
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'product_file',
+          relationField: 'product',
+          relationResource: 'products',
+          entityId: 12,
+          companyId: 3,
+          attachments: [{id: 1, file: {id: 1, fileName: 'Anexa'}}],
+          context: 'products',
+          title: 'Imagens anexas',
+          triggerLabel: 'Gerenciar imagens',
+          managerTitle: 'Gerenciador de imagens',
+          searchPlaceholder: 'Buscar imagem',
+          uploadButtonLabel: 'Enviar nova',
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Gerenciar imagens').props.onPress();
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalled();
+
+    const uploadButton = findButtonByLabel(tree.root, 'Enviar nova');
+    expect(uploadButton).toBeTruthy();
+
+    await renderer.act(async () => {
+      await uploadButton.props.onPress();
+      await flush();
+    });
+
+    expect(selectFile).toHaveBeenCalledWith('image/*');
+    expect(uploadFileToApi).toHaveBeenCalledWith({
+      file: expect.objectContaining({name: 'nova-imagem.png'}),
+      context: 'products',
+      peopleId: 3,
+      entityId: 12,
+    });
+    expect(mockRelationActions.save).toHaveBeenCalledWith({
+      product: '/products/12',
+      file: '/files/77',
+    });
+  });
+
+  it('permite que o pai gerencie upload anexado e remocao por contexto customizado', async () => {
+    const onChanged = jest.fn();
+    const onUploadFile = jest.fn().mockResolvedValue({id: 8, file: {id: 88}});
+    const onRemoveAttachment = jest.fn().mockResolvedValue({});
+
+    mockFileActions.getItems.mockResolvedValue({member: []});
+    selectFile.mockResolvedValue({
+      name: 'avatar.png',
+      type: 'image/png',
+    });
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          libraryContexts: ['people_media'],
+          title: 'avatar',
+          triggerLabel: 'Gerenciar avatar',
+          uploadButtonLabel: 'Enviar nova',
+          onChanged,
+          onUploadFile,
+          onRemoveAttachment,
+          uploadResultAlreadyAttached: true,
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Gerenciar avatar').props.onPress();
+      await flush();
+    });
+
+    await renderer.act(async () => {
+      await findButtonByLabel(tree.root, 'Enviar nova').props.onPress();
+      await flush();
+    });
+
+    expect(onUploadFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: 'people_media',
+        entityId: 30,
+        file: expect.objectContaining({name: 'avatar.png'}),
+      }),
+    );
+    expect(mockRelationActions.save).not.toHaveBeenCalled();
+    expect(onChanged).toHaveBeenCalled();
+
+    const removeButton = findButtonByAccessibilityLabel(tree.root, 'Remover');
+    expect(removeButton).toBeTruthy();
+
+    await renderer.act(async () => {
+      await removeButton.props.onPress();
+      await flush();
+    });
+
+    expect(onRemoveAttachment).toHaveBeenCalledWith(
+      expect.objectContaining({file: expect.objectContaining({id: 91})}),
+    );
+    expect(mockRelationActions.remove).not.toHaveBeenCalled();
+  });
+
+  it('normaliza o identificador da relacao antes da remocao customizada', async () => {
+    const onRemoveAttachment = jest.fn().mockResolvedValue({});
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{mediaId: '/people_media/44', file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          title: 'avatar',
+          triggerLabel: 'Gerenciar avatar',
+          onRemoveAttachment,
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      await findButtonByAccessibilityLabel(tree.root, 'Remover').props.onPress();
+      await flush();
+    });
+
+    expect(onRemoveAttachment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '44',
+        mediaId: '/people_media/44',
+        file: expect.objectContaining({id: 91}),
+      }),
+    );
+  });
+
+  it('renderiza apenas o gatilho customizado quando o conteudo inline fica desativado', async () => {
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          title: 'avatar',
+          showInlineContent: false,
+          renderTrigger: ({openManager}) =>
+            mockReact.createElement(
+              'touchableopacity',
+              {onPress: openManager},
+              mockReact.createElement('text', null, 'Abrir gerenciador customizado'),
+            ),
+        }),
+      );
+    });
+
+    expect(collectText(tree.root)).toContain('Abrir gerenciador customizado');
+    expect(collectText(tree.root)).not.toContain('avatar.png');
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Abrir gerenciador customizado').props.onPress();
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalled();
+  });
+
+  it('nao recarrega a biblioteca quando arrays equivalentes sao recriados', async () => {
+    mockFileActions.getItems.mockResolvedValue({member: []});
+    let tree;
+    const renderProps = () => ({
+      relationStoreName: 'people',
+      relationField: 'people',
+      relationResource: 'people',
+      entityId: 30,
+      companyId: 30,
+      context: 'company_certificate',
+      libraryContexts: ['company_certificate'],
+      knownFileIds: [],
+      showInlineContent: false,
+      renderTrigger: ({openManager}) =>
+        mockReact.createElement('touchableopacity', {onPress: openManager}, 'Abrir'),
+    });
+
+    await renderer.act(async () => {
+      tree = renderer.create(mockReact.createElement(DefaultUpload, renderProps()));
+    });
+
+    await renderer.act(async () => {
+      tree.root.findByType('touchableopacity').props.onPress();
+      await flush();
+    });
+
+    await renderer.act(async () => {
+      tree.update(mockReact.createElement(DefaultUpload, renderProps()));
+      tree.update(mockReact.createElement(DefaultUpload, renderProps()));
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,104 @@
+/** @jest-environment node */
+
+/** app-community#433 — library lists all people_media files for the person */
+const {
+  fetchLibraryFiles,
+  filesFromPeopleMediaRelations,
+  normalizeSeedLibraryFiles,
+} = require('../../../../react/components/upload/defaultUploadLibrary');
+
+describe('filesFromPeopleMediaRelations', () => {
+  it('extracts embedded file objects with id', () => {
+    const relations = [
+      {id: 1, file: {id: 10, fileName: 'a.png', '@id': '/files/10'}},
+      {id: 2, file: {id: 20, fileName: 'b.png'}},
+      {id: 3, file: null},
+      {id: 4},
+    ];
+    const files = filesFromPeopleMediaRelations(relations);
+    expect(files).toHaveLength(2);
+    expect(files.map(f => f.id)).toEqual([10, 20]);
+  });
+});
+
+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 and no seed', async () => {
+    const result = await fetchLibraryFiles({fileActions: {}});
+    expect(result).toEqual([]);
+  });
+
+  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([
+      {id: 1, file: {id: 10, fileName: 'from-files.png'}},
+      {id: 2, file: {id: 11, fileName: 'only-relation.png'}},
+    ]);
+
+    const files = await fetchLibraryFiles({
+      fileActions: {getItems},
+      companyId: 103446,
+      fileType: 'image',
+      libraryContexts: ['people_media'],
+      peopleActions: {getPeopleMedia},
+      additionalLibraryFiles: [{id: 3, file: {id: 12, fileName: 'seeded.png'}}],
+    });
+
+    expect(getItems).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: 'people_media',
+        people: '/people/103446',
+        itemsPerPage: 500,
+        page: 1,
+      }),
+    );
+    expect(getPeopleMedia).toHaveBeenCalledWith(
+      expect.objectContaining({
+        people: '/people/103446',
+        itemsPerPage: 100,
+      }),
+    );
+    const ids = files.map(f => String(f.id)).sort();
+    expect(ids).toEqual(['10', '11', '12']);
+  });
+
+  it('still returns /files results if people_media fetch fails', async () => {
+    const getItems = jest.fn().mockResolvedValue({
+      member: [{id: 5, fileName: 'ok.png'}],
+    });
+    const getPeopleMedia = jest.fn().mockRejectedValue(new Error('network'));
+
+    const files = await fetchLibraryFiles({
+      fileActions: {getItems},
+      companyId: 1,
+      libraryContexts: ['people_media'],
+      peopleActions: {getPeopleMedia},
+    });
+
+    expect(files).toHaveLength(1);
+    expect(files[0].id).toBe(5);
+  });
+});

package/src/tests/react/components/upload/peopleMediaLibraryPreview.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '../../../../../');
+const require = createRequire(import.meta.url);
+const lib = require(join(root, 'src/react/components/upload/defaultUploadLibrary.js'));
+
+test('people_media path never requires peopleIri to avoid GET /files', async () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/defaultUploadLibrary.js'),
+    'utf8',
+  );
+  assert.match(source, /if \(includesPeopleMedia\)/);
+  assert.doesNotMatch(
+    source,
+    /if \(includesPeopleMedia && peopleIri\)/,
+  );
+  // Without peopleIri still returns stubs only
+  const files = await lib.fetchLibraryFiles({
+    fileActions: {
+      getItems: async () => {
+        throw new Error('should not call getItems');
+      },
+      get: async () => {
+        throw new Error('should not call get');
+      },
+    },
+    companyId: null,
+    fileType: 'image',
+    libraryContexts: ['people_media'],
+    peopleActions: null,
+    knownFileIds: [8469],
+  });
+  assert.equal(files.length, 1);
+  assert.equal(files[0].id, 8469);
+});
+
+test('inline attachments list can hide star/trash', () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/DefaultUploadAttachmentsList.js'),
+    'utf8',
+  );
+  assert.match(source, /showAttachmentActions/);
+});
+
+test('manager shows remove for attached library items', () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/DefaultUploadManagerModal.js'),
+    'utf8',
+  );
+  assert.match(source, /trash-can-outline/);
+  assert.match(source, /handleRemove/);
+});