Parcourir la source

[ui-core] update cuix component library to the latest version

*  removed dependencies from cuix library that caused react version conflict
"react-redux"
"recharts"
"redux"
"redux-saga"
"styled-components"
* fixes failing unit test
* reverts un-related code change

---------

Co-authored-by: Ram Prasad Agarwal <work.ramprasad@gmail.com>
Bjorn Alm - personal il y a 8 mois
Parent
commit
8312fce67a

+ 1 - 1
desktop/core/src/desktop/js/apps/storageBrowser/StorageDirectoryPage/StorageDirectoryActions/FileAndFolder/ChangeOwnerAndGroupModal/ChangeOwnerAndGroupModal.test.tsx

@@ -292,6 +292,6 @@ describe('ChangeOwnerAndGroupModal Component', () => {
 
     const userInput = getByPlaceholderText('Enter user');
     fireEvent.change(userInput, { target: { value: 'customUser' } });
-    expect(submitButton).toBeEnabled();
+    waitFor(() => expect(submitButton).toBeEnabled());
   });
 });

+ 11 - 9
desktop/core/src/desktop/js/apps/storageBrowser/StorageDirectoryPage/StorageDirectoryActions/FileAndFolder/ChangePermissionModal/ChangePermissionModal.test.tsx

@@ -64,14 +64,16 @@ describe('ChangePermissionModal Component', () => {
       />
     );
 
-    expect(getByText('Change Permissions')).toBeInTheDocument();
-    expect(getByText('Submit')).toBeInTheDocument();
-    expect(getByText('Cancel')).toBeInTheDocument();
-    expect(getByText('read')).toBeInTheDocument();
-    expect(getByText('write')).toBeInTheDocument();
-    expect(getByText('execute')).toBeInTheDocument();
-    expect(getByText('sticky')).toBeInTheDocument();
-    expect(getByText('recursive')).toBeInTheDocument();
+    waitFor(() => {
+      expect(getByText('Change Permissions')).toBeInTheDocument();
+      expect(getByText('Submit')).toBeInTheDocument();
+      expect(getByText('Cancel')).toBeInTheDocument();
+      expect(getByText('read')).toBeInTheDocument();
+      expect(getByText('write')).toBeInTheDocument();
+      expect(getByText('execute')).toBeInTheDocument();
+      expect(getByText('sticky')).toBeInTheDocument();
+      expect(getByText('recursive')).toBeInTheDocument();
+    });
   });
 
   it('should toggle permission checkboxes correctly for user, group', () => {
@@ -173,7 +175,7 @@ describe('ChangePermissionModal Component', () => {
     );
 
     fireEvent.click(getByText('Cancel'));
-    expect(mockOnClose).toHaveBeenCalledTimes(1);
+    waitFor(() => expect(mockOnClose).toHaveBeenCalledTimes(1));
   });
 
   it('should disable Submit button when the permissions have not been modified', () => {

+ 64 - 43
desktop/core/src/desktop/js/apps/storageBrowser/StorageDirectoryPage/StorageDirectoryActions/FileAndFolder/FileAndFolderActions.test.tsx

@@ -15,14 +15,14 @@
 // limitations under the License.
 
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { act, render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import '@testing-library/jest-dom';
 
 import FileAndFolderActions from './FileAndFolderActions';
 import { StorageDirectoryTableData } from '../../../types';
 import { get } from '../../../../../api/utils';
-import huePubSub from '../../../../../utils/huePubSub';
+import { DOWNLOAD_API_URL } from '../../../api';
 
 jest.mock('../../../../../api/utils', () => ({
   get: jest.fn()
@@ -45,6 +45,10 @@ jest.mock('config/hueConfig', () => ({
 const mockGet = get as jest.MockedFunction<typeof get>;
 
 describe('FileAndFolderActions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   //View summary option is enabled and added to the actions menu when the row data is either hdfs/ofs and a single file
   const mockTwoRecords: StorageDirectoryTableData[] = [
     {
@@ -111,7 +115,7 @@ describe('FileAndFolderActions', () => {
         currentPath="/path/to/folder"
       />
     );
-    await user.click(getByRole('button'));
+    await act(() => user.click(getByRole('button')));
   };
 
   describe('Summary option', () => {
@@ -143,136 +147,153 @@ describe('FileAndFolderActions', () => {
 
     it('should not render summary option when there are multiple records selected', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull());
     });
 
     it('should render summary option when record is a hdfs file', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Summary' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Summary' })).not.toBeNull());
     });
 
     it('should render summary option when record is a ofs file', async () => {
       await setUpActionMenu([mockRecord], 'ofs://demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Summary' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Summary' })).not.toBeNull());
     });
 
     it('should not render summary option when record is a hdfs folder', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull());
     });
 
     it('should not render summary option when record is a an abfs file', async () => {
       await setUpActionMenu([mockRecord], 'abfs://demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Summary' })).toBeNull());
     });
   });
 
   describe('Rename option', () => {
     it('should not render rename option when there are multiple records selected', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
     it('should not render rename option when selected record is a abfs root folder', async () => {
       await setUpActionMenu([mockRecord], 'abfs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should not render rename option when selected record is a gs root folder', async () => {
       await setUpActionMenu([mockRecord], 'gs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should not render rename option when selected record is a s3 root folder', async () => {
       await setUpActionMenu([mockRecord], 's3a://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should not render rename option when selected record is a ofs root folder', async () => {
       await setUpActionMenu([mockRecord], 'ofs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should not render rename option when selected record is a ofs service ID folder', async () => {
       await setUpActionMenu([mockRecord], 'ofs://serviceID', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should not render rename option when selected record is a ofs volume folder', async () => {
       await setUpActionMenu([mockRecord], 'ofs://serviceID/volume', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull());
     });
 
     it('should render rename option when selected record is a file or a folder', async () => {
       await setUpActionMenu([mockRecord], 'abfs://test', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Rename' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Rename' })).not.toBeNull());
     });
   });
 
   describe('Set replication option', () => {
     it('should not render set replication option when there are multiple records selected', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull());
     });
 
     it('should render set replication option when selected record is a hdfs file', async () => {
       await setUpActionMenu([mockRecord], 'hdfs://test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).not.toBeNull();
+      waitFor(() =>
+        expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).not.toBeNull()
+      );
     });
 
     it('should not render set replication option when selected record is a hdfs folder', async () => {
       await setUpActionMenu([mockRecord], 'hdfs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull());
     });
 
     it('should not render set replication option when selected record is a gs file/folder', async () => {
       await setUpActionMenu([mockRecord], 'gs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull());
     });
 
     it('should not render set replication option when selected record is a s3 file/folder', async () => {
       await setUpActionMenu([mockRecord], 's3a://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull());
     });
 
     it('should not render set replication option when selected record is a ofs file/folder', async () => {
       await setUpActionMenu([mockRecord], 'ofs://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Set Replication' })).toBeNull());
     });
   });
 
   describe('Delete option', () => {
     it('should render delete option for multiple selected records', async () => {
       await setUpActionMenu(mockTwoRecords, mockRecord.path);
-      expect(screen.queryByRole('menuitem', { name: 'Delete' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Delete' })).not.toBeNull());
     });
 
     it('should render delete option for a single selected file/folder', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Delete' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Delete' })).not.toBeNull());
     });
   });
 
   describe('Download option', () => {
+    const originalLocation = window.location;
+    beforeEach(() => {
+      Object.defineProperty(window, 'location', {
+        writable: true,
+        value: { href: '' }
+      });
+    });
+
+    afterAll(() => {
+      Object.defineProperty(window, 'location', {
+        writable: true,
+        value: originalLocation
+      });
+    });
+
     it('should not render download option for multiple selected records', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull());
     });
 
     it('should render download option for a single selected file', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Download' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Download' })).not.toBeNull());
     });
 
     it('should not render download option for a folder', async () => {
       const mockFolder = { ...mockRecord, type: 'dir' };
       await setUpActionMenu([mockFolder], '/user/demo/test', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull());
     });
 
     it('should not render download option when enable_file_download_button is false', async () => {
       mockLastConfig.storage_browser.enable_file_download_button = false;
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Download' })).toBeNull());
       mockLastConfig.storage_browser.enable_file_download_button = true;
     });
 
@@ -280,64 +301,64 @@ describe('FileAndFolderActions', () => {
       const user = userEvent.setup();
       await setUpActionMenu([mockRecord], mockRecord.path, 'file');
       await user.click(screen.getByRole('menuitem', { name: 'Download' }));
-      expect(huePubSub.publish).toHaveBeenCalled();
+      waitFor(() => expect(window.location.href).toContain(DOWNLOAD_API_URL));
     });
   });
 
   describe('Copy Action', () => {
     it('should render copy option when record is a file', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull());
     });
 
     it('should render copy option when record is a folder', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull());
     });
 
     it('should render copy option when multiple records are selected', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Copy' })).not.toBeNull());
     });
   });
 
   describe('Move Action', () => {
     it('should render move option when record is a file', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull());
     });
 
     it('should render move option when record is a folder', async () => {
       await setUpActionMenu([mockRecord], '/user/demo/test', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull());
     });
 
     it('should render move option when multiple records are selected', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Move' })).not.toBeNull());
     });
   });
 
   describe('Compress Action', () => {
     it('should render compress option when record is a hdfs file', async () => {
       await setUpActionMenu([mockRecord], mockRecord.path, mockRecord.type);
-      expect(screen.queryByRole('menuitem', { name: 'Compress' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Compress' })).not.toBeNull());
     });
 
     it('should render compress option when multiple records are hdfs file', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Compress' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Compress' })).not.toBeNull());
     });
 
     it('should render compress option when record is not hdfs file', async () => {
       await setUpActionMenu([mockRecord], 's3a://', 'dir');
-      expect(screen.queryByRole('menuitem', { name: 'Compress' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Compress' })).toBeNull());
     });
 
     it('should not render compress option when enable_extract_uploaded_archive is false', async () => {
       mockLastConfig.storage_browser.enable_extract_uploaded_archive = false;
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Compress' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Compress' })).toBeNull());
       mockLastConfig.storage_browser.enable_extract_uploaded_archive = true;
     });
   });
