@controleonline/ui-common 1.2.80 → 1.2.82

package/src/tests/react/components/themeAwareModals.test.mjs

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import {dirname, join} from 'node:path';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '../../..');
+
+const FORBIDDEN_COLOR = /#[0-9a-fA-F]{3,8}\b|\brgba?\s*\(|\bwhite\b|\bblack\b/i;
+
+function loadSource(rel) {
+  return readFileSync(join(root, rel), 'utf8');
+}
+
+test('ConfirmModal.js sources colors only from themeStore getters.colors', () => {
+  const src = loadSource('react/components/ConfirmModal.js');
+  assert.match(src, /themeStore\.getters\.colors|themeColors/);
+  assert.match(src, /modalOverlay|modalBackground|buttonBackground/);
+  assert.doesNotMatch(
+    src.replace(/transparent/g, ''),
+    FORBIDDEN_COLOR,
+    'ConfirmModal.js must not hardcode colors',
+  );
+});
+
+test('ConfirmModal.styles.js createStyles uses only palette tokens', () => {
+  const src = loadSource('react/components/ConfirmModal.styles.js');
+  assert.match(src, /palette\.modalOverlay/);
+  assert.match(src, /palette\.modalBackground/);
+  assert.match(src, /palette\.buttonBackground/);
+  assert.match(src, /palette\.buttonText/);
+  // strip comments and the word transparent (Modal prop, not a color literal in styles)
+  const stripped = src
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\/\/.*$/gm, '')
+    .replace(/transparent/gi, '');
+  assert.doesNotMatch(stripped, FORBIDDEN_COLOR);
+});
+
+test('SystemErrorToast.js sources colors only from themeStore getters.colors', () => {
+  const src = loadSource('react/components/SystemErrorToast.js');
+  assert.match(src, /themeStore\.getters\.colors|themeColors/);
+  assert.match(src, /toastDangerBackground|toastDangerText/);
+  assert.doesNotMatch(
+    src.replace(/transparent/g, ''),
+    FORBIDDEN_COLOR,
+    'SystemErrorToast.js must not hardcode colors',
+  );
+});
+
+test('SystemErrorToast.styles.js createStyles uses only palette tokens', () => {
+  const src = loadSource('react/components/SystemErrorToast.styles.js');
+  assert.match(src, /palette\.toastDangerBackground/);
+  assert.match(src, /palette\.toastDangerText/);
+  const stripped = src
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\/\/.*$/gm, '')
+    .replace(/transparent/gi, '');
+  assert.doesNotMatch(stripped, FORBIDDEN_COLOR);
+});

package/src/tests/react/config/deviceConfigBootstrap.test.js

