@controleonline/ui-common 1.2.71 → 1.2.76

package/src/tests/react/utils/translate.test.mjs

@@ -1,239 +1,92 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import Translate from '../../../utils/translate.js';
-
-const installLocalStorage = (config = {language: 'pt-br'}) => {
-  const storage = {};
-
-  global.localStorage = {
-    getItem(key) {
-      return Object.prototype.hasOwnProperty.call(storage, key)
-        ? storage[key]
-        : null;
-    },
-    setItem(key, value) {
-      storage[key] = String(value);
-    },
-    removeItem(key) {
-      delete storage[key];
-    },
-  };
-
-  localStorage.setItem('config', JSON.stringify(config));
-  localStorage.setItem('translates', JSON.stringify({}));
-  delete global.refreshTranslationsUI;
-};
-
-const flushAsync = async () => {
-  await Promise.resolve();
-  await new Promise(resolve => setTimeout(resolve, 0));
-  await new Promise(resolve => setTimeout(resolve, 0));
-};
-
-const normalizeLanguage = value =>
-  String(value || '')
-    .trim()
-    .replace(/_/g, '-')
-    .toLowerCase();
-
-const normalizeId = value =>
-  String(value || '')
-    .replace(/\D+/g, '')
-    .trim();
-
-const createPendingTranslateStore = ({getItems, save, resolveQueuedMessages} = {}) => {
-  const store = {
-    getters: {
-      messages: {},
-      pendingMessages: {},
-    },
-    actions: {},
-  };
-
-  const translateActions = {
-    getItems: getItems || (async () => []),
-    save: save || (async payload => payload),
-    ...(resolveQueuedMessages
-      ? {
-          resolveQueuedMessages,
-        }
-      : {}),
-    setMessages: nextMessages => {
-      store.getters.messages = nextMessages;
-      return nextMessages;
-    },
-    setPendingMessages: nextMessages => {
-      store.getters.pendingMessages = nextMessages;
-      return nextMessages;
-    },
-    queueMissingTranslate: ({language, companyId, store: storeName, type, key, translate}) => {
-      const normalizedLanguage = normalizeLanguage(language);
-      const normalizedCompanyId = normalizeId(companyId);
-      const pendingMessages = store.getters.pendingMessages;
-
-      if (!pendingMessages[normalizedLanguage]) {
-        pendingMessages[normalizedLanguage] = {};
-      }
-
-      if (!pendingMessages[normalizedLanguage].companies) {
-        pendingMessages[normalizedLanguage].companies = {};
-      }
-
-      if (!pendingMessages[normalizedLanguage].companies[normalizedCompanyId]) {
-        pendingMessages[normalizedLanguage].companies[normalizedCompanyId] = {};
-      }
-
-      if (!pendingMessages[normalizedLanguage].companies[normalizedCompanyId][storeName]) {
-        pendingMessages[normalizedLanguage].companies[normalizedCompanyId][storeName] = {};
-      }
-
-      if (
-        !pendingMessages[normalizedLanguage].companies[normalizedCompanyId][storeName][type]
-      ) {
-        pendingMessages[normalizedLanguage].companies[normalizedCompanyId][storeName][type] =
-          {};
-      }
-
-      pendingMessages[normalizedLanguage].companies[normalizedCompanyId][storeName][type][
-        key
-      ] = translate;
-
-      return pendingMessages;
-    },
-    removePendingTranslate: ({language, companyId, store: storeName, type, key}) => {
-      const normalizedLanguage = normalizeLanguage(language);
-      const normalizedCompanyId = normalizeId(companyId);
-      const pendingMessages = store.getters.pendingMessages;
-      const languageBucket = pendingMessages[normalizedLanguage];
-      const companyBucket = languageBucket?.companies?.[normalizedCompanyId];
-      const storeBucket = companyBucket?.[storeName];
-      const typeBucket = storeBucket?.[type];
-
-      if (!typeBucket || !Object.prototype.hasOwnProperty.call(typeBucket, key)) {
-        return pendingMessages;
-      }
-
-      delete typeBucket[key];
-
-      if (Object.keys(typeBucket).length === 0) {
-        delete storeBucket[type];
-      }
-
-      if (Object.keys(storeBucket).length === 0) {
-        delete companyBucket[storeName];
-      }
-
-      if (Object.keys(companyBucket).length === 0) {
-        delete languageBucket.companies[normalizedCompanyId];
-      }
-
-      if (Object.keys(languageBucket.companies || {}).length === 0) {
-        delete languageBucket.companies;
-      }
-
-      if (Object.keys(languageBucket).length === 0) {
-        delete pendingMessages[normalizedLanguage];
-      }
-
-      return pendingMessages;
-    },
-  };
-
-  store.actions = translateActions;
-
-  return {
-    getters: store.getters,
-    actions: store.actions,
-    get messages() {
-      return store.getters.messages;
-    },
-    get pendingMessages() {
-      return store.getters.pendingMessages;
-    },
-    translateActions,
-  };
-};
-
-test('prefers the current company translation and falls back to the default company', () => {
-  installLocalStorage();
-
-  const translateStore = createPendingTranslateStore();
-  const translate = new Translate(
-    [{id: 1}, {id: 5}],
-    {id: 1},
-    {id: 5},
-    ['orders'],
-    translateStore,
-  );
-
-  translate.findMessage('orders', 'label', 'save', 'Salvar', 1);
-  translate.findMessage('orders', 'label', 'save', 'Save for ASC', 5);
-  translate.persist();
-
-  assert.equal(translate.t('orders', 'label', 'save'), 'Save for ASC');
-
-  const fallbackTranslate = new Translate(
-    [{id: 1}, {id: 5}],
-    {id: 1},
-    {id: 9},
-    ['orders'],
-    createPendingTranslateStore(),
-  );
-
-  assert.equal(fallbackTranslate.t('orders', 'label', 'save'), 'Salvar');
-});
-
-test('keeps the translate method bound when passed as a standalone function', () => {
-  installLocalStorage();
-
-  const translate = new Translate(
-    [{id: 1}],
-    {id: 1},
-    {id: 1},
-    ['orders'],
-    createPendingTranslateStore(),
-  );
-
-  translate.findMessage('orders', 'label', 'save', 'Salvar', 1);
-
-  const detachedTranslate = translate.t;
-
-  assert.equal(detachedTranslate('orders', 'label', 'save'), 'Salvar');
-});
-
-test('hydrates the cached translations into the translate store on startup', () => {
-  installLocalStorage();
-  localStorage.setItem('translates', JSON.stringify({
-    'pt-br': {
-      companies: {
-        1: {
-          invoice: {
-            label: {
-              accountsReceivable: 'Contas a receber',
-            },
-          },
-        },
-      },
-    },
-  }));
-
-  const translateStore = createPendingTranslateStore();
-
-  new Translate(
-    [{id: 1}],
-    {id: 1},
-    {id: 1},
-    ['invoice'],
-    translateStore,
-  );
-
-  assert.equal(
-    translateStore.messages['pt-br'].companies[1].invoice.label.accountsReceivable,
-    'Contas a receber',
-  );
-});
-
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import Translate from '../../../utils/translate.js';
+import {
+  installLocalStorage,
+  flushAsync,
+  createPendingTranslateStore,
+} from './translate.test.helpers.mjs';
+
+test('prefers the current company translation and falls back to the default company', () => {
+  installLocalStorage();
+
+  const translateStore = createPendingTranslateStore();
+  const translate = new Translate(
+    [{id: 1}, {id: 5}],
+    {id: 1},
+    {id: 5},
+    ['orders'],
+    translateStore,
+  );
+
+  translate.findMessage('orders', 'label', 'save', 'Salvar', 1);
+  translate.findMessage('orders', 'label', 'save', 'Save for ASC', 5);
+  translate.persist();
+
+  assert.equal(translate.t('orders', 'label', 'save'), 'Save for ASC');
+
+  const fallbackTranslate = new Translate(
+    [{id: 1}, {id: 5}],
+    {id: 1},
+    {id: 9},
+    ['orders'],
+    createPendingTranslateStore(),
+  );
+
+  assert.equal(fallbackTranslate.t('orders', 'label', 'save'), 'Salvar');
+});
+
+test('keeps the translate method bound when passed as a standalone function', () => {
+  installLocalStorage();
+
+  const translate = new Translate(
+    [{id: 1}],
+    {id: 1},
+    {id: 1},
+    ['orders'],
+    createPendingTranslateStore(),
+  );
+
+  translate.findMessage('orders', 'label', 'save', 'Salvar', 1);
+
+  const detachedTranslate = translate.t;
+
+  assert.equal(detachedTranslate('orders', 'label', 'save'), 'Salvar');
+});
+
+test('hydrates the cached translations into the translate store on startup', () => {
+  installLocalStorage();
+  localStorage.setItem('translates', JSON.stringify({
+    'pt-br': {
+      companies: {
+        1: {
+          invoice: {
+            label: {
+              accountsReceivable: 'Contas a receber',
+            },
+          },
+        },
+      },
+    },
+  }));
+
+  const translateStore = createPendingTranslateStore();
+
+  new Translate(
+    [{id: 1}],
+    {id: 1},
+    {id: 1},
+    ['invoice'],
+    translateStore,
+  );
+
+  assert.equal(
+    translateStore.messages['pt-br'].companies[1].invoice.label.accountsReceivable,
+    'Contas a receber',
+  );
+});
+
 test('posts missing translations once and keeps the fallback until review', async () => {
   installLocalStorage();
 
@@ -242,36 +95,36 @@ test('posts missing translations once and keeps the fallback until review', asyn
     save: async payload => {
       saveCalls.push(payload);
       return payload;
-    },
-  });
-  const translate = new Translate(
-    [{id: 1}],
-    {id: 1},
-    {id: 1},
-    ['contract'],
-    translateStore,
-  );
-
-  const firstValue = translate.t('contract', 'empty', 'none_registered_title');
-  const secondValue = translate.t('contract', 'empty', 'none_registered_title');
-
-  assert.equal(firstValue, 'None registered title');
-  assert.equal(secondValue, 'None registered title');
+    },
+  });
+  const translate = new Translate(
+    [{id: 1}],
+    {id: 1},
+    {id: 1},
+    ['contract'],
+    translateStore,
+  );
+
+  const firstValue = translate.t('contract', 'empty', 'none_registered_title');
+  const secondValue = translate.t('contract', 'empty', 'none_registered_title');
+
+  assert.equal(firstValue, 'None registered title');
+  assert.equal(secondValue, 'None registered title');
 
   await flushAsync();
 
   assert.deepEqual(saveCalls, [{
     people: '/people/1',
     language: 'pt-br',
-    store: 'contract',
-    type: 'empty',
-    key: 'none_registered_title',
-    translate: 'None registered title',
-    revised: false,
-  }]);
-  assert.equal(
-    translateStore.messages['pt-br'].companies[1].contract.empty.none_registered_title,
-    'None registered title',
+    store: 'contract',
+    type: 'empty',
+    key: 'none_registered_title',
+    translate: 'None registered title',
+    revised: false,
+  }]);
+  assert.equal(
+    translateStore.messages['pt-br'].companies[1].contract.empty.none_registered_title,
+    'None registered title',
   );
   assert.deepEqual(translateStore.pendingMessages, {});
 });
