@controleonline/ui-common 1.2.78 → 1.2.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@controleonline/ui-common",
-  "version": "1.2.78",
+  "version": "1.2.79",
   "author": "ControleOnline",
   "description": "ControleOnline Common Quasar UI Component",
   "license": "MIT",

package/src/react/pages/DeviceDetailPage.js

@@ -64,6 +64,7 @@ import {
   resolvePosOperationMode,
   resolvePosPrintMode,
 } from '@controleonline/ui-common/src/react/config/deviceConfigBootstrap';
+import { buildDeviceAliasStoreUpdates } from '@controleonline/ui-common/src/react/utils/deviceAliasSync';
 
 import {
   filterDeviceConfigsByCompany,
@@ -496,11 +497,16 @@ const DeviceDetailPage = () => {
   const [savingAlias,  setSavingAlias]  = useState(false);
   const [removingDevice, setRemovingDevice] = useState(false);
   const aliasInputRef = useRef(null);
+  const skipAliasSyncFromStoreRef = useRef(false);
 
   useEffect(() => {
     if (editingAlias) {
       return;
     }
+    if (skipAliasSyncFromStoreRef.current) {
+      skipAliasSyncFromStoreRef.current = false;
+      return;
+    }
 
     setAlias(initialAlias || '');
     setAliasInput(initialAlias || '');
@@ -1060,6 +1066,19 @@ const DeviceDetailPage = () => {
         alias: trimmed,
       });
       const nextAlias = String(savedDevice?.alias || trimmed).trim();
+      const { mergedDevice, nextDeviceConfig } = buildDeviceAliasStoreUpdates({
+        deviceId,
+        nextAlias,
+        runtimeDevice,
+        runtimeDeviceConfig,
+        savedDevice,
+        normalizeEntityId,
+      });
+      actionsRef.current.deviceActions.setItem?.(mergedDevice);
+      if (nextDeviceConfig && actionsRef.current.deviceConfigActions?.setItem) {
+        actionsRef.current.deviceConfigActions.setItem(nextDeviceConfig);
+      }
+      skipAliasSyncFromStoreRef.current = true;
       setAlias(nextAlias);
       setAliasInput(nextAlias);
       setEditingAlias(false);
@@ -1075,28 +1094,25 @@ const DeviceDetailPage = () => {
     if (!deviceId || removingDevice) {
       return;
     }
-    Alert.alert(
-      'Excluir device',
-      `Tem certeza que deseja excluir o device "${alias || deviceString || deviceId}"? Esta ação não pode ser desfeita.`,
-      [
-        { text: 'Cancelar', style: 'cancel' },
-        {
-          text: 'Excluir',
-          style: 'destructive',
-          onPress: async () => {
-            setRemovingDevice(true);
-            try {
-              await actionsRef.current.deviceActions.remove(deviceId);
-              navigation.navigate('DevicesIndex');
-            } catch (error) {
-              showSystemError(error, 'Não foi possível excluir o device.');
-            } finally {
-              setRemovingDevice(false);
-            }
-          },
-        },
-      ],
-    );
+    const label = String(alias || deviceString || deviceId).trim();
+    const message = `Tem certeza que deseja excluir o device "${label}"? Esta ação não pode ser desfeita.`;
+    // Use web-safe confirm() (window.confirm on web; Alert.alert on native).
+    // Alert.alert alone is a no-op on Manager web — root cause of "click does nothing".
+    confirm(message, async () => {
+      setRemovingDevice(true);
+      try {
+        await actionsRef.current.deviceActions.remove(deviceId);
+        if (navigation?.canGoBack?.()) {
+          navigation.goBack();
+        } else {
+          navigation.navigate('DevicesIndex');
+        }
+      } catch (error) {
+        showSystemError(error, 'Não foi possível excluir o device.');
+      } finally {
+        setRemovingDevice(false);
+      }
+    });
   }, [deviceId, removingDevice, alias, deviceString, navigation, showSystemError]);
 
   const saveDevicePaymentTarget = useCallback(async (override = {}) => {
@@ -1934,6 +1950,7 @@ const DeviceDetailPage = () => {
                     activeOpacity={0.8}
                     disabled={removingDevice || savingAlias}
                     accessibilityLabel="Excluir device"
+                    testID="device-detail-delete-btn"
                   >
                     <Icon
                       name={removingDevice ? 'loader' : 'trash-2'}

package/src/react/pages/Devices/deviceTypes/DeviceGroupCard.js

@@ -26,8 +26,44 @@ import {
 } from './deviceListHelpers';
 import styles from '../../Devices.styles';
 
+/**
+ * Normalize DefaultTable card `item` into a device group shape.
+ * DefaultTable can hand us either a grouped object ({device, deviceConfigs})
+ * or a flat device_config entity from the store (no deviceConfigs array).
+ * Accessing `.deviceConfigs[0]` on a flat item throws TypeError (app-community#627 KDS).
+ */
+const normalizeDeviceGroup = item => {
+  if (!item || typeof item !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(item.deviceConfigs)) {
+    return item;
+  }
+
+  // Flat device_config row from store — promote to single-config group.
+  if (item.device != null || item.type != null || item.id != null) {
+    return {
+      key:
+        item.key ||
+        item['@id'] ||
+        (item.id != null ? `config:${item.id}` : undefined),
+      device: item.device && typeof item.device === 'object' ? item.device : {},
+      deviceConfigs: [item],
+      primaryConfig: item,
+      alias:
+        item.alias ||
+        item.device?.alias ||
+        item.device?.device ||
+        undefined,
+    };
+  }
+
+  return null;
+};
+
 export default function DeviceGroupCard({
-  item: deviceGroup,
+  item,
   brandColors,
   creatingPdv,
   goToDetail,
@@ -38,6 +74,13 @@ export default function DeviceGroupCard({
   runtimeDeviceType,
   showCurrentPdvSetup,
 }) {
+        const deviceGroup = normalizeDeviceGroup(item);
+        if (!deviceGroup) {
+          return null;
+        }
+        const deviceConfigs = Array.isArray(deviceGroup.deviceConfigs)
+          ? deviceGroup.deviceConfigs
+          : [];
         const isCurrentDevice = isCurrentDeviceGroup({
           deviceGroup,
           runtimeDeviceIdentifier,
@@ -52,7 +95,8 @@ export default function DeviceGroupCard({
         const primaryConfig =
           sessionConfig ||
           filteredTypeConfig ||
-          deviceGroup.deviceConfigs[0] ||
+          deviceGroup.primaryConfig ||
+          deviceConfigs[0] ||
           null;
         const normalizedType = primaryConfig
           ? getDeviceConfigType(primaryConfig)
@@ -150,7 +194,7 @@ export default function DeviceGroupCard({
                 </Text>
 
                 <View style={styles.deviceConfigRow}>
-                  {deviceGroup.deviceConfigs.map(deviceConfig => {
+                  {deviceConfigs.map(deviceConfig => {
                     const configType = getDeviceConfigType(deviceConfig);
                     const configAccent = getDeviceTypeAccent(configType);
                     const isSessionConfig =

package/src/react/pages/Devices/deviceTypes/deviceListHelpers.js

@@ -138,6 +138,12 @@ export const getDeviceListIdentifier = deviceConfig =>
     deviceConfig,
   }).runtimeDetail || String(deviceConfig?.device?.device || '').trim();
 
+/**
+ * Build list params for device_configs collection.
+ * Always send a single scalar `type` when filtering (API SearchFilter exact).
+ * Callers with multiple queryTypes must request each type separately and merge.
+ * Empty queryTypes = no type filter (All).
+ */
 export const buildDeviceListParams = ({
   companyId,
   page,
@@ -151,17 +157,43 @@ export const buildDeviceListParams = ({
     'order[id]': 'DESC',
   };
 
-  if (Array.isArray(queryTypes) && queryTypes.length === 1) {
-    params.type = queryTypes[0];
-  }
+  const types = Array.isArray(queryTypes)
+    ? queryTypes.map(t => String(t || '').trim()).filter(Boolean)
+    : [];
 
-  if (Array.isArray(queryTypes) && queryTypes.length > 1) {
-    params.type = queryTypes;
+  if (types.length === 1) {
+    params.type = types[0];
   }
 
+  // Multi-type: do NOT set params.type as array — API exact filter is unreliable
+  // with type[]= on some platforms; callers must fetch each type and merge.
+
   return params;
 };
 
+/**
+ * Expand queryTypes into one or more single-type param sets for sequential fetch.
+ * Empty → one set without type (All). Single → one set. Multiple → one set per type.
+ */
+export const expandDeviceListParamSets = ({
+  companyId,
+  page,
+  pageSize = PAGE_SIZE,
+  queryTypes = [],
+}) => {
+  const types = Array.isArray(queryTypes)
+    ? queryTypes.map(t => String(t || '').trim()).filter(Boolean)
+    : [];
+
+  if (types.length === 0) {
+    return [buildDeviceListParams({companyId, page, pageSize, queryTypes: []})];
+  }
+
+  return types.map(type =>
+    buildDeviceListParams({companyId, page, pageSize, queryTypes: [type]}),
+  );
+};
+
 export {
   parseConfigsObject,
   getDeviceConfigType,

package/src/react/pages/Devices/deviceTypes/shared.js

@@ -55,7 +55,7 @@ import {
   getPosOperationModeLabel,
   getDeviceDetailRoute,
   getDeviceListIdentifier,
-  buildDeviceListParams,
+  expandDeviceListParamSets,
   isPdvPrinterEnabled,
 } from './deviceListHelpers';
 
@@ -205,40 +205,45 @@ export const createDeviceTypeTab = ({
 
         try {
           const requestPageSize = Math.max(pageSize, API_PAGE_SIZE);
-          let page = 1;
           let loadedItems = [];
           let reportedTotal = 0;
 
-          while (true) {
-            const pageItems = await deviceConfigStore.actions.getItems(
-              buildDeviceListParams({
-                companyId,
+          const paramSets = expandDeviceListParamSets({
+            companyId,
+            page: 1,
+            pageSize: requestPageSize,
+            queryTypes,
+          });
+
+          for (const baseParams of paramSets) {
+            let page = 1;
+            while (true) {
+              const pageItems = await deviceConfigStore.actions.getItems({
+                ...baseParams,
                 page,
-                pageSize: requestPageSize,
-                queryTypes,
-              }),
-            );
-            const previousLength = loadedItems.length;
-            loadedItems = mergeDeviceConfigs(loadedItems, pageItems);
-            reportedTotal = Math.max(
-              reportedTotal,
-              Number(
-                deviceConfigStore.getters.totalItems ||
-                  loadedItems.length ||
-                  0,
-              ),
-            );
-
-            if (
-              !Array.isArray(pageItems) ||
-              pageItems.length === 0 ||
-              loadedItems.length >= reportedTotal ||
-              loadedItems.length === previousLength
-            ) {
-              break;
+              });
+              const previousLength = loadedItems.length;
+              loadedItems = mergeDeviceConfigs(loadedItems, pageItems);
+              reportedTotal = Math.max(
+                reportedTotal,
+                Number(
+                  deviceConfigStore.getters.totalItems ||
+                    loadedItems.length ||
+                    0,
+                ),
+              );
+
+              if (
+                !Array.isArray(pageItems) ||
+                pageItems.length === 0 ||
+                loadedItems.length >= reportedTotal ||
+                loadedItems.length === previousLength
+              ) {
+                break;
+              }
+
+              page += 1;
             }
-
-            page += 1;
           }
 
           setDeviceConfigs(loadedItems);

package/src/react/utils/deviceAliasSync.js

@@ -0,0 +1,46 @@
+/**
+ * Build device + device_config store payloads after a successful alias save.
+ * Keeps derived initialAlias in sync so UI does not snap back to the old name.
+ */
+export function buildDeviceAliasStoreUpdates({
+  deviceId,
+  nextAlias,
+  runtimeDevice,
+  runtimeDeviceConfig,
+  savedDevice,
+  normalizeEntityId,
+}) {
+  const id = normalizeEntityId(deviceId);
+  const alias = String(nextAlias || '').trim();
+
+  const baseDevice =
+    runtimeDevice &&
+    normalizeEntityId(runtimeDevice?.id || runtimeDevice?.['@id']) === id
+      ? runtimeDevice
+      : {};
+
+  const mergedDevice = {
+    ...baseDevice,
+    ...(savedDevice && typeof savedDevice === 'object' ? savedDevice : {}),
+    id,
+    alias,
+  };
+
+  let nextDeviceConfig = null;
+  if (runtimeDeviceConfig && typeof runtimeDeviceConfig === 'object') {
+    const nestedDevice =
+      runtimeDeviceConfig.device && typeof runtimeDeviceConfig.device === 'object'
+        ? runtimeDeviceConfig.device
+        : {};
+    nextDeviceConfig = {
+      ...runtimeDeviceConfig,
+      device: {
+        ...nestedDevice,
+        id: nestedDevice.id || id,
+        alias,
+      },
+    };
+  }
+
+  return { mergedDevice, nextDeviceConfig };
+}

package/src/tests/browser/manager/devices-type-filters.spec.js

@@ -0,0 +1,322 @@
+const {expect, test} = require('playwright/test');
+const packageJson = require('../../../../../../../package.json');
+const {API_ORIGIN} = require('../../../../../../../src/tests/browser/apiOrigin');
+
+const APP_VERSION = packageJson?.version || '1.0.0';
+const CURRENT_DEVICE_ID = 'web-7';
+
+const CORS_HEADERS = {
+  'access-control-allow-origin': '*',
+  'access-control-allow-headers':
+    'API-TOKEN, APP-DOMAIN, DEVICE, ACCEPT, CONTENT-TYPE, X-Requested-With',
+  'access-control-allow-methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+};
+
+const jsonHeaders = () => ({
+  ...CORS_HEADERS,
+  'content-type': 'application/ld+json; charset=utf-8',
+});
+
+const collection = member => ({
+  member,
+  'hydra:member': member,
+  totalItems: member.length,
+  'hydra:totalItems': member.length,
+  summary: {},
+});
+
+const currentDevice = {
+  '@id': '/devices/396',
+  '@type': 'Device',
+  id: 396,
+  device: CURRENT_DEVICE_ID,
+  alias: 'Caixa atual',
+  metadata: {
+    runtime: 'web',
+    network: {publicIp: '127.0.0.1'},
+  },
+};
+
+const printerDevice = {
+  '@id': '/devices/501',
+  '@type': 'Device',
+  id: 501,
+  device: 'printer-1',
+  alias: 'Impressora cozinha',
+  metadata: {runtime: 'network'},
+};
+
+const displayDevice = {
+  '@id': '/devices/502',
+  '@type': 'Device',
+  id: 502,
+  device: 'kds-1',
+  alias: 'KDS salão',
+  metadata: {runtime: 'network'},
+};
+
+const createDeviceConfig = ({id, type, device = currentDevice, alias}) => ({
+  '@id': `/device_configs/${id}`,
+  '@type': 'DeviceConfig',
+  id,
+  type,
+  people: '/people/3',
+  device: alias
+    ? {...device, alias}
+    : device,
+  configs: JSON.stringify({
+    'config-version': APP_VERSION,
+    'pos-gateway': 'infinite-pay',
+  }),
+});
+
+/**
+ * Smoke for app-community#381:
+ * type filters beyond All/PDV must not throw and must request scalar `type`
+ * (or omit type for All). Multi-type filters expand to sequential single-type GETs.
+ */
+const mockDevicesTypeFilterApi = async page => {
+  const company = {
+    id: 3,
+    name: 'Teste',
+    alias: 'TESTE',
+    panel_enabled: true,
+    enabled: true,
+    commercial_enabled: true,
+    theme: {
+      colors: {
+        primary: '#0EA5E9',
+        cardBackground: '#FFFFFF',
+        cardBorder: '#D8E0EA',
+        cardSelectedBackground: '#E8F8FD',
+        cardSelectedBorder: '#0284C7',
+        cardSelectedText: '#0F172A',
+        badgeSelectedBackground: '#CDEFFA',
+        badgeSelectedText: '#075985',
+      },
+    },
+  };
+
+  const allConfigs = [
+    createDeviceConfig({id: 487, type: 'MANAGER'}),
+    createDeviceConfig({id: 488, type: 'PDV'}),
+    createDeviceConfig({
+      id: 501,
+      type: 'PRINTER',
+      device: printerDevice,
+    }),
+    createDeviceConfig({
+      id: 502,
+      type: 'DISPLAY',
+      device: displayDevice,
+    }),
+    createDeviceConfig({id: 503, type: 'DEVICE'}),
+  ];
+
+  const typeRequests = [];
+
+  await page.route(`${API_ORIGIN}/**`, async route => {
+    const request = route.request();
+    const url = new URL(request.url());
+    const pathname = url.pathname.replace(/^\/+/, '');
+    const method = request.method().toUpperCase();
+
+    if (method === 'OPTIONS') {
+      return route.fulfill({status: 204, headers: CORS_HEADERS, body: ''});
+    }
+
+    if (pathname === 'themes-colors.css') {
+      return route.fulfill({
+        status: 200,
+        headers: {...CORS_HEADERS, 'content-type': 'text/css; charset=utf-8'},
+        body: ':root { --primary: #0ea5e9; }',
+      });
+    }
+
+    if (pathname === 'runtime/ip') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify({ip: '127.0.0.1'}),
+      });
+    }
+
+    if (pathname === 'menus-people') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify({modules: {}}),
+      });
+    }
+
+    if (pathname === 'people/companies/my') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(collection([company])),
+      });
+    }
+
+    if (pathname === 'people/company/default') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(company),
+      });
+    }
+
+    if (pathname === 'configs/discovery-configs') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify({configs: {}}),
+      });
+    }
+
+    if (pathname === 'devices' && method === 'GET') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(
+          collection([currentDevice, printerDevice, displayDevice]),
+        ),
+      });
+    }
+
+    if (pathname === 'devices' && method === 'POST') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(currentDevice),
+      });
+    }
+
+    if (pathname === 'device_configs' && method === 'GET') {
+      const requestedType = url.searchParams.get('type');
+      // API Platform array notation would be type[] — must NOT appear for this fix
+      const hasArrayType =
+        url.searchParams.has('type[]') ||
+        [...url.searchParams.keys()].some(k => k === 'type[]' || k.startsWith('type['));
+
+      typeRequests.push({
+        type: requestedType,
+        hasArrayType,
+        search: url.search,
+      });
+
+      if (hasArrayType) {
+        // Simulate the previous failure mode (bad request / empty / error)
+        return route.fulfill({
+          status: 400,
+          headers: jsonHeaders(),
+          body: JSON.stringify({
+            'hydra:description': 'Invalid type filter array notation',
+          }),
+        });
+      }
+
+      const filtered = requestedType
+        ? allConfigs.filter(c => String(c.type).toUpperCase() === String(requestedType).toUpperCase())
+        : allConfigs;
+
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(collection(filtered)),
+      });
+    }
+
+    return route.fulfill({
+      status: 200,
+      headers: jsonHeaders(),
+      body: JSON.stringify(collection([])),
+    });
+  });
+
+  return {typeRequests};
+};
+
+test.describe('Manager devices-index type filters (device_config) #381', () => {
+  test('All, PDV and non-PDV types load without error (scalar type only)', async ({
+    page,
+  }) => {
+    const api = await mockDevicesTypeFilterApi(page);
+    const consoleErrors = [];
+    page.on('pageerror', err => consoleErrors.push(String(err)));
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        consoleErrors.push(msg.text());
+      }
+    });
+
+    await page.goto('/devices-index?store=device_config');
+
+    // Initial All (or default) should render without crash
+    await expect(page.locator('body')).toBeVisible();
+    await expect.poll(() => api.typeRequests.length).toBeGreaterThan(0);
+
+    // Click filter chips by visible labels used in UI
+    const filterLabels = ['Todos', 'PDVs', 'KDS', 'Impressoras', 'Devices'];
+    for (const label of filterLabels) {
+      const chip = page.getByText(label, {exact: true}).first();
+      if (await chip.count()) {
+        await chip.click();
+        // Give list a moment to re-fetch
+        await page.waitForTimeout(400);
+      }
+    }
+
+    // No array-type requests (the bug)
+    const arrayRequests = api.typeRequests.filter(r => r.hasArrayType);
+    expect(arrayRequests).toEqual([]);
+
+    // At least one request without type (All) and one with scalar PDV / PRINTER / DISPLAY
+    const typesSeen = new Set(
+      api.typeRequests.map(r => r.type).filter(Boolean),
+    );
+    // PDV or PRINTER or DISPLAY should have been requested as scalar
+    const hasScalarNonAll = [...typesSeen].some(t =>
+      ['PDV', 'PRINTER', 'PRINT', 'DISPLAY', 'DEVICE', 'IP_CAMERA'].includes(
+        String(t).toUpperCase(),
+      ),
+    );
+    expect(hasScalarNonAll || api.typeRequests.some(r => !r.type)).toBe(true);
+
+    // Page still healthy
+    await expect(page.locator('body')).toBeVisible();
+    const critical = consoleErrors.filter(
+      e =>
+        !/favicon|ResizeObserver|Download the React DevTools/i.test(e) &&
+        /TypeError|ReferenceError|Cannot read|hydra:description|Invalid type/i.test(
+          e,
+        ),
+    );
+    expect(critical).toEqual([]);
+  });
+
+  test('switching All ↔ Printer ↔ All stays stable', async ({page}) => {
+    const api = await mockDevicesTypeFilterApi(page);
+
+    await page.goto('/devices-index?store=device_config');
+    await expect.poll(() => api.typeRequests.length).toBeGreaterThan(0);
+
+    const todos = page.getByText('Todos', {exact: true}).first();
+    const impressoras = page.getByText('Impressoras', {exact: true}).first();
+
+    if (await impressoras.count()) {
+      await impressoras.click();
+      await page.waitForTimeout(350);
+    }
+    if (await todos.count()) {
+      await todos.click();
+      await page.waitForTimeout(350);
+    }
+    if (await impressoras.count()) {
+      await impressoras.click();
+      await page.waitForTimeout(350);
+    }
+
+    expect(api.typeRequests.every(r => !r.hasArrayType)).toBe(true);
+    await expect(page.locator('body')).toBeVisible();
+  });
+});

package/src/tests/react/pages/Devices/deviceListHelpers.test.js

@@ -3,6 +3,7 @@
 const {
   mergeDeviceConfigs,
   buildDeviceListParams,
+  expandDeviceListParamSets,
   PAGE_SIZE,
 } = require('../../../../react/pages/Devices/deviceTypes/deviceListHelpers');
 
@@ -27,13 +28,57 @@ describe('deviceListHelpers', () => {
     expect(params.itemsPerPage).toBe(PAGE_SIZE);
   });
 
-  it('buildDeviceListParams accepts multiple types', () => {
+  it('buildDeviceListParams omits type for empty queryTypes (All)', () => {
+    const params = buildDeviceListParams({
+      companyId: 1,
+      page: 1,
+      queryTypes: [],
+    });
+    expect(params.type).toBeUndefined();
+    expect(params.people).toBe('/people/1');
+  });
+
+  it('buildDeviceListParams does not set array type for multi (caller expands)', () => {
     const params = buildDeviceListParams({
       companyId: 1,
       page: 2,
-      queryTypes: ['PDV', 'PRINTER'],
+      queryTypes: ['PRINT', 'PRINTER'],
     });
-    expect(params.type).toEqual(['PDV', 'PRINTER']);
+    expect(params.type).toBeUndefined();
     expect(params.page).toBe(2);
   });
+
+  it('expandDeviceListParamSets returns one set without type for All', () => {
+    const sets = expandDeviceListParamSets({
+      companyId: 3,
+      page: 1,
+      pageSize: 50,
+      queryTypes: [],
+    });
+    expect(sets).toHaveLength(1);
+    expect(sets[0].type).toBeUndefined();
+    expect(sets[0].people).toBe('/people/3');
+  });
+
+  it('expandDeviceListParamSets returns one set per type for multi', () => {
+    const sets = expandDeviceListParamSets({
+      companyId: 5,
+      page: 1,
+      queryTypes: ['PRINT', 'PRINTER'],
+    });
+    expect(sets).toHaveLength(2);
+    expect(sets[0].type).toBe('PRINT');
+    expect(sets[1].type).toBe('PRINTER');
+    expect(sets[0].people).toBe('/people/5');
+  });
+
+  it('expandDeviceListParamSets single type stays one set', () => {
+    const sets = expandDeviceListParamSets({
+      companyId: 2,
+      page: 1,
+      queryTypes: ['DISPLAY'],
+    });
+    expect(sets).toHaveLength(1);
+    expect(sets[0].type).toBe('DISPLAY');
+  });
 });

package/src/tests/react/utils/deviceAliasSync.test.js

@@ -0,0 +1,48 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  buildDeviceAliasStoreUpdates,
+} = require('../../../react/utils/deviceAliasSync.js');
+
+const normalizeEntityId = value => {
+  if (value == null || value === '') return '';
+  const raw = String(value);
+  const match = raw.match(/(\d+)\s*$/);
+  return match ? match[1] : raw.replace(/\D/g, '') || raw;
+};
+
+test('buildDeviceAliasStoreUpdates merges alias into device and nested config', () => {
+  const { mergedDevice, nextDeviceConfig } = buildDeviceAliasStoreUpdates({
+    deviceId: 42,
+    nextAlias: 'Caixa 01',
+    runtimeDevice: { id: 42, alias: 'Antigo', device: 'uuid-1' },
+    runtimeDeviceConfig: {
+      id: 7,
+      device: { id: 42, alias: 'Antigo', device: 'uuid-1' },
+      configs: {},
+    },
+    savedDevice: { id: 42, alias: 'Caixa 01' },
+    normalizeEntityId,
+  });
+
+  assert.equal(mergedDevice.alias, 'Caixa 01');
+  assert.equal(mergedDevice.id, '42');
+  assert.equal(mergedDevice.device, 'uuid-1');
+  assert.equal(nextDeviceConfig.device.alias, 'Caixa 01');
+  assert.equal(nextDeviceConfig.id, 7);
+});
+
+test('buildDeviceAliasStoreUpdates works without runtimeDeviceConfig', () => {
+  const { mergedDevice, nextDeviceConfig } = buildDeviceAliasStoreUpdates({
+    deviceId: '/devices/9',
+    nextAlias: 'Novo',
+    runtimeDevice: null,
+    runtimeDeviceConfig: null,
+    savedDevice: { '@id': '/devices/9', alias: 'Novo' },
+    normalizeEntityId,
+  });
+
+  assert.equal(mergedDevice.alias, 'Novo');
+  assert.equal(mergedDevice.id, '9');
+  assert.equal(nextDeviceConfig, null);
+});