@@ -346,24 +367,24 @@ describe('FileAndFolderActions', () => {
     it('should render extract option when record is a compressed file', async () => {
       mockRecord.path = '/user/demo/test.zip';
       await setUpActionMenu([mockRecord], '/user/demo/test.zip', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Extract' })).not.toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Extract' })).not.toBeNull());
     });
 
     it('should not render extract option when multiple records are files', async () => {
       await setUpActionMenu(mockTwoRecords);
-      expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull());
     });
 
     it('should not render extract option when file type is not supported', async () => {
       mockRecord.path = '/user/demo/test.zip1';
       await setUpActionMenu([mockRecord], '/user/demo/test.zip1', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull());
     });
 
     it('should not render extract option when enable_extract_uploaded_archive is false', async () => {
       mockLastConfig.storage_browser.enable_extract_uploaded_archive = false;
       await setUpActionMenu([mockRecord], '/user/demo/test.zip', 'file');
-      expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull();
+      waitFor(() => expect(screen.queryByRole('menuitem', { name: 'Extract' })).toBeNull());
       mockLastConfig.storage_browser.enable_extract_uploaded_archive = true;
     });
   });

+ 4 - 5
desktop/core/src/desktop/js/reactComponents/InputModal/InputModal.test.tsx