@@ -359,102 +212,41 @@ test('queues missing translations in a single batch resolve request', async () =
   assert.deepEqual(translateStore.pendingMessages, {});
 });
 
-test('persists missing translations with the normalized configured language', async () => {
-  installLocalStorage({language: 'en_US'});
-
-  const saveCalls = [];
-  const translateStore = createPendingTranslateStore({
-    getItems: async () => [],
-    save: async payload => {
-      saveCalls.push(payload);
-      return payload;
-    },
-  });
-  const translate = new Translate(
-    [{id: 1}],
-    {id: 1},
-    {id: 1},
-    ['contract'],
-    translateStore,
-  );
-
-  translate.t('contract', 'empty', 'none_registered_title');
-
-  await flushAsync();
-
-  assert.equal(
-    saveCalls[0].language,
-    'en-us',
-  );
-  assert.equal(
-    translateStore.messages['en-us'].companies[1].contract.empty.none_registered_title,
-    'None registered title',
-  );
-});
-
-test('loads each requested store only for the current and default companies', async () => {
+test('falls back past empty current-company values to the main company', () => {
   installLocalStorage();
+  const translateStore = createPendingTranslateStore();
+  const currentCompany = {id: 2};
+  const defaultCompany = {id: 1};
+  const translate = new Translate(
+    [defaultCompany, currentCompany],
+    defaultCompany,
+    currentCompany,
+    ['orders'],
+    translateStore,
+  );
 
-  const calls = [];
-  const translate = new Translate(
-    [{id: 1}, {id: 5}, {id: 9}],
-    {id: 1},
-    {id: 5},
-    ['orders', 'crm'],
-    createPendingTranslateStore({
-      getItems: async params => {
-        calls.push(params);
-        return [];
-      },
-    }),
-  );
-
-  await translate.discoveryAll();
-
-  assert.deepEqual(calls, [
-    {store: 'orders', 'language.language': 'pt-br', people: '/people/1', page: 1},
-    {store: 'crm', 'language.language': 'pt-br', people: '/people/1', page: 1},
-    {store: 'orders', 'language.language': 'pt-br', people: '/people/5', page: 1},
-    {store: 'crm', 'language.language': 'pt-br', people: '/people/5', page: 1},
-  ]);
+  translate.findMessage('orders', 'menu', 'overview', '   ', 2, 'pt-br');
+  translate.findMessage('orders', 'menu', 'overview', 'Visão geral', 1, 'pt-br');
+
+  assert.equal(translate.t('orders', 'menu', 'overview'), 'Visão geral');
 });
 
-test('reuses cached store buckets without refetching after in-memory discovery is cleared', async () => {
+test('getResolveCompaniesToCache returns current and main companies', () => {
   installLocalStorage();
-  localStorage.setItem('translates', JSON.stringify({
-    'pt-br': {
-      companies: {
-        1: {
-          contract: {
-            empty: {
-              none_registered_title: 'None registered title',
-            },
-          },
-        },
-      },
-    },
-  }));
-
-  const calls = [];
-  const translateStore = createPendingTranslateStore({
-    getItems: async params => {
-      calls.push(params);
-      return [];
-    },
-  });
+  const translateStore = createPendingTranslateStore();
+  const currentCompany = {id: 2};
+  const defaultCompany = {id: 1};
   const translate = new Translate(
-    [{id: 1}],
-    {id: 1},
-    {id: 1},
-    ['contract'],
+    [defaultCompany, currentCompany],
+    defaultCompany,
+    currentCompany,
+    ['orders'],
     translateStore,
   );
 
-  translate.discoveredStores.clear();
-
-  assert.equal(translate.t('contract', 'empty', 'none_registered_title'), 'None registered title');
-
-  await flushAsync();
-
-  assert.deepEqual(calls, []);
+  const ids = translate
+    .getResolveCompaniesToCache()
+    .map((company) => String(company.id))
+    .sort();
+  assert.deepEqual(ids, ['1', '2']);
 });

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

@@ -0,0 +1,63 @@
+import {
+  getAvatarDisplayName,
+  getGravatarUrl,
+  getUserInitials,
+  resolveUserAvatarUrl,
+  resolveUserPeopleIri,
+} from '../../../react/utils/userAvatar';
+
+describe('userAvatar', () => {
+  it('uses the first and last names for two initials', () => {
+    expect(getUserInitials({name: 'Alexandre AleMac Cunha'})).toBe('AC');
+  });
+
+  it('uses one initial for a single name', () => {
+    expect(getUserInitials({name: 'Alexandre'})).toBe('A');
+  });
+
+  it('falls back to the email initial when the name is unavailable', () => {
+    expect(getUserInitials({email: 'claudio@example.com'})).toBe('C');
+  });
+
+  it('asks Gravatar for a real image without an identicon fallback', () => {
+    expect(getGravatarUrl(' MyEmailAddress@example.com ', 120)).toBe(
+      'https://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?s=120&d=404',
+    );
+  });
+
+  it('does not call Gravatar without an email', () => {
+    expect(getGravatarUrl('')).toBe('');
+  });
+
+  it('uses the complete person name and never the functional alias', () => {
+    const user = {name: 'Claudio Medeiros', realname: 'Claudio Owner', alias: 'owner'};
+
+    expect(getAvatarDisplayName(user)).toBe('Claudio Medeiros');
+    expect(getUserInitials({name: getAvatarDisplayName(user)})).toBe('CM');
+  });
+
+  it('resolves the person from the same stored session shape used by Profile', () => {
+    expect(
+      resolveUserPeopleIri({id: 131}, {people: '/people/14'}),
+    ).toBe('/people/14');
+  });
+
+  it('resolves only the canonical persisted avatar', () => {
+    const user = {avatar: {id: 42}};
+
+    expect(
+      resolveUserAvatarUrl(user, avatar =>
+        avatar?.id ? `https://api.example/files/${avatar.id}/download` : '',
+      ),
+    ).toBe('https://api.example/files/42/download');
+  });
+
+  it('does not treat avatarUrl as an avatar source', () => {
+    expect(
+      resolveUserAvatarUrl(
+        {avatarUrl: 'https://legacy.example/avatar.png'},
+        () => '',
+      ),
+    ).toBe('');
+  });
+});

package/src/utils/appDomain.js

@@ -1,4 +1,9 @@
-const toRawString = value => String(value || '').trim();
+const INVALID_DOMAIN_VALUES = new Set(['undefined', 'null', 'false']);
+
+const toRawString = value => {
+  const raw = String(value || '').trim();
+  return INVALID_DOMAIN_VALUES.has(raw.toLowerCase()) ? '' : raw;
+};
 
 const tryParseHost = value => {
   const raw = toRawString(value);
@@ -23,10 +28,16 @@ export const resolveRuntimeHost = () => {
   return toRawString(location?.host || '');
 };
 
+/**
+ * App-Domain header value.
+ * Browser (web multi-tenant): always prefer window.location.host so custom
+ * domains (e.g. erpjaguncos.com.br) resolve the correct tenant.
+ * Native / no location: fall back to configured DOMAIN from env.
+ */
 export const resolveAppDomain = configuredDomain => {
-  const configuredHost = tryParseHost(configuredDomain);
-  if (configuredHost) return configuredHost;
-  return tryParseHost(resolveRuntimeHost());
+  const runtimeHost = tryParseHost(resolveRuntimeHost());
+  if (runtimeHost) return runtimeHost;
+  return tryParseHost(configuredDomain);
 };
 
 export const resolveCompanyDomain = (company, fallbackDomain = '') => {