@@ -1,10 +1,10 @@
-const {jest} = require('@jest/globals')
-
-jest.mock('../../../react/utils/screenMetrics', () => ({
-  appendScreenMetrics: configs => configs,
-  hasScreenMetricsChanges: () => false,
-}))
-
+const {jest} = require('@jest/globals')
+
+jest.mock('../../../react/utils/screenMetrics', () => ({
+  appendScreenMetrics: configs => configs,
+  hasScreenMetricsChanges: () => false,
+}))
+
 const {
   buildProviderManagedDeviceConfigs,
   DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY,
@@ -36,22 +36,24 @@ const {
   resolvePosCashManagementMode,
   resolvePosOperationMode,
   resolvePosPrintMode,
+  POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY,
+  isPosLocalChargeEnabled,
   resolvePosCheckOrderType,
   shouldEnableAndroidKioskMode,
   shouldEnableAndroidLauncherMode,
   shouldUsePosCashRegisterLifecycle,
   isPosTotemMode,
 } = require('../../../react/config/deviceConfigBootstrap')
-
-const {describe, expect, it} = global
-
-describe('deviceConfigBootstrap POS operation helpers', () => {
+
+const {describe, expect, it} = global
+
+describe('deviceConfigBootstrap POS operation helpers', () => {
   it('normalizes balcão as counter and treats counter as self service', () => {
     const configs = {
       [POS_OPERATION_MODE_CONFIG_KEY]: 'balcao',
     }
-
-    expect(resolvePosOperationMode(configs)).toBe('counter')
+
+    expect(resolvePosOperationMode(configs)).toBe('counter')
     expect(isPosCounterMode(configs)).toBe(true)
     expect(isPosSelfServiceMode(configs)).toBe(true)
   })
@@ -65,52 +67,52 @@ describe('deviceConfigBootstrap POS operation helpers', () => {
     expect(isPosSingleItemMode(configs)).toBe(true)
     expect(isPosSelfServiceMode(configs)).toBe(false)
   })
-
-  it('keeps counter auto print disabled by default and allows explicit enablement', () => {
-    const counterConfigs = {
-      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
-    }
-
-    expect(isPosAutoPrintEnabled(counterConfigs)).toBe(false)
-
-    expect(
-      isPosAutoPrintEnabled({
-        ...counterConfigs,
-        [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '1',
-      }),
-    ).toBe(true)
-  })
-
-  it('defaults non-counter modes to auto print enabled', () => {
-    expect(
-      isPosAutoPrintEnabled({
-        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
-      }),
-    ).toBe(true)
-  })
-
-  it('resolves counter daily close mode and skips cash register lifecycle', () => {
-    const configs = {
-      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
-      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'daily',
-    }
-
-    expect(resolvePosCashManagementMode(configs)).toBe('daily')
-    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
-    expect(isPosCashRegisterOpen(configs)).toBe(true)
-    expect(isPosCashRegisterClosed(configs)).toBe(false)
-  })
-
+
+  it('keeps counter auto print disabled by default and allows explicit enablement', () => {
+    const counterConfigs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+    }
+
+    expect(isPosAutoPrintEnabled(counterConfigs)).toBe(false)
+
+    expect(
+      isPosAutoPrintEnabled({
+        ...counterConfigs,
+        [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+
+  it('defaults non-counter modes to auto print enabled', () => {
+    expect(
+      isPosAutoPrintEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      }),
+    ).toBe(true)
+  })
+
+  it('resolves counter daily close mode and skips cash register lifecycle', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'daily',
+    }
+
+    expect(resolvePosCashManagementMode(configs)).toBe('daily')
+    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
+    expect(isPosCashRegisterOpen(configs)).toBe(true)
+    expect(isPosCashRegisterClosed(configs)).toBe(false)
+  })
+
   it('requires cash register lifecycle for counter with open/close policy', () => {
     const closedConfigs = {
       [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
       [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'cash-register',
       'cash-wallet-closed-id': 1,
     }
-
-    expect(shouldUsePosCashRegisterLifecycle(closedConfigs)).toBe(true)
-    expect(isPosCashRegisterClosed(closedConfigs)).toBe(true)
-
+
+    expect(shouldUsePosCashRegisterLifecycle(closedConfigs)).toBe(true)
+    expect(isPosCashRegisterClosed(closedConfigs)).toBe(true)
+
     expect(
       isPosCashRegisterOpen({
         ...closedConfigs,
@@ -369,16 +371,52 @@ describe('deviceConfigBootstrap POS operation helpers', () => {
   })
 
   it('keeps delivery enabled by default and respects explicit disablement', () => {
-    expect(isPosDeliveryEnabled({})).toBe(true)
-    expect(
-      isPosDeliveryEnabled({
-        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '0',
-      }),
-    ).toBe(false)
-    expect(
-      isPosDeliveryEnabled({
-        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
-      }),
-    ).toBe(true)
-  })
-})
+    expect(isPosDeliveryEnabled({})).toBe(true)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '0',
+      }),
+    ).toBe(false)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+})
+
+describe('deviceConfigBootstrap local charge capability', () => {
+  it('defaults waiter to blocked and other modes to allowed when config missing', () => {
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'waiter',
+      }),
+    ).toBe(false)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      }),
+    ).toBe(true)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'single-item',
+      }),
+    ).toBe(true)
+  })
+
+  it('honors explicit pos-local-charge-enabled over mode default', () => {
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'waiter',
+        [POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+        [POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY]: '0',
+      }),
+    ).toBe(false)
+  })
+})
+

package/src/tests/react/pages/deviceDetailDelete.test.js

@@ -0,0 +1,78 @@
+/**
+ * Unit coverage for device-detail delete confirmation flow (app-community#383).
+ */
+
+describe('device-detail delete confirmation (task-383)', () => {
+  const buildDeleteFlow = ({ remove, onSuccess, onError }) => {
+    let confirmed = false;
+    const confirm = (msg, cb) => ({
+      confirmNow: () => {
+        confirmed = true;
+        return Promise.resolve().then(() => cb());
+      },
+      cancel: () => {
+        confirmed = false;
+      },
+      wasConfirmed: () => confirmed,
+      message: msg,
+    });
+
+    const deleteDevice = async ({ deviceId, alias, deviceString }) => {
+      if (!deviceId) return { aborted: true };
+      const label = String(alias || deviceString || deviceId).trim();
+      const message = `Excluir o device "${label}"? Esta ação não pode ser desfeita.`;
+      return confirm(message, async () => {
+        try {
+          await remove(deviceId);
+          onSuccess?.();
+        } catch (e) {
+          onError?.(e);
+        }
+      });
+    };
+
+    return { deleteDevice };
+  };
+
+  test('does not call remove when confirmation is cancelled', async () => {
+    const remove = jest.fn();
+    const onSuccess = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess });
+    const gate = await deleteDevice({ deviceId: '42', alias: 'PDV 1' });
+    expect(gate.message).toContain('PDV 1');
+    gate.cancel();
+    expect(remove).not.toHaveBeenCalled();
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(gate.wasConfirmed()).toBe(false);
+  });
+
+  test('calls remove with deviceId after confirmation', async () => {
+    const remove = jest.fn().mockResolvedValue(undefined);
+    const onSuccess = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess });
+    const gate = await deleteDevice({ deviceId: '99', alias: 'Kiosk' });
+    await gate.confirmNow();
+    expect(remove).toHaveBeenCalledWith('99');
+    expect(onSuccess).toHaveBeenCalled();
+  });
+
+  test('surfaces error without success when remove rejects', async () => {
+    const remove = jest.fn().mockRejectedValue(new Error('fail'));
+    const onSuccess = jest.fn();
+    const onError = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess, onError });
+    const gate = await deleteDevice({ deviceId: '7', deviceString: 'dev-7' });
+    await gate.confirmNow();
+    expect(remove).toHaveBeenCalledWith('7');
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalled();
+  });
+
+  test('aborts when deviceId is missing', async () => {
+    const remove = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove });
+    const result = await deleteDevice({ deviceId: null, alias: 'x' });
+    expect(result).toEqual({ aborted: true });
+    expect(remove).not.toHaveBeenCalled();
+  });
+});