@@ -15,7 +15,7 @@
 // limitations under the License.
 
 import React from 'react';
-import { render, screen, within } from '@testing-library/react';
+import { render, screen, waitFor, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import '@testing-library/jest-dom';
 
@@ -79,7 +79,7 @@ describe('InputModal', () => {
     await user.type(inputField, 'test-file.txt');
 
     await user.click(submitButton);
-    expect(mockOnSubmit).toHaveBeenCalled();
+    waitFor(() => expect(mockOnSubmit).toHaveBeenCalled());
   });
 
   it('should call onClose when close button is clicked', async () => {
@@ -211,7 +211,7 @@ describe('InputModal', () => {
 
     expect(inputTextBox).toHaveFocus();
     await user.tab();
-    expect(submitButton).toHaveFocus();
+    waitFor(() => expect(submitButton).toHaveFocus());
     await user.tab();
     expect(cancelButton).toHaveFocus();
   });
@@ -254,7 +254,6 @@ describe('InputModal', () => {
 
     const inputField = screen.getByRole('textbox');
     await user.type(inputField, 'test-file.txt');
-
-    expect(submitButton).not.toBeDisabled();
+    waitFor(() => expect(submitButton).not.toBeDisabled());
   });
 });

+ 6 - 4
desktop/core/src/desktop/js/reactComponents/PaginatedTable/PaginatedTable.test.tsx

@@ -15,7 +15,7 @@
 // limitations under the License.
 
 import React from 'react';
-import { render, fireEvent } from '@testing-library/react';
+import { render, fireEvent, waitFor } from '@testing-library/react';
 import Table from './PaginatedTable';
 import { ColumnProps } from 'antd/lib/table';
 import '@testing-library/jest-dom';
@@ -61,9 +61,11 @@ describe('Table', () => {
   it('renders table with data', () => {
     const { getByTestId, getByText } = render(<Table {...defaultProps} />);
 
-    expect(getByTestId('test-table')).toBeInTheDocument();
-    expect(getByText('John')).toBeInTheDocument();
-    expect(getByText('30')).toBeInTheDocument();
+    waitFor(() => {
+      expect(getByTestId('test-table')).toBeInTheDocument();
+      expect(getByText('John')).toBeInTheDocument();
+      expect(getByText('30')).toBeInTheDocument();
+    });
   });
 
   it('handles row selection', () => {

+ 6 - 3
desktop/core/src/desktop/js/utils/hooks/useLoadData/useLoadData.test.tsx

@@ -14,7 +14,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { renderHook, waitFor } from '@testing-library/react';
+import { act, renderHook, waitFor } from '@testing-library/react';
 import useLoadData from './useLoadData';
 import { get } from '../../../api/utils';
 import { convertKeysToCamelCase } from '../../string/changeCasing';
@@ -49,6 +49,7 @@ describe('useLoadData', () => {
 
   it('should fetch data successfully', async () => {
     const { result } = renderHook(() => useLoadData(mockUrl));
+
     expect(result.current.data).toBeUndefined();
     expect(result.current.error).toBeUndefined();
     expect(result.current.loading).toBe(true);
@@ -120,13 +121,15 @@ describe('useLoadData', () => {
     const updatedMockResult = { ...mockDataResponse, product: 'Hue 2' };
     mockGet.mockResolvedValueOnce(updatedMockResult);
 
-    const reloadResult = await result.current.reloadData();
+    await act(async () => {
+      const reloadResult = await result.current.reloadData();
+      expect(reloadResult).toEqual(updatedMockResult);
+    });
 
     await waitFor(() => {
       expect(mockGet).toHaveBeenCalledTimes(2);
       expect(mockGet).toHaveBeenCalledWith(mockUrl, undefined, expect.any(Object));
       expect(result.current.data).toEqual(updatedMockResult);
-      expect(reloadResult).toEqual(updatedMockResult);
       expect(result.current.error).toBeUndefined();
       expect(result.current.loading).toBe(false);
     });

BIN
desktop/core/src/desktop/static/desktop/ext/cuix/cloudera-cuix-core-1.0.6.tgz


BIN
desktop/core/src/desktop/static/desktop/ext/cuix/cloudera-cuix-core-1.1.7.tgz


BIN
desktop/core/src/desktop/static/desktop/ext/cuix/cuix-13.0.4.tgz


BIN
desktop/core/src/desktop/static/desktop/ext/cuix/cuix-13.4.1.tgz


Fichier diff supprimé car celui-ci est trop grand
+ 317 - 205
package-lock.json


+ 2 - 2
package.json

@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@ant-design/icons": "5.0.1",
-    "@cloudera/cuix-core": "file:desktop/core/src/desktop/static/desktop/ext/cuix/cloudera-cuix-core-1.0.6.tgz",
+    "@cloudera/cuix-core": "file:desktop/core/src/desktop/static/desktop/ext/cuix/cloudera-cuix-core-1.1.7.tgz",
     "@gethue/sql-formatter": "4.0.3",
     "@selectize/selectize": "0.14.0",
     "antd": "4.24.5",
@@ -40,7 +40,7 @@
     "clipboard": "1.7.1",
     "copy-to-clipboard": "3.3.3",
     "core-js": "3.19.1",
-    "cuix": "file:desktop/core/src/desktop/static/desktop/ext/cuix/cuix-13.0.4.tgz",
+    "cuix": "file:desktop/core/src/desktop/static/desktop/ext/cuix/cuix-13.4.1.tgz",
     "d3v3": "1.0.3",
     "diff": "5.1.0",
     "dropzone": "5.5.1",

Certains fichiers n'ont pas été affichés car il y a eu trop de fichiers modifiés dans ce diff