@controleonline/ui-common 1.2.70 → 1.2.75

package/src/utils/translate.js

@@ -1,12 +1,40 @@
-const TRANSLATES_STORAGE_KEY = "translates";
+import {
+  formatMessage,
+  isNonEmptyMessage,
+  normalizeId,
+  normalizeLanguageCode,
+  resolveReferenceId,
+} from "./translateNormalize.js";
+import {
+  TRANSLATES_STORAGE_KEY,
+  collectCompaniesToCache,
+  getCompanyBucket as readCompanyBucket,
+  getLanguageBucket as readLanguageBucket,
+  getStoreBucket as readStoreBucket,
+  loadStorageObject,
+  writeMessageToBucket,
+} from "./translateStorage.js";
+import {
+  getPendingMessages as readPendingMessages,
+  getQueuedTranslateGroups as readQueuedGroups,
+  getQueuedTranslateGroupsForStore as readQueuedGroupsForStore,
+  hasPendingTranslate as readHasPendingTranslate,
+} from "./translatePending.js";
+import {
+  discoveryAll as runDiscoveryAll,
+  discoveryStoreTranslate as runDiscoveryStoreTranslate,
+  fetchTranslates as runFetchTranslates,
+  resolveStoreTranslates as runResolveStoreTranslates,
+} from "./translateDiscovery.js";
 
 export default class Translate {
   constructor(companies, defaultCompany, currentCompany, stores, translateStore) {
-    this.translates = this.loadStorageObject(TRANSLATES_STORAGE_KEY);
+    this.translates = loadStorageObject(TRANSLATES_STORAGE_KEY);
 
-    this.language = this.normalizeLanguageCode(
-      JSON.parse(localStorage.getItem("config") || "{}").language
-    ) || "pt-br";
+    this.language =
+      normalizeLanguageCode(
+        JSON.parse(localStorage.getItem("config") || "{}").language,
+      ) || "pt-br";
 
     this.defaultCompany = defaultCompany;
     this.currentCompany = currentCompany;
@@ -17,6 +45,8 @@ export default class Translate {
     this.bootstrapStores = new Set(this.getStoreList());
     this.discoveredStores = new Set();
     this.pendingStoreDiscoveries = new Map();
+    this.pendingMissingTranslateSchedules = new Set();
+    this.pendingTranslateResolutionPromise = null;
     this.pendingPersistRequests = new Map();
     this.t = this.t.bind(this);
     if (typeof this.translateActions?.setPendingMessages === "function") {
@@ -26,194 +56,101 @@ export default class Translate {
     this.hydrateDiscoveredStores();
   }
 
-  loadStorageObject(key) {
-    if (typeof localStorage === "undefined") {
-      return {};
-    }
+  normalizeId(value) {
+    return normalizeId(value);
+  }
 
-    try {
-      const value = localStorage.getItem(key);
-      if (!value) return {};
+  normalizeLanguageCode(value) {
+    return normalizeLanguageCode(value);
+  }
 
-      const parsed = JSON.parse(value);
-      return parsed && typeof parsed === "object" ? parsed : {};
-    } catch {
-      return {};
-    }
+  formatMessage(key) {
+    return formatMessage(key);
   }
-
-  getLanguageBucket(language = this.language, createIfMissing = false) {
-    const normalizedLanguage = this.normalizeLanguageCode(language);
-    if (!normalizedLanguage) return null;
 
-    if (!this.translates[normalizedLanguage] && createIfMissing) {
-      this.translates[normalizedLanguage] = {};
+  resolveReferenceId(value) {
+    if (value == null) return null;
+    if (typeof value === "object") {
+      return this.normalizeId(
+        value.id || value["@id"] || value.people || value.language,
+      );
     }
+    return this.normalizeId(value);
+  }
 
-    return this.translates[normalizedLanguage] || null;
+  getLanguageBucket(language = this.language, createIfMissing = false) {
+    return readLanguageBucket(this.translates, language, createIfMissing);
   }
 
   getCompanyBucket(companyId, createIfMissing = false, language = this.language) {
-    const normalizedCompanyId = this.normalizeId(companyId);
-    if (!normalizedCompanyId) return null;
-
-    const languageBucket = this.getLanguageBucket(language, createIfMissing);
-    if (!languageBucket) return null;
-
-    if (!languageBucket.companies && createIfMissing) {
-      languageBucket.companies = {};
-    }
-
-    if (
-      createIfMissing &&
-      languageBucket.companies &&
-      !languageBucket.companies[normalizedCompanyId]
-    ) {
-      languageBucket.companies[normalizedCompanyId] = {};
-    }
-
-    return languageBucket.companies?.[normalizedCompanyId] || null;
+    return readCompanyBucket(
+      this.translates,
+      companyId,
+      createIfMissing,
+      language,
+    );
   }
 
   getStoreBucket(companyId, store, createIfMissing = false, language = this.language) {
-    if (!store) return null;
-
-    if (companyId) {
-      const companyBucket = this.getCompanyBucket(companyId, createIfMissing, language);
-      if (!companyBucket) return null;
-
-      if (createIfMissing && !companyBucket[store]) {
-        companyBucket[store] = {};
-      }
-
-      return companyBucket[store] || null;
-    }
-
-    const languageBucket = this.getLanguageBucket(language, createIfMissing);
-    if (!languageBucket) return null;
-
-    if (createIfMissing && !languageBucket[store]) {
-      languageBucket[store] = {};
-    }
-
-    return languageBucket[store] || null;
-  }
-
-  normalizeId(value) {
-    if (value == null) return null;
-
-    const match = String(value).match(/\d+/);
-    return match?.[0] || null;
-  }
-
-  normalizeLanguageCode(value) {
-    if (typeof value !== "string") return "";
-
-    return value.trim().replace(/_/g, "-").toLowerCase();
-  }
-
-  getCompaniesToCache() {
-    const candidates = [
-      this.defaultCompany,
-      this.currentCompany,
-    ].filter((company) => company?.id);
-
-    const unique = [];
-    const seen = new Set();
-
-    candidates.forEach((company) => {
-      const companyId = this.normalizeId(company.id);
-      if (!companyId || seen.has(companyId)) return;
-
-      seen.add(companyId);
-      unique.push(company);
-    });
-
-    return unique;
-  }
-
-  getStoreList() {
-    if (Array.isArray(this.stores)) {
-      return this.stores.filter(Boolean);
-    }
-
-    return this.stores ? [this.stores] : [];
+    return readStoreBucket(
+      this.translates,
+      companyId,
+      store,
+      createIfMissing,
+      language,
+    );
   }
 
-  getPendingMessages() {
-    const messages = this.translateStore?.getters?.pendingMessages;
-    if (!messages || typeof messages !== "object" || Array.isArray(messages)) {
-      return {};
-    }
-
-    return messages;
+  getCompaniesToCache() {
+    return collectCompaniesToCache(this.defaultCompany, this.currentCompany);
   }
 
-  getPendingLanguageBucket(language = this.language) {
-    const pendingMessages = this.getPendingMessages();
-    const normalizedLanguage = this.normalizeLanguageCode(language);
-    if (!normalizedLanguage) return null;
-
-    return pendingMessages[normalizedLanguage] || null;
+  // Always load current + main company so runtime resolution can apply
+  // current company -> main company -> global fallback (getMessageFromBuckets).
+  getResolveCompaniesToCache() {
+    return this.getCompaniesToCache();
   }
 
-  getPendingCompanyBucket(companyId, language = this.language) {
-    const normalizedCompanyId = this.normalizeId(companyId);
-    if (!normalizedCompanyId) return null;
-
-    const languageBucket = this.getPendingLanguageBucket(language);
-    if (!languageBucket) return null;
-
-    const companiesBucket = languageBucket.companies;
-    if (!companiesBucket || typeof companiesBucket !== "object") {
-      return null;
+  getStoreList() {
+    if (Array.isArray(this.stores)) {
+      return this.stores.filter(Boolean);
     }
-
-    return companiesBucket[normalizedCompanyId] || null;
+    return this.stores ? [this.stores] : [];
   }
 
-  getPendingStoreBucket(companyId, store, language = this.language) {
-    const normalizedStore = String(store || "").trim();
-    if (!normalizedStore) return null;
-
-    const companyBucket = this.getPendingCompanyBucket(companyId, language);
-    if (!companyBucket) return null;
-
-    return companyBucket[normalizedStore] || null;
+  getPendingMessages() {
+    return readPendingMessages(this.translateStore);
   }
 
   hasPendingTranslate(store, type, key) {
-    const pendingStoreBucket = this.getPendingStoreBucket(
+    return readHasPendingTranslate(
+      this.translateStore,
       this.defaultCompany?.id,
       store,
+      type,
+      key,
       this.language,
     );
-
-    return Boolean(pendingStoreBucket?.[type]?.[key]);
   }
 
   getStoreDiscoveryToken(store) {
-    return [
-      this.language,
-      String(store || ""),
-    ].join("::");
+    return `discover:${store}:${this.language}`;
   }
 
   canDiscoverStore() {
-    return typeof this.translateActions?.getItems === "function";
+    return typeof this.translateActions?.resolveQueuedMessages === "function";
   }
 
   hasCachedBootstrapStore(store) {
-    if (!store) return false;
-
     const companies = this.getCompaniesToCache();
     if (companies.length === 0) return false;
-
-    return companies.every((company) => this.getStoreBucket(company.id, store) != null);
+    return companies.every(
+      (company) => this.getStoreBucket(company.id, store) != null,
+    );
   }
 
   hydrateDiscoveredStores() {
-    this.bootstrapStores.forEach((store) => {
+    this.getStoreList().forEach((store) => {
       if (this.hasCachedBootstrapStore(store)) {
         this.markStoreDiscovered(store);
       }
@@ -221,86 +158,55 @@ export default class Translate {
   }
 
   hasDiscoveredStore(store) {
-    if (!store) return false;
-
-    return this.discoveredStores.has(this.getStoreDiscoveryToken(store));
+    return this.discoveredStores.has(store);
   }
 
   markStoreDiscovered(store) {
-    if (!store) return;
-
-    this.discoveredStores.add(this.getStoreDiscoveryToken(store));
+    if (store) this.discoveredStores.add(store);
   }
 
   ensureStoreDiscovered(store) {
-    if (!store || !this.canDiscoverStore()) {
-      return Promise.resolve(this.translates);
-    }
-
-    if (this.hasDiscoveredStore(store)) {
+    if (!store || this.hasDiscoveredStore(store) || !this.canDiscoverStore()) {
       return Promise.resolve(this.translates);
     }
 
-    const token = this.getStoreDiscoveryToken(store);
-    if (this.pendingStoreDiscoveries.has(token)) {
-      return this.pendingStoreDiscoveries.get(token);
+    if (this.pendingStoreDiscoveries.has(store)) {
+      return this.pendingStoreDiscoveries.get(store);
     }
 
-    const discoveryPromise = Promise.resolve()
-      .then(() => this.discoveryStoreTranslate(store))
+    const discoveryPromise = this.discoveryStoreTranslate(store)
+      .catch(() => this.translates)
       .finally(() => {
-        this.pendingStoreDiscoveries.delete(token);
+        this.pendingStoreDiscoveries.delete(store);
       });
 
-    this.pendingStoreDiscoveries.set(token, discoveryPromise);
-
+    this.pendingStoreDiscoveries.set(store, discoveryPromise);
     return discoveryPromise;
   }
 
   notifyTranslationsUpdated() {
-    const globalObject =
-      typeof global !== "undefined" ? global : globalThis;
-
-    if (typeof globalObject?.refreshTranslationsUI === "function") {
-      globalObject.refreshTranslationsUI();
+    if (typeof this.translateActions?.setMessages === "function") {
+      this.translateActions.setMessages(this.translates);
     }
   }
 
   syncCachedMessagesToStore() {
-    if (typeof this.translateActions?.setMessages !== "function") {
-      return;
+    if (typeof this.translateActions?.setMessages === "function") {
+      this.translateActions.setMessages(this.translates);
     }
-
-    this.translateActions.setMessages({
-      ...this.translates,
-    });
   }
 
   getPersistRequestToken(store, type, key) {
-    return [
-      this.language,
-      this.normalizeId(this.defaultCompany?.id),
-      String(store || "").trim(),
-      String(type || "").trim(),
-      String(key || "").trim(),
-    ].join("::");
-  }
-
-  resolveReferenceId(value) {
-    if (!value) return null;
-
-    if (typeof value === "object") {
-      return this.normalizeId(value.id || value["@id"] || value.people || value.language);
-    }
-
-    return this.normalizeId(value);
+    return `${this.language}:${this.normalizeId(this.defaultCompany?.id)}:${store}:${type}:${key}`;
   }
 
   cacheTranslateRecord(record, fallbackCompanyId = null, fallbackLanguage = this.language) {
-    const companyId = this.resolveReferenceId(record?.people) || this.normalizeId(fallbackCompanyId);
+    const companyId =
+      this.resolveReferenceId(record?.people) || this.normalizeId(fallbackCompanyId);
     const language =
-      this.normalizeLanguageCode(record?.language?.language || record?.language?.locale || fallbackLanguage) ||
-      this.language;
+      this.normalizeLanguageCode(
+        record?.language?.language || record?.language?.locale || fallbackLanguage,
+      ) || this.language;
     const store = String(record?.store || "").trim();
     const type = String(record?.type || "").trim();
     const key = String(record?.key || "").trim();
@@ -310,56 +216,53 @@ export default class Translate {
       return false;
     }
 
-    const previousMessage = this.getStoreBucket(companyId, store, false, language)?.[type]?.[key];
+    const previousMessage = this.getStoreBucket(companyId, store, false, language)?.[
+      type
+    ]?.[key];
     this.findMessage(store, type, key, message, companyId, language);
 
     return previousMessage !== message;
   }
-
-  getMessageFromBuckets(store, type, key) {
-    const companyIds = [
-      this.currentCompany?.id,
-      this.defaultCompany?.id,
-    ]
-      .map((value) => this.normalizeId(value))
-      .filter(Boolean);
-
-    for (const companyId of companyIds) {
-      const companyMessage =
-        this.getStoreBucket(companyId, store)?.[type]?.[key];
-
-      if (companyMessage) {
-        return companyMessage;
-      }
-    }
-
-    return this.getStoreBucket(null, store)?.[type]?.[key];
-  }
-
+
+  getMessageFromBuckets(store, type, key) {
+    const companyIds = [this.currentCompany?.id, this.defaultCompany?.id]
+      .map((value) => this.normalizeId(value))
+      .filter(Boolean);
+
+    // Prefer current company, then main/default company, then language-global bucket.
+    // Empty/whitespace values do not count as a hit so fallback can still apply.
+    for (const companyId of companyIds) {
+      const companyMessage = this.getStoreBucket(companyId, store)?.[type]?.[key];
+      if (isNonEmptyMessage(companyMessage)) {
+        return companyMessage;
+      }
+    }
+
+    const globalMessage = this.getStoreBucket(null, store)?.[type]?.[key];
+    if (isNonEmptyMessage(globalMessage)) {
+      return globalMessage;
+    }
+
+    return globalMessage;
+  }
+
   persistMissingTranslate(store, type, key, translate) {
     if (!store || !type || !key || !this.defaultCompany?.id) return;
 
-    // verifica se tenho acesso ao defaultCompany
     const defaultCompanyId = this.normalizeId(this.defaultCompany?.id);
-    if (
-      !Array.isArray(this.companies) ||
-      !this.companies.some((company) => this.normalizeId(company?.id) === defaultCompanyId)
-    )
-      return;
-
-    if (this.hasPendingTranslate(store, type, key)) {
+    // Queueing is a local pending state used to drive resolve/discovery.
+    // Do NOT require defaultCompany to appear in this.companies: non-superadmin
+    // tenants often lack membership on the main company, but still must be able
+    // to resolve and cache the main catalog (read path). Backend gates writes.
+    if (!defaultCompanyId) {
       return;
     }
 
-    const requestToken = this.getPersistRequestToken(store, type, key);
-    if (this.pendingPersistRequests.has(requestToken)) {
+    if (this.hasPendingTranslate(store, type, key)) {
       return;
     }
 
-    if (
-      typeof this.translateActions?.queueMissingTranslate !== "function" ||
-      typeof this.translateActions?.save !== "function"
-    ) {
+    if (typeof this.translateActions?.queueMissingTranslate !== "function") {
       return;
     }
 
@@ -372,6 +275,19 @@ export default class Translate {
       translate,
     });
 
+    if (typeof this.translateActions?.resolveQueuedMessages === "function") {
+      return this.scheduleQueuedTranslateResolution();
+    }
+
+    const requestToken = this.getPersistRequestToken(store, type, key);
+    if (this.pendingPersistRequests.has(requestToken)) {
+      return this.pendingPersistRequests.get(requestToken);
+    }
+
+    if (typeof this.translateActions?.save !== "function") {
+      return;
+    }
+
     const request = Promise.resolve(
       this.translateActions.save({
         people: "/people/" + defaultCompanyId,
@@ -381,10 +297,14 @@ export default class Translate {
         key,
         translate,
         revised: false,
-      })
+      }),
     )
       .then((result) => {
-        const changed = this.cacheTranslateRecord(result, defaultCompanyId, this.language);
+        const changed = this.cacheTranslateRecord(
+          result,
+          defaultCompanyId,
+          this.language,
+        );
         this.removePendingTranslate(store, type, key);
         this.persist();
         if (changed) {
@@ -398,223 +318,182 @@ export default class Translate {
       });
 
     this.pendingPersistRequests.set(requestToken, request);
+    return request;
   }
 
   removePendingTranslate(store, type, key) {
-    if (!store || !type || !key || !this.defaultCompany?.id) return;
-
     if (typeof this.translateActions?.removePendingTranslate !== "function") {
       return;
     }
 
     this.translateActions.removePendingTranslate({
       language: this.language,
-      companyId: this.defaultCompany.id,
+      companyId: this.defaultCompany?.id,
       store,
       type,
       key,
     });
   }
-
-  t(store, type, key) {
-    const translate = this.getMessageFromBuckets(store, type, key);
-    const fallbackTranslate = this.formatMessage(key);
-    const shouldDiscoverStore =
-      this.canDiscoverStore() && !this.hasDiscoveredStore(store);
-
-    if (shouldDiscoverStore) {
-      this.ensureStoreDiscovered(store)
-        .then(() => {
-          const discoveredTranslate = this.getMessageFromBuckets(store, type, key);
-
-          if (discoveredTranslate) {
-            return;
-          }
 
-          this.persistMissingTranslate(store, type, key, fallbackTranslate);
-        })
-        .catch(() => {});
-    }
-
-    if (!translate) {
-      if (!shouldDiscoverStore) {
-        this.persistMissingTranslate(store, type, key, fallbackTranslate);
-      }
-
-      return fallbackTranslate;
-    }
-
-    return translate;
-  }
-
-  reload() {
-    this.clear();
-    return this.discoveryAll({ force: true });
+  getQueuedTranslateGroups() {
+    return readQueuedGroups(
+      this.translateStore,
+      this.defaultCompany?.id,
+      this.language,
+    );
   }
 
-  clear() {
-    this.translates = {};
-    this.discoveredStores.clear();
-    this.pendingStoreDiscoveries.clear();
-    this.pendingPersistRequests.clear();
-    if (typeof this.translateActions?.setPendingMessages === "function") {
-      this.translateActions.setPendingMessages({});
-    }
-    this.persist();
+  getQueuedTranslateGroupsForStore(store) {
+    return readQueuedGroupsForStore(
+      this.translateStore,
+      this.defaultCompany?.id,
+      store,
+      this.language,
+    );
   }
 
-  shouldFetchStoreForCompany(store, company, force = false) {
-    if (force) return true;
+  scheduleQueuedTranslateResolution() {
+    if (this.pendingTranslateResolutionPromise) {
+      return this.pendingTranslateResolutionPromise;
+    }
 
-    const companyId = this.normalizeId(company?.id);
-    if (!companyId || !store) return false;
+    this.pendingTranslateResolutionPromise = new Promise((resolve) => {
+      setTimeout(resolve, 0);
+    })
+      .then(() => this.resolveQueuedTranslations())
+      .catch(() => this.translates)
+      .finally(() => {
+        this.pendingTranslateResolutionPromise = null;
+      });
 
-    const storeBucket = this.getStoreBucket(companyId, store, false, this.language);
-    return storeBucket == null;
+    return this.pendingTranslateResolutionPromise;
   }
 
-  async discoveryAll(options = {}) {
-    const companies = this.getCompaniesToCache();
-
-    for (const company of companies) {
-      for (const store of this.getStoreList()) {
-        await this.discoveryStoreTranslate(store, {
-          ...options,
-          companies: [company],
-        });
-      }
+  async resolveQueuedTranslations() {
+    if (typeof this.translateActions?.resolveQueuedMessages !== "function") {
+      return this.translates;
     }
 
-    return this.translates;
-  }
-
-  async discoveryStoreTranslate(store, options = {}) {
-    if (!store) return this.translates;
-
-    const force = options.force === true;
-    if (!force && this.hasDiscoveredStore(store)) {
+    const requests = this.getQueuedTranslateGroups();
+    if (requests.length === 0) {
       return this.translates;
     }
 
-    const companies = Array.isArray(options.companies) && options.companies.length > 0
-      ? options.companies
-      : this.getCompaniesToCache();
+    // Resolve against every company we keep in cache (current + main) so fallback
+    // translations from the main company are available at runtime.
+    const companies = this.getCompaniesToCache();
     if (companies.length === 0) {
-      this.markStoreDiscovered(store);
       return this.translates;
     }
 
-    let hasChanges = false;
+    let changed = false;
+    const allResolvedItems = [];
+
     for (const company of companies) {
-      const changed = await this.fetchTranslates(store, company, { force });
-      hasChanges = changed || hasChanges;
-    }
+      const companyId = this.normalizeId(company?.id);
+      if (!companyId) continue;
+
+      const response = await this.translateActions.resolveQueuedMessages({
+        people: "/people/" + companyId,
+        language: this.language,
+        requests,
+      });
 
-    if (this.hasCachedBootstrapStore(store)) {
-      this.markStoreDiscovered(store);
+      const resolvedItems = Array.isArray(response)
+        ? response
+        : response?.member || response?.["hydra:member"] || [];
+
+      resolvedItems.forEach((item) => {
+        changed =
+          this.cacheTranslateRecord(item, companyId, this.language) || changed;
+        this.removePendingTranslate(item.store, item.type, item.key);
+        allResolvedItems.push(item);
+      });
     }
 
-    if (hasChanges) {
+    if (changed) {
       this.persist();
       this.notifyTranslationsUpdated();
     }
 
-    return this.translates;
+    return allResolvedItems;
   }
 
-  async fetchTranslates(store, company, options = {}) {
-    if (!company?.id) return false;
+  t(store, type, key) {
+    const translate = this.getMessageFromBuckets(store, type, key);
+    const fallbackTranslate = this.formatMessage(key);
 
-    const force = options.force === true;
-    if (!this.shouldFetchStoreForCompany(store, company, force)) {
-      return false;
-    }
+    if (!translate) {
+      const scheduleKey = `${store}:${type}:${key}`;
+      if (!this.pendingMissingTranslateSchedules.has(scheduleKey)) {
+        this.pendingMissingTranslateSchedules.add(scheduleKey);
+        setTimeout(() => {
+          this.pendingMissingTranslateSchedules.delete(scheduleKey);
+          this.persistMissingTranslate(store, type, key, fallbackTranslate);
+        }, 0);
+      }
 
-    const params = {
-      store: store,
-      "language.language": this.language,
-      people: "/people/" + company.id,
-    };
-
-    const storeTranslates = [];
-    let page = 1;
-    let firstPageSize = null;
-    const maxPages = 1000;
-
-    while (page <= maxPages) {
-      const pageItems = await this.translateActions.getItems({
-        ...params,
-        page,
-      });
-
-      if (!Array.isArray(pageItems) || pageItems.length === 0) break;
-
-      storeTranslates.push(...pageItems);
-      if (firstPageSize == null) firstPageSize = pageItems.length;
-      if (pageItems.length < firstPageSize) break;
-
-      page += 1;
+      this.ensureStoreDiscovered(store);
+      return fallbackTranslate;
     }
 
-    const companyId = this.normalizeId(company?.id);
-    const storeBucket = this.getStoreBucket(companyId, store, true);
-    let changed = false;
+    return translate;
+  }
 
-    if (storeBucket) {
-      if (Object.keys(storeBucket).length > 0) {
-        changed = true;
-      }
-      Object.keys(storeBucket).forEach((type) => {
-        delete storeBucket[type];
-      });
-    }
+  reload() {
+    this.translates = loadStorageObject(TRANSLATES_STORAGE_KEY);
+    this.syncCachedMessagesToStore();
+  }
 
-    storeTranslates.forEach((element) => {
-      changed = this.cacheTranslateRecord(
-        {
-          ...element,
-          people: element.people || companyId,
-        },
-        companyId,
-        this.language,
-      ) || changed;
-      this.removePendingTranslate(element.store, element.type, element.key);
-    });
+  clear() {
+    this.translates = {};
+    this.discoveredStores.clear();
+    this.pendingStoreDiscoveries.clear();
+    this.persist();
+  }
+
+  shouldFetchStoreForCompany(store, company, force = false) {
+    if (force) return true;
+    if (!company?.id || !store) return false;
+    return this.getStoreBucket(company.id, store) == null;
+  }
+
+  async discoveryAll(options = {}) {
+    return runDiscoveryAll(this, options);
+  }
 
-    return changed || storeTranslates.length === 0;
+  async discoveryStoreTranslate(store, options = {}) {
+    return runDiscoveryStoreTranslate(this, store, options);
+  }
+
+  async fetchTranslates(store, company, options = {}) {
+    return runFetchTranslates(this, store, company, options);
+  }
+
+  async resolveStoreTranslates(store, company, options = {}) {
+    return runResolveStoreTranslates(this, store, company, options);
   }
 
   persist() {
     if (typeof localStorage !== "undefined") {
       localStorage.setItem("translates", JSON.stringify(this.translates));
     }
-
     this.syncCachedMessagesToStore();
   }
 
   findMessage(store, type, key, message, companyId = null, language = this.language) {
-    const storeBucket = this.getStoreBucket(companyId, store, true, language);
-    if (!storeBucket) {
+    const written = writeMessageToBucket(
+      this.translates,
+      store,
+      type,
+      key,
+      message,
+      companyId,
+      language,
+    );
+    if (written == null) {
       return this.formatMessage(key);
     }
-
-    if (!storeBucket[type]) {
-      storeBucket[type] = {};
-    }
-
-    if (message !== null)
-      storeBucket[type][key] = message;
-
-    return storeBucket[type][key] || this.formatMessage(key);
-  }
-
-  formatMessage(key) {
-    if (!key) return "";
-
-    return key
-      .replace(/([a-z])([A-Z])/g, "$1_$2")
-      .replace(/_/g, " ")
-      .replace(/-/g, " ")
-      .replace(/^\w/, (c) => c.toUpperCase());
-  }
-}
+    return written || this.formatMessage(key);
+  }
+}