@controleonline/ui-common 1.2.70 → 1.2.75

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

@@ -0,0 +1,170 @@
+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('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('does not fall back to the translates collection during discovery', async () => {
+  installLocalStorage();
+
+  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, []);
+});
+
+test('resolves queued store discovery through the resolve endpoint', async () => {
+  installLocalStorage();
+
+  const getItemsCalls = [];
+  const resolveCalls = [];
+  const translateStore = createPendingTranslateStore({
+    getItems: async params => {
+      getItemsCalls.push(params);
+      return [];
+    },
+    resolveQueuedMessages: async payload => {
+      resolveCalls.push(payload);
+
+      return [
+        {
+          people: '/people/5',
+          language: {
+            id: 1,
+            language: 'pt-br',
+          },
+          store: 'financial',
+          type: 'label',
+          key: 'accountsReceivable',
+          translate: 'Contas a receber',
+          revised: true,
+        },
+      ];
+    },
+  });
+  const translate = new Translate(
+    [{id: 1}, {id: 5}],
+    {id: 1},
+    {id: 5},
+    ['financial'],
+    translateStore,
+  );
+
+  translateStore.actions.queueMissingTranslate({
+    language: 'pt-br',
+    companyId: 1,
+    store: 'financial',
+    type: 'label',
+    key: 'accountsReceivable',
+    translate: 'Accounts Receivable',
+  });
+
+  await translate.discoveryAll();
+
+  assert.deepEqual(getItemsCalls, []);
+  // Discovery resolves against main+current; mock payload people id drives cache company.
+  assert.equal(resolveCalls.length >= 1, true);
+  assert.equal(resolveCalls[0].people, '/people/1');
+  assert.deepEqual(resolveCalls[0].requests, [
+    {
+      store: 'financial',
+      type: 'label',
+      keys: ['accountsReceivable'],
+    },
+  ]);
+  assert.equal(
+    translateStore.messages['pt-br'].companies[5].financial.label.accountsReceivable,
+    'Contas a receber',
+  );
+  assert.deepEqual(translateStore.pendingMessages, {});
+});
+
+test('reuses cached store buckets without refetching after in-memory discovery is cleared', async () => {
+  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 translate = new Translate(
+    [{id: 1}],
+    {id: 1},
+    {id: 1},
+    ['contract'],
+    translateStore,
+  );
+
+  translate.discoveredStores.clear();
+
+  assert.equal(translate.t('contract', 'empty', 'none_registered_title'), 'None registered title');
+
+  await flushAsync();
+
+  assert.deepEqual(calls, []);
+});

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

@@ -0,0 +1,152 @@
+export 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;
+};
+
+export 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();
+
+export 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,
+  };
+};
+