package/src/tests/react/pages/receitaFederalIntegrationContract.test.mjs

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import test from 'node:test';
+
+const catalog = fs.readFileSync(new URL('../../../react/pages/integrationsCatalog.js', import.meta.url), 'utf8');
+const page = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigPage.js', import.meta.url), 'utf8');
+const fields = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigFields.js', import.meta.url), 'utf8');
+const utils = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigPage.utils.js', import.meta.url), 'utf8');
+
+test('Receita Federal catalog exposes company fiscal configuration', () => {
+  assert.match(catalog, /key: 'receita-federal'/);
+  assert.match(catalog, /label: 'Receita Federal'/);
+  assert.match(catalog, /receita-federal-tax-regime/);
+  assert.match(catalog, /receita-federal-ibge-code/);
+  assert.match(catalog, /receita-federal-certificate-file/);
+  assert.match(catalog, /receita-federal-certificate-password/);
+  assert.match(catalog, /secureTextEntry: true/);
+  assert.match(catalog, /\.pfx,\.p12,application\/x-pkcs12/);
+});
+
+test('Receita Federal route resolves without relying only on route params', () => {
+  assert.match(utils, /ReceitaFederalIntegrationPage: 'receita-federal'/);
+  assert.match(page, /ROUTE_PROVIDER_MAP\[route\?\.name\]/);
+});
+
+test('embedded fiscal configuration keeps reads and writes on the company being edited', () => {
+  assert.match(utils, /route\?\.params\?\.companyId/);
+  assert.match(utils, /resolveProviderId/);
+  assert.match(utils, /resolveFallbackConfigs/);
+  assert.match(page, /resolveProviderId\(\{ route, currentCompany \}\)/);
+  assert.match(page, /api\.fetch\('\/configs', \{ params: \{ people: providerIri \} \}\)/);
+  assert.match(page, /addManyConfigs\(\{ configs, people: providerIri/);
+  assert.match(page, /syncConfigValues\(fallbackConfigs\)/);
+});
+
+test('certificate picker remains scoped to the active company', () => {
+  assert.match(fields, /companyId=\{providerId\}/);
+  assert.match(fields, /entityId=\{providerId\}/);
+  assert.match(fields, /peopleId: companyId \|\| providerId/);
+  assert.match(fields, /company_certificate/);
+});
+
+test('IntegrationConfigPage delegates field rendering to a focused component', () => {
+  assert.match(page, /<IntegrationConfigFields/);
+  assert.ok(page.split('\n').length <= 500, `IntegrationConfigPage.js has ${page.split('\n').length} lines`);
+  assert.ok(fields.split('\n').length <= 500, `IntegrationConfigFields.js has ${fields.split('\n').length} lines`);
+  assert.ok(utils.split('\n').length <= 500, `IntegrationConfigPage.utils.js has ${utils.split('\n').length} lines`);
+});

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

@@ -0,0 +1,222 @@
+const assert = require('node:assert/strict')
+const {test} = require('node:test')
+
+const {
+  SAFE_TOOLBAR_FALLBACK_ROUTES,
+  buildSafeToolbarFallbackMenus,
+  mapRuntimeMenusToNavItems,
+  resolveToolbarRuntimeMenus,
+} = require('../../../react/utils/bottomNavigationToolbar')
+
+const managerPreset = {
+  items: [
+    {
+      route: 'HomePage',
+      icon: 'home',
+      label: {store: 'configs', type: 'toolbar', key: 'home', fallback: 'Início'},
+    },
+    {
+      route: 'CrmIndex',
+      icon: 'dollar-sign',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'opportunities',
+        fallback: 'Oportunidades',
+      },
+    },
+    {
+      route: 'ClientsIndex',
+      icon: 'users',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'customers',
+        fallback: 'Clientes',
+      },
+    },
+    {
+      route: 'ProfilePage',
+      icon: 'user',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'profile',
+        fallback: 'Perfil',
+      },
+    },
+  ],
+  routeAliases: {
+    ClientDetails: 'ClientsIndex',
+    ProfilePage: 'ProfilePage',
+    SettingsPage: 'ProfilePage',
+  },
+}
+
+test('exposes only HomePage and ProfilePage as safe fallback routes', () => {
+  assert.deepEqual(SAFE_TOOLBAR_FALLBACK_ROUTES, ['HomePage', 'ProfilePage'])
+})
+
+test('builds safe fallback from managerToolbar without business routes', () => {
+  const menus = buildSafeToolbarFallbackMenus(
+    managerPreset,
+    'toolbar',
+    null,
+    'managerToolbar',
+  )
+
+  assert.equal(menus.length, 1)
+  const routes = menus[0].menus.map(item => item.route)
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+  assert.equal(routes.includes('ClientsIndex'), false)
+  assert.equal(routes.includes('CrmIndex'), false)
+  assert.deepEqual(
+    menus[0].menus.map(item => item.label),
+    ['Início', 'Perfil'],
+  )
+})
+
+test('returns empty safe fallback when preset has no safe routes', () => {
+  const menus = buildSafeToolbarFallbackMenus(
+    {items: [{route: 'ClientsIndex', icon: 'users', label: 'Clientes'}]},
+    'toolbar',
+  )
+  assert.deepEqual(menus, [])
+})
+
+test('prefers API toolbar menus over preset when authorized items exist', () => {
+  const apiMenus = [
+    {
+      id: 'toolbar-mod',
+      label: 'Toolbar',
+      menus: [
+        {
+          id: 1,
+          route: 'HomePage',
+          icon: 'home',
+          label: 'Início',
+          menuType: 'toolbar',
+          sortOrder: 10,
+        },
+        {
+          id: 2,
+          route: 'ClientsIndex',
+          icon: 'users',
+          label: 'Clientes',
+          menuType: 'toolbar',
+          sortOrder: 20,
+        },
+      ],
+    },
+  ]
+
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus,
+    preset: managerPreset,
+    presetKey: 'managerToolbar',
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ClientsIndex'])
+  assert.equal(routes.includes('ProfilePage'), false)
+})
+
+test('falls back to safe routes when API menus are empty', () => {
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus: [],
+    preset: managerPreset,
+    presetKey: 'managerToolbar',
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+  assert.equal(routes.includes('ClientsIndex'), false)
+  assert.equal(routes.includes('CrmIndex'), false)
+})
+
+test('falls back to safe routes when API only has non-toolbar menus', () => {
+  const apiMenus = [
+    {
+      id: 'home-mod',
+      menus: [
+        {
+          route: 'ProductsPage',
+          label: 'Produtos',
+          menuType: 'home',
+          sortOrder: 1,
+        },
+      ],
+    },
+  ]
+
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus,
+    preset: managerPreset,
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+})
+
+test('returns empty when API empty and no preset (no bypass)', () => {
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus: [],
+    preset: null,
+    menuType: 'toolbar',
+  })
+  assert.deepEqual(resolved, [])
+})
+
+test('maps runtime menus to nav items sorted by sortOrder', () => {
+  const runtimeMenus = [
+    {
+      id: 'm1',
+      menus: [
+        {
+          route: 'ClientsIndex',
+          icon: 'users',
+          label: 'Clientes',
+          menuKey: 'clients',
+          menuType: 'toolbar',
+          sortOrder: 30,
+        },
+        {
+          route: 'HomePage',
+          icon: 'home',
+          label: 'Início',
+          menuKey: 'home',
+          menuType: 'toolbar',
+          sortOrder: 10,
+        },
+      ],
+    },
+  ]
+
+  const items = mapRuntimeMenusToNavItems(runtimeMenus, 'toolbar')
+  assert.deepEqual(
+    items.map(i => i.route),
+    ['HomePage', 'ClientsIndex'],
+  )
+  assert.equal(items[0].menuKey, 'home')
+})
+
+test('ignores items without route when mapping', () => {
+  const items = mapRuntimeMenusToNavItems(
+    [
+      {
+        menus: [
+          {route: '', label: 'Empty', menuType: 'toolbar'},
+          {route: 'HomePage', label: 'Início', menuType: 'toolbar', sortOrder: 1},
+        ],
+      },
+    ],
+    'toolbar',
+  )
+  assert.deepEqual(
+    items.map(i => i.route),
+    ['HomePage'],
+  )
+})