@controleonline/ui-common 1.2.70

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

@@ -0,0 +1,396 @@
+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} = {}) => {
+  const store = {
+    getters: {
+      messages: {},
+      pendingMessages: {},
+    },
+    actions: {},
+  };
+
+  const translateActions = {
+    getItems: getItems || (async () => []),
+    save: save || (async payload => payload),
+    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',
+  );
+});
+
+test('posts missing translations once and keeps the fallback until review', async () => {
+  installLocalStorage();
+
+  const discoveryCalls = [];
+  const saveCalls = [];
+  const translateStore = createPendingTranslateStore({
+    getItems: async params => {
+      discoveryCalls.push(params);
+      return [];
+    },
+    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');
+
+  await flushAsync();
+
+  assert.deepEqual(discoveryCalls, [
+    {store: 'contract', 'language.language': 'pt-br', people: '/people/1', page: 1},
+  ]);
+  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',
+  );
+  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 () => {
+  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, [
+    {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},
+  ]);
+});
+
+test('removes stale pending entries once a discovered store returns the real translation', async () => {
+  installLocalStorage();
+
+  const translateStore = createPendingTranslateStore({
+    getItems: async params => {
+      if (params.page === 1) {
+        return [
+          {
+            store: 'menu',
+            type: 'menu',
+            key: 'orders',
+            translate: 'Pedidos',
+          },
+        ];
+      }
+
+      return [];
+    },
+  });
+
+  let refreshCalls = 0;
+  global.refreshTranslationsUI = () => {
+    refreshCalls += 1;
+  };
+
+  const translate = new Translate(
+    [{id: 1}],
+    {id: 1},
+    {id: 1},
+    ['orders'],
+    translateStore,
+  );
+
+  translateStore.actions.setPendingMessages({
+    'pt-br': {
+      companies: {
+        1: {
+          menu: {
+            menu: {
+              orders: 'Orders',
+            },
+          },
+        },
+      },
+    },
+  });
+
+  assert.equal(translate.t('menu', 'menu', 'orders'), 'Orders');
+
+  await flushAsync();
+
+  assert.deepEqual(translateStore.pendingMessages, {});
+  assert.equal(refreshCalls, 1);
+  assert.equal(translate.t('menu', 'menu', 'orders'), 'Pedidos');
+});

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

@@ -0,0 +1,245 @@
+const {jest} = require('@jest/globals');
+
+const {
+  compareRuntimePriority,
+  createWebsocketSharedRuntime,
+  isHigherPriorityRuntime,
+} = require('../../../react/utils/websocketSharedRuntime');
+
+const {describe, expect, it, beforeEach, afterEach} = global;
+
+const channelRegistry = new Map();
+
+class FakeBroadcastChannel {
+  constructor(name) {
+    this.name = name;
+    this.closed = false;
+    this.onmessage = null;
+
+    if (!channelRegistry.has(name)) {
+      channelRegistry.set(name, new Set());
+    }
+
+    channelRegistry.get(name).add(this);
+  }
+
+  postMessage(message) {
+    const listeners = channelRegistry.get(this.name) || new Set();
+    listeners.forEach(listener => {
+      if (listener !== this && !listener.closed && listener.onmessage) {
+        listener.onmessage({data: message});
+      }
+    });
+  }
+
+  close() {
+    this.closed = true;
+    channelRegistry.get(this.name)?.delete(this);
+  }
+}
+
+class FakeWebSocket {
+  static instances = [];
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+
+  constructor(url) {
+    this.url = url;
+    this.readyState = FakeWebSocket.CONNECTING;
+    this.send = jest.fn();
+    FakeWebSocket.instances.push(this);
+  }
+
+  close(code = 1000, reason = 'close') {
+    this.readyState = FakeWebSocket.CLOSED;
+    this.onclose?.({code, reason});
+  }
+}
+
+const buildPipeline = () => {
+  const state = {
+    connected: false,
+    identified: false,
+    status: 'idle',
+    attempts: 0,
+    updatedAt: new Date().toISOString(),
+    device: 'device-1',
+    error: null,
+    code: null,
+    reason: '',
+    ownerRegistrationId: '',
+    ownerPackageName: '',
+    ownerCompanyId: '',
+    lastEventAt: null,
+    lastEventCount: 0,
+    lastStores: [],
+    lastCompanies: [],
+  };
+
+  return {
+    getConnectionState: () => state,
+    processPayload: jest.fn(() => state),
+    refreshFooter: jest.fn(),
+    reset: jest.fn(() => {
+      state.connected = false;
+      state.identified = false;
+      state.status = 'idle';
+      state.attempts = 0;
+      state.error = null;
+      state.code = null;
+      state.reason = '';
+      state.lastEventAt = null;
+      state.lastEventCount = 0;
+      state.lastStores = [];
+      state.lastCompanies = [];
+      return state;
+    }),
+    updateConnectionState: jest.fn(nextState => {
+      Object.assign(state, nextState);
+      return state;
+    }),
+  };
+};
+
+describe('websocketSharedRuntime', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(1000);
+    channelRegistry.clear();
+    FakeWebSocket.instances = [];
+    global.localStorage?.clear?.();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it('prefers the oldest runtime and routes payloads through the shared channel', async () => {
+    const leaderPipeline = buildPipeline();
+    const followerPipeline = buildPipeline();
+
+    const leaderRuntime = createWebsocketSharedRuntime({
+      socketUrl: 'wss://example.test/socket',
+      getDeviceId: () => 'device-1',
+      pipeline: leaderPipeline,
+      BroadcastChannelImpl: FakeBroadcastChannel,
+      WebSocketImpl: FakeWebSocket,
+      claimDelayMs: 20,
+      heartbeatMs: 50,
+      leaderStaleMs: 100,
+      reconnectBaseMs: 20,
+      reconnectMaxMs: 40,
+      channelName: 'websocket-runtime-test',
+    });
+
+    jest.advanceTimersByTime(1);
+
+    const followerRuntime = createWebsocketSharedRuntime({
+      socketUrl: 'wss://example.test/socket',
+      getDeviceId: () => 'device-1',
+      pipeline: followerPipeline,
+      BroadcastChannelImpl: FakeBroadcastChannel,
+      WebSocketImpl: FakeWebSocket,
+      claimDelayMs: 20,
+      heartbeatMs: 50,
+      leaderStaleMs: 100,
+      reconnectBaseMs: 20,
+      reconnectMaxMs: 40,
+      channelName: 'websocket-runtime-test',
+    });
+
+    leaderRuntime.start();
+    followerRuntime.start();
+
+    jest.advanceTimersByTime(25);
+
+    expect(leaderRuntime.isLeader()).toBe(true);
+    expect(followerRuntime.isLeader()).toBe(false);
+    expect(FakeWebSocket.instances).toHaveLength(1);
+
+    const socket = FakeWebSocket.instances[0];
+    socket.readyState = FakeWebSocket.OPEN;
+    socket.onopen?.({});
+    jest.advanceTimersByTime(200);
+
+    const payload = JSON.stringify([
+      {
+        store: 'orders',
+        company: {id: 'company-1'},
+        order: '/orders/100',
+      },
+    ]);
+
+    socket.onmessage?.({data: payload});
+    await Promise.resolve();
+
+    expect(leaderPipeline.processPayload).toHaveBeenCalledWith(payload);
+    expect(followerPipeline.processPayload).toHaveBeenCalledWith(payload);
+  });
+
+  it('allows a follower to take over when the leader stops broadcasting', () => {
+    const leaderPipeline = buildPipeline();
+    const followerPipeline = buildPipeline();
+
+    const leaderRuntime = createWebsocketSharedRuntime({
+      socketUrl: 'wss://example.test/socket',
+      getDeviceId: () => 'device-1',
+      pipeline: leaderPipeline,
+      BroadcastChannelImpl: FakeBroadcastChannel,
+      WebSocketImpl: FakeWebSocket,
+      claimDelayMs: 20,
+      heartbeatMs: 50,
+      leaderStaleMs: 100,
+      reconnectBaseMs: 20,
+      reconnectMaxMs: 40,
+      channelName: 'websocket-runtime-test',
+    });
+
+    jest.advanceTimersByTime(1);
+
+    const followerRuntime = createWebsocketSharedRuntime({
+      socketUrl: 'wss://example.test/socket',
+      getDeviceId: () => 'device-1',
+      pipeline: followerPipeline,
+      BroadcastChannelImpl: FakeBroadcastChannel,
+      WebSocketImpl: FakeWebSocket,
+      claimDelayMs: 20,
+      heartbeatMs: 50,
+      leaderStaleMs: 100,
+      reconnectBaseMs: 20,
+      reconnectMaxMs: 40,
+      channelName: 'websocket-runtime-test',
+    });
+
+    leaderRuntime.start();
+    followerRuntime.start();
+    jest.advanceTimersByTime(25);
+
+    expect(leaderRuntime.isLeader()).toBe(true);
+    expect(followerRuntime.isLeader()).toBe(false);
+
+    leaderRuntime.stop();
+    jest.advanceTimersByTime(25);
+
+    expect(followerRuntime.isLeader()).toBe(true);
+    expect(FakeWebSocket.instances).toHaveLength(2);
+  });
+
+  it('compares runtime priority by start time before instance id', () => {
+    expect(
+      compareRuntimePriority(
+        {instanceId: 'a', startedAt: 1},
+        {instanceId: 'b', startedAt: 2},
+      ),
+    ).toBeLessThan(0);
+    expect(
+      isHigherPriorityRuntime(
+        {instanceId: 'a', startedAt: 1},
+        {instanceId: 'b', startedAt: 2},
+      ),
+    ).toBe(true);
+  });
+});

package/src/utils/apiEntryPoint.js

@@ -0,0 +1,31 @@
+import {Platform} from 'react-native';
+
+const ANDROID_EMULATOR_HOST = '10.0.2.2';
+const LOCALHOST_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
+
+const normalizeText = value => String(value || '').trim();
+
+const replaceLocalhostHost = value => {
+  const normalizedValue = normalizeText(value);
+  if (!normalizedValue) {
+    return '';
+  }
+
+  try {
+    const parsed = new URL(normalizedValue);
+    if (
+      Platform.OS === 'android' &&
+      LOCALHOST_HOSTS.has(String(parsed.hostname || '').trim().toLowerCase())
+    ) {
+      parsed.hostname = ANDROID_EMULATOR_HOST;
+      return parsed.toString();
+    }
+
+    return normalizedValue;
+  } catch {
+    return normalizedValue;
+  }
+};
+
+export const resolveApiEntryPoint = value =>
+  replaceLocalhostHost(value).replace(/\/$/, '');

package/src/utils/appDomain.js

@@ -0,0 +1,50 @@
+const toRawString = value => String(value || '').trim();
+
+const tryParseHost = value => {
+  const raw = toRawString(value);
+  if (!raw) return '';
+
+  try {
+    const withProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(raw)
+      ? raw
+      : `https://${raw}`;
+    const parsed = new URL(withProtocol);
+    return parsed.host || '';
+  } catch (error) {
+    return raw
+      .replace(/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//, '')
+      .replace(/\/.*$/, '')
+      .trim();
+  }
+};
+
+export const resolveRuntimeHost = () => {
+  if (typeof location === 'undefined') return '';
+  return toRawString(location?.host || '');
+};
+
+export const resolveAppDomain = configuredDomain => {
+  const configuredHost = tryParseHost(configuredDomain);
+  if (configuredHost) return configuredHost;
+  return tryParseHost(resolveRuntimeHost());
+};
+
+export const resolveCompanyDomain = (company, fallbackDomain = '') => {
+  const candidates = [
+    company?.domain,
+    company?.host,
+    company?.hostname,
+    company?.website,
+    company?.site,
+    company?.url,
+    company?.extraData?.domain,
+    company?.extraData?.hostname,
+  ];
+
+  for (const value of candidates) {
+    const normalized = tryParseHost(value);
+    if (normalized) return normalized;
+  }
+
+  return tryParseHost(fallbackDomain);
+};