langsys-js-typescript 0.1.0

package/dist/index.js

@@ -0,0 +1,1249 @@
+'use strict';
+
+// src/signal.ts
+function createSignal(initial) {
+  let value = initial;
+  const subscribers = /* @__PURE__ */ new Set();
+  const subscribe = (run) => {
+    subscribers.add(run);
+    run(value);
+    return () => {
+      subscribers.delete(run);
+    };
+  };
+  const set = (next) => {
+    if (Object.is(value, next)) return;
+    value = next;
+    for (const run of subscribers) run(value);
+  };
+  const update = (fn) => {
+    set(fn(value));
+  };
+  const get = () => value;
+  return { subscribe, set, update, get };
+}
+function getValue(signal) {
+  return signal.get();
+}
+
+// src/logger.ts
+var STYLES = {
+  log: "display:inline-block;background:rgb(239,239,244);color:black;font-weight:bold;padding:3px 7px;border-radius:3px",
+  warn: "display:inline-block;background:gold;color:black;font-weight:bold;padding:3px 7px;border-radius:3px",
+  error: "display:inline-block;background:#e0005a;color:#fff;font-weight:bold;padding:3px 7px;border-radius:3px"
+};
+var supportsStyle = typeof window !== "undefined";
+function emit(level, label, args) {
+  if (supportsStyle) {
+    console[level](`%c${label}`, STYLES[level], ...args);
+  } else {
+    console[level](`[${label}]`, ...args);
+  }
+}
+var Logger = class {
+  constructor(debugEnabled = false) {
+    this.debugEnabled = debugEnabled;
+  }
+  log(...args) {
+    if (!this.debugEnabled) return;
+    emit("log", "Langsys Debug", args);
+  }
+  warn(...args) {
+    emit("warn", "Langsys Warning", args);
+  }
+  error(...args) {
+    emit("error", "Langsys Error", args);
+  }
+};
+var logger = new Logger(false);
+
+// src/api.ts
+var LangsysAppAPIClass = class {
+  constructor() {
+    this.apiurl = "https://api.langsys.dev/api";
+    this.config = {
+      projectid: "",
+      key: "",
+      sUserLocale: createSignal(""),
+      baseLocale: "en"
+    };
+    this.headers = {
+      "Content-Type": "application/json; charset=utf-8",
+      "x-Authorization": this.config.key
+    };
+  }
+  setup(config2) {
+    if (config2?.key && config2?.projectid) {
+      this.config = config2;
+      this.headers["x-Authorization"] = this.config.key;
+    }
+  }
+  /** Optional hook to point the client at a different API host. */
+  setBaseUrl(url) {
+    this.apiurl = url.replace(/\/$/, "");
+  }
+  async validate(config2) {
+    this.setup(config2);
+    return await this.get("authorize-project/[projectid]");
+  }
+  async getTranslations(locale) {
+    return await this.get("projects/[projectid]/translations", { locale });
+  }
+  async post(path, data = {}) {
+    return await this.send("POST", path, data);
+  }
+  async get(path, data = {}) {
+    return await this.send("GET", path, data);
+  }
+  async delete(path, data = {}) {
+    return await this.send("DELETE", path, data);
+  }
+  async patch(path, data = {}) {
+    return await this.send("PATCH", path, data);
+  }
+  async put(path, data = {}) {
+    return await this.send("PUT", path, data);
+  }
+  async send(method, path, data = {}) {
+    if (!this.config.projectid || !this.config.key) {
+      return {
+        status: false,
+        errors: ["Missing projectid or API key in configuration"],
+        http: {
+          status: 0,
+          statusText: "Configuration Error",
+          url: `${this.apiurl}/${path}`,
+          data: JSON.stringify(data)
+        }
+      };
+    }
+    if (path.startsWith("/")) path = path.substring(1);
+    if (path.includes("/[projectid]")) {
+      path = path.replaceAll("/[projectid]", `/${this.config.projectid}`);
+    }
+    try {
+      const querystring = method === "GET" ? "?" + new URLSearchParams(data).toString() : "";
+      const query = await fetch(`${this.apiurl}/${path}${querystring === "?" ? "" : querystring}`, {
+        headers: this.headers,
+        method,
+        body: method === "GET" ? void 0 : JSON.stringify(data)
+      });
+      const responseData = await query.json();
+      const http = {
+        status: query.status,
+        statusText: query.statusText,
+        url: query.url,
+        data: JSON.stringify(data)
+      };
+      responseData.http = http;
+      if (!query.ok) {
+        logger.warn("LangsysAppAPI failed to query", responseData);
+        return {
+          status: false,
+          errors: [`HTTP ${query.status}: ${query.statusText}`],
+          data: responseData,
+          http
+        };
+      }
+      return responseData;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error occurred";
+      logger.error("LangsysAppAPI Error:", errorMessage);
+      logger.error("Request details:", {
+        method,
+        url: `${this.apiurl}/${path}`,
+        data
+      });
+      return {
+        status: false,
+        errors: ["Error communicating with API Server", errorMessage],
+        http: {
+          status: 0,
+          statusText: "Network Error",
+          url: `${this.apiurl}/${path}`,
+          data: JSON.stringify(data)
+        }
+      };
+    }
+  }
+};
+var LangsysAppAPI = new LangsysAppAPIClass();
+
+// src/persist.ts
+function persist(key, initial) {
+  const storage = getSafeStorage();
+  let seed = initial;
+  if (storage) {
+    try {
+      const raw = storage.getItem(key);
+      if (raw !== null) seed = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const signal = createSignal(seed);
+  if (storage) {
+    signal.subscribe((value) => {
+      try {
+        storage.setItem(key, JSON.stringify(value));
+      } catch {
+      }
+    });
+  }
+  return signal;
+}
+function getSafeStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    const s = window.localStorage;
+    s.getItem("__langsys_probe__");
+    return s;
+  } catch {
+    return null;
+  }
+}
+
+// src/stores.ts
+var initialTranslations = {
+  __uncategorized__: {
+    __category__: "__uncategorized__",
+    __symbol__: "__uncategorized__"
+  }
+};
+var sTranslations = persist("translations", initialTranslations);
+var currentlyLoadedLocale = createSignal("");
+var contentBlocks = createSignal([]);
+var config = {
+  projectid: "",
+  key: "",
+  sUserLocale: createSignal(""),
+  baseLocale: "en",
+  debug: false,
+  key_type: "read"
+};
+
+// src/interpolate.ts
+function interpolate(template, params) {
+  return template.replace(/\{([^{}]+)\}/g, (match, rawKey) => {
+    const key = rawKey.trim();
+    if (!(key in params)) return match;
+    const value = params[key];
+    if (value === void 0 || value === null) return match;
+    if (value instanceof Date) return value.toISOString();
+    return String(value);
+  });
+}
+
+// src/translations.ts
+function isObject(test) {
+  return typeof test === "object" && !Array.isArray(test) && test !== null;
+}
+function sameToken(a, b) {
+  return a.projectid === b.projectid && a.category === b.category && a.token === b.token;
+}
+var Translations = class {
+  constructor(config2) {
+    this.lastLoaded = {};
+    this.missingTokens = [];
+    this.timer = null;
+    this.flushScheduled = false;
+    this.isFirstClientRun = true;
+    this.config = config2;
+    this.debug = new Logger(!!config2.debug);
+    this.locale = config2.baseLocale || "";
+    this.tSignal = createSignal(this.buildTFn());
+    sTranslations.subscribe(() => this.tSignal.set(this.buildTFn()));
+    currentlyLoadedLocale.subscribe(() => this.tSignal.set(this.buildTFn()));
+    if (config2.key && config2.projectid) this.setup(config2);
+  }
+  /** Current translation function. Reads fresh state on every call. */
+  get t() {
+    return this.tSignal.get();
+  }
+  /** Subscribe to translation snapshot changes. Fires immediately with the current value. */
+  subscribe(run) {
+    return sTranslations.subscribe(run);
+  }
+  /**
+   * Content-block-keyed lookup used by the DOM `Translate` class.
+   * Returns the per-token translation inside a content block, or `null` if
+   * either the content block or the inner token is missing. Never registers
+   * a missing token — the DOM class manages its own lifecycle via content blocks.
+   */
+  lookupContent(category, customId, token) {
+    const cats = sTranslations.get();
+    const lookupCat = category || "__uncategorized__";
+    const contentData = cats[lookupCat]?.[customId];
+    if (!contentData || typeof contentData !== "object") return null;
+    const value = contentData[token];
+    return typeof value === "string" ? value : null;
+  }
+  buildTFn() {
+    return (category, phrase, ...args) => {
+      const cats = sTranslations.get();
+      const lookupCat = category || "__uncategorized__";
+      const value = cats[lookupCat]?.[phrase];
+      let translated;
+      if (typeof value === "string" && value.length > 0) {
+        this.debug.log("TRANSLATION FOUND", [lookupCat, phrase, value]);
+        translated = value;
+      } else {
+        this.missingToken(lookupCat, phrase);
+        translated = phrase;
+      }
+      const params = args[0];
+      return params ? interpolate(translated, params) : translated;
+    };
+  }
+  missingToken(category, token) {
+    if (token === void 0 || token === null) {
+      return this.debug.warn(`Received undefined or null token for category: ${category}`);
+    }
+    if (this.config.key_type !== "write") {
+      this.debug.log(`Skipping missing token collection (API key is ${this.config.key_type || "unknown"}):`, {
+        category,
+        token
+      });
+      return;
+    }
+    if (/^[0-9a-f]{32}$/.test(token)) return;
+    if (token === "toJSON") {
+      this.debug.error(`Received toJSON as token ${category}:${token}`, token);
+      return;
+    }
+    if (token === "") {
+      this.debug.warn("Received empty token", token);
+      return;
+    }
+    const missingToken = { category, token, projectid: this.config.projectid };
+    if (!this.missingTokens.some((t2) => sameToken(t2, missingToken))) {
+      this.debug.log("MISSING TOKEN LOOKUP FAILED", [missingToken, [...this.missingTokens], { ...sTranslations.get() }]);
+      this.missingTokens.push(missingToken);
+      this.scheduleTokenFlush();
+    }
+  }
+  scheduleTokenFlush() {
+    const strategy = this.config.ssrTokenStrategy || "client";
+    const isSSR = typeof window === "undefined";
+    if (isSSR) {
+      switch (strategy) {
+        case "server":
+          if (!this.flushScheduled) {
+            this.flushScheduled = true;
+            queueMicrotask(() => {
+              this.updateTokens().then(() => {
+                this.flushScheduled = false;
+              });
+            });
+          }
+          break;
+        case "auto":
+          if (this.missingTokens.length <= 5 && !this.flushScheduled) {
+            this.flushScheduled = true;
+            queueMicrotask(() => {
+              this.updateTokens().then(() => {
+                this.flushScheduled = false;
+              });
+            });
+          }
+          break;
+        case "client":
+        default:
+          this.debug.log("SSR: Queuing tokens for client-side transmission");
+          break;
+      }
+    } else {
+      if (!this.flushScheduled && !this.timer) {
+        this.flushScheduled = true;
+        queueMicrotask(() => {
+          this.updateTokens().then(() => {
+            this.flushScheduled = false;
+          });
+        });
+      }
+    }
+  }
+  setup(config2) {
+    this.config = config2;
+    if (!this.config.projectid || !this.config.key) return;
+    if (this.config.debug) this.debug.debugEnabled = this.config.debug;
+    if (config2.baseLocale) this.locale = config2.baseLocale;
+    this.debug.log("TRANSLATION SETUP INITIATED", this.config);
+    if (typeof window !== "undefined") {
+      if (this.isFirstClientRun && this.missingTokens.length > 0) {
+        this.isFirstClientRun = false;
+        const strategy = this.config.ssrTokenStrategy || "client";
+        if (strategy === "client" || strategy === "auto" && this.missingTokens.length > 5) {
+          this.debug.log(`Post-hydration: Flushing ${this.missingTokens.length} SSR-collected tokens`);
+          queueMicrotask(() => this.updateTokens());
+        }
+      }
+      if (this.timer) clearInterval(this.timer);
+      this.timer = setInterval(() => this.updateTokens(), 3e3);
+      this.debug.log("UPDATE TOKEN INTERVAL", this.timer);
+    } else {
+      const strategy = this.config.ssrTokenStrategy || "client";
+      this.debug.log(`SSR environment detected - using '${strategy}' token strategy`);
+    }
+  }
+  /**
+   * React to a user-locale change. Fetches translations if we haven't
+   * loaded this locale within the last 60s (or if forced).
+   */
+  async change(locale, force = false, skipFetch = false) {
+    if (!locale) return false;
+    if (!this.config.projectid || !this.config.key) return false;
+    if (skipFetch) {
+      this.debug.log("Using pre-fetched translations for locale", locale);
+      this.locale = locale;
+      this.lastLoaded[locale] = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+      return true;
+    }
+    const now = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+    if (!force && locale === this.locale && this.lastLoaded[locale] && Math.abs(this.lastLoaded[locale] - now) < 60) {
+      return false;
+    }
+    this.debug.log("Locale change detected!", locale);
+    this.locale = locale;
+    await this.getTranslations();
+    return true;
+  }
+  async updateTokens() {
+    if (!this.missingTokens.length) return false;
+    if (!this.config.projectid || !this.config.key) return false;
+    if (this.config.key_type !== "write") {
+      this.debug.log(`Skipping token updates (API key is ${this.config.key_type || "unknown"})`);
+      return false;
+    }
+    if (typeof window === "undefined") {
+      this.debug.log(`Sending ${this.missingTokens.length} tokens from SSR`);
+    }
+    const currentData = sTranslations.get();
+    this.missingTokens = this.missingTokens.filter((tokenObj) => {
+      tokenObj.projectid = this.config.projectid;
+      if (tokenObj.category in currentData && tokenObj.token in currentData[tokenObj.category]) {
+        this.debug.log("Missing token already exists! Skipping:", {
+          category: tokenObj.category,
+          token: tokenObj.token,
+          existing: currentData[tokenObj.category][tokenObj.token]
+        });
+        return false;
+      }
+      return true;
+    });
+    if (!this.missingTokens.length) return false;
+    this.debug.log("CREATE MISSING TOKENS", this.missingTokens);
+    try {
+      const response = await LangsysAppAPI.post("projects/[projectid]/tokens", {
+        tokens: this.missingTokens
+      });
+      if (!response.status) {
+        if (response.errors) {
+          this.debug.log("TOKEN UPDATE FAIL", this.missingTokens);
+          this.debug.error("Error updating project tokens", response.errors);
+        }
+        return false;
+      }
+      this.missingTokens.forEach((tokenObj) => {
+        if (!currentData[tokenObj.category]) {
+          currentData[tokenObj.category] = {
+            __category__: tokenObj.category,
+            __symbol__: tokenObj.category
+          };
+        }
+        currentData[tokenObj.category][tokenObj.token] = tokenObj.token;
+        currentData[tokenObj.category]["__category__"] = tokenObj.category;
+      });
+      sTranslations.set({ ...currentData });
+      this.missingTokens = [];
+      return true;
+    } catch (err) {
+      this.debug.log("CREATE MISSING TOKEN FAILURE", this.missingTokens);
+      this.debug.error("Error updating project tokens", err);
+      return false;
+    }
+  }
+  async getTranslations() {
+    if (!LangsysAppAPI.config.projectid && this.config.projectid) {
+      LangsysAppAPI.setup(this.config);
+    }
+    const response = await LangsysAppAPI.getTranslations(this.locale);
+    this.debug.log("GET TRANSLATIONS API RESPONSE", response);
+    if (response.errors) {
+      this.debug.error("Error", response.errors[0]);
+      return;
+    }
+    const trans = response.data;
+    if (!isObject(trans["__uncategorized__"])) {
+      trans["__uncategorized__"] = {
+        __category__: "__uncategorized__",
+        __symbol__: "__uncategorized__"
+      };
+    }
+    for (const cat of Object.keys(trans)) {
+      trans[cat]["__category__"] = cat;
+    }
+    this.debug.log("GET TRANSLATIONS " + this.locale, trans);
+    sTranslations.set(trans);
+    setTimeout(() => currentlyLoadedLocale.set(this.locale), 100);
+    this.lastLoaded[this.locale] = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+  }
+};
+
+// src/langsys-app.ts
+var LangsysAppClass = class {
+  constructor() {
+    this.translationsLoadingPromise = Promise.resolve();
+    this.locales = {};
+    this.countries = [];
+    this.countriesLocale = "";
+    this.dialCodes = [];
+    this.dialCodesLocale = "";
+    this.currencies = [];
+    this.currenciesLocale = "";
+    this.config = config;
+    this.debug = new Logger(!!this.config.debug);
+    this.Translations = new Translations(this.config);
+  }
+  /** Current translation function. Reads fresh state on every call. */
+  get t() {
+    return this.Translations.t;
+  }
+  async refresh() {
+    const locale = this.config.sUserLocale.get();
+    this.locales = {};
+    return this.Translations.change(locale, true);
+  }
+  /**
+   * Initialize Langsys. Configuration must include at least `projectid`,
+   * `key`, and `UserLocaleStore` (any Signal<string>).
+   */
+  async init(initConfig) {
+    const projectid = initConfig.projectid;
+    const key = initConfig.key;
+    const UserLocaleStore = initConfig.UserLocaleStore;
+    let baseLocale = initConfig.baseLocale || "en";
+    const debug = initConfig.debug || false;
+    const emulateFailureToLoad = initConfig.emulateFailureToLoad || false;
+    const ssrTokenStrategy = initConfig.ssrTokenStrategy || "client";
+    const initialTranslations2 = initConfig.initialTranslations;
+    const initialTranslationsLocale = initConfig.initialTranslationsLocale;
+    this.debug.debugEnabled = debug;
+    if (debug && initialTranslations2) {
+      this.debug.log("SSR initial translations config:", {
+        hasInitialTranslations: !!initialTranslations2,
+        initialTranslationsLocale,
+        categoriesProvided: initialTranslations2 ? Object.keys(initialTranslations2).length : 0,
+        categories: initialTranslations2 ? Object.keys(initialTranslations2) : []
+      });
+    }
+    if (!projectid) {
+      this.debug.error("LangsysApp.init missing projectid in configuration object!");
+      return { status: false, errors: ["Missing projectid"] };
+    }
+    if (!key) {
+      this.debug.error("LangsysApp.init missing API key in configuration object!");
+      return { status: false, errors: ["Missing API key"] };
+    }
+    if (!UserLocaleStore?.subscribe) {
+      this.debug.error(
+        "LangsysApp.init missing UserLocaleStore \u2014 pass a Signal<string> (createSignal('en-us') works if you have nothing of your own)."
+      );
+      return { status: false, errors: ["Missing UserLocaleStore"] };
+    }
+    baseLocale = baseLocale.toLowerCase();
+    if (!emulateFailureToLoad) {
+      this.config = {
+        projectid,
+        key,
+        sUserLocale: UserLocaleStore,
+        baseLocale,
+        debug,
+        ssrTokenStrategy
+      };
+      Object.assign(config, this.config);
+    }
+    const validateResponse = await LangsysAppAPI.validate(this.config);
+    if (validateResponse.status && validateResponse.data) {
+      const authData = validateResponse.data;
+      if (authData.key_type) {
+        this.config.key_type = authData.key_type;
+        config.key_type = authData.key_type;
+        this.debug.log("API Key Type:", this.config.key_type);
+      }
+    }
+    if (initialTranslations2 && initialTranslationsLocale) {
+      if (!initialTranslations2["__uncategorized__"]) {
+        initialTranslations2["__uncategorized__"] = {
+          __category__: "__uncategorized__",
+          __symbol__: "__uncategorized__"
+        };
+      }
+      for (const cat of Object.keys(initialTranslations2)) {
+        initialTranslations2[cat]["__category__"] = cat;
+      }
+      sTranslations.set(initialTranslations2);
+      currentlyLoadedLocale.set(initialTranslationsLocale);
+      this.debug.log("Populated sTranslations with initial data for locale:", initialTranslationsLocale);
+    }
+    this.Translations.setup(this.config);
+    this.config.sUserLocale.subscribe((locale) => {
+      if (!validateResponse.status) return;
+      this.getLocalesData(locale);
+      this.debug.log("SUBSCRIBING TO USER LOCALE STORE");
+      const skipFetch = initialTranslationsLocale === locale && !!initialTranslations2;
+      this.translationsLoadingPromise = this.Translations.change(locale, false, skipFetch);
+    });
+    return validateResponse;
+  }
+  async getDialCodes(inLocale) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (this.dialCodes.length && this.dialCodesLocale === locale) return this.dialCodes;
+    const route = `countries/dial-codes/${locale}`;
+    const response = await LangsysAppAPI.get(route);
+    if (response.errors || !response.status) {
+      this.debug.error("LangsysApp.getDialCodes failed: " + route);
+      return [];
+    }
+    this.dialCodes = response.data;
+    this.dialCodesLocale = locale;
+    return this.dialCodes;
+  }
+  async getCurrencies(inLocale) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (this.currencies.length && this.currenciesLocale === locale) return this.currencies;
+    const route = `currencies/${locale}`;
+    const response = await LangsysAppAPI.get(route);
+    if (response.errors || !response.status) {
+      this.debug.error("LangsysApp.getCurrencies failed: " + route);
+      return [];
+    }
+    this.currencies = response.data;
+    this.currenciesLocale = locale;
+    return this.currencies;
+  }
+  async getCountries(inLocale) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (this.countries.length && this.countriesLocale === locale) return this.countries;
+    const route = `countries/${locale}`;
+    const response = await LangsysAppAPI.get(route);
+    if (response.errors || !response.status) {
+      this.debug.error("LangsysApp.getCountries failed: " + route);
+      return [];
+    }
+    this.countries = response.data;
+    this.countriesLocale = locale;
+    return this.countries;
+  }
+  async getCountryName(forCountryCode, inLocale) {
+    if (!forCountryCode) return "";
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (!this.countries.length || this.countriesLocale !== locale) await this.getCountries(inLocale);
+    const country = this.countries.find((c) => c.code.toLowerCase() === forCountryCode.toLowerCase())?.label;
+    if (!country) this.debug.warn("getCountryName failed to match", forCountryCode);
+    return country || forCountryCode;
+  }
+  async getCurrencyName(forCurrencyCode, inLocale) {
+    if (!forCurrencyCode) return "";
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (!this.currencies.length || this.currenciesLocale !== locale) await this.getCurrencies(inLocale);
+    const currency = this.currencies.find((c) => c.code?.toLowerCase() === forCurrencyCode.toLowerCase())?.name;
+    if (!currency) this.debug.warn("getCurrencyName failed to match", forCurrencyCode);
+    return currency || forCurrencyCode;
+  }
+  async getLocalesFormat(format = "", inLocale) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    const route = `locales/${locale}` + (format ? `/${format}` : "");
+    const response = await LangsysAppAPI.get(route);
+    if (response.errors || !response.status) {
+      this.debug.error(response.errors, response.status, response);
+      this.debug.error("LangsysApp.getLocales failed: " + route);
+      return format === "flat" ? [] : format === "data" ? [] : {};
+    }
+    switch (format) {
+      case "flat":
+        return response.data;
+      case "data":
+        return response.data;
+      default:
+        return response.data;
+    }
+  }
+  async getLocalesFlat(inLocale) {
+    return await this.getLocalesFormat("flat", inLocale);
+  }
+  async getLocalesData(inLocale, forceRefresh = false) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    if (this.locales?.[locale]?.length && !forceRefresh) return this.locales[locale];
+    this.locales[locale] = await this.getLocalesFormat("data", inLocale);
+    return this.locales[locale];
+  }
+  async getLocales(inLocale) {
+    return await this.getLocalesFormat("", inLocale);
+  }
+  async getLocaleNameWithLookup(forLocale, shortName = false, inLocale) {
+    if (!forLocale) return "";
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    await this.getLocalesData(locale);
+    return this.getLocaleName(forLocale, shortName, locale);
+  }
+  getLocaleName(forLocale, shortName = false, inLocale) {
+    const locale = inLocale || this.config.sUserLocale.get() || this.config.baseLocale;
+    let name = "";
+    this.locales[locale]?.every((loc) => {
+      if (loc.code === forLocale) {
+        name = shortName ? loc.lang_name : loc.locale_name;
+        return false;
+      }
+      return true;
+    });
+    if (!name) this.debug.warn("getLocaleNameWithLookup failed to match", forLocale);
+    return name;
+  }
+  /** @deprecated use `getLocaleNameWithLookup` or `getLocaleName` */
+  async getLanguageName(forLocale, shortName = false, inLocale) {
+    return this.getLocaleNameWithLookup(forLocale, shortName, inLocale);
+  }
+  /**
+   * Detects the end-user's preferred locale.
+   *
+   * - In browsers, uses `navigator.languages` with fallback to `navigator.language`.
+   * - In SSR environments, parses the `Accept-Language` header.
+   */
+  detectPreferredLocale(acceptLanguageHeader, supportedLocales) {
+    const userLocales = this.getUserLanguagePreferences(acceptLanguageHeader);
+    if (userLocales.length === 0) return false;
+    if (supportedLocales && supportedLocales.length > 0) {
+      const bestMatch = this.findBestLocaleMatch(userLocales, supportedLocales);
+      if (bestMatch) return bestMatch;
+    }
+    return this.normalizeLocale(userLocales[0]);
+  }
+  getUserLanguagePreferences(acceptLanguageHeader) {
+    if (acceptLanguageHeader) {
+      try {
+        return this.parseAcceptLanguageHeader(acceptLanguageHeader);
+      } catch (error) {
+        this.debug.warn("Failed to parse Accept-Language header:", error);
+      }
+    }
+    if (typeof navigator !== "undefined") {
+      if (navigator.languages && navigator.languages.length > 0) {
+        return Array.from(navigator.languages);
+      }
+      if (navigator.language) return [navigator.language];
+    }
+    return [];
+  }
+  parseAcceptLanguageHeader(header) {
+    if (!header || typeof header !== "string" || header.trim() === "") return [];
+    try {
+      return header.split(",").map((part) => {
+        const trimmed = part.trim();
+        if (!trimmed || trimmed === "*") return null;
+        const [localePart, qPart] = trimmed.split(";q=");
+        const locale = localePart?.trim();
+        const q = qPart ? parseFloat(qPart) : 1;
+        if (!locale || isNaN(q) || q <= 0 || q > 1) return null;
+        return { locale, q };
+      }).filter((item) => item !== null).sort((a, b) => b.q - a.q).map((item) => item.locale);
+    } catch (error) {
+      this.debug.warn("Error parsing Accept-Language header:", error);
+      return [];
+    }
+  }
+  findBestLocaleMatch(userLocales, supportedLocales) {
+    if (!userLocales.length || !supportedLocales.length) return null;
+    const normalizedSupported = supportedLocales.map((l) => this.normalizeLocale(l));
+    for (const userLocale of userLocales) {
+      const normalizedUser = this.normalizeLocale(userLocale);
+      if (normalizedSupported.includes(normalizedUser)) return normalizedUser;
+    }
+    for (const userLocale of userLocales) {
+      const userLang = this.getLanguageCode(userLocale);
+      for (const supported of normalizedSupported) {
+        if (this.getLanguageCode(supported) === userLang) return supported;
+      }
+    }
+    return null;
+  }
+  normalizeLocale(locale) {
+    if (!locale || typeof locale !== "string") return locale;
+    const parts = locale.split(/[-_]/);
+    if (parts.length === 1) return parts[0].toLowerCase();
+    const language = parts[0].toLowerCase();
+    const region = parts[1].toUpperCase();
+    return `${language}-${region}`;
+  }
+  getLanguageCode(locale) {
+    if (!locale || typeof locale !== "string") return "";
+    return locale.split(/[-_]/)[0].toLowerCase();
+  }
+};
+var LangsysApp = new LangsysAppClass();
+
+// src/utils.ts
+var isEmpty = (data) => {
+  if (typeof data === "number" || typeof data === "boolean") return false;
+  if (typeof data === "undefined" || data === null) return true;
+  if (typeof data.length !== "undefined") {
+    return data.length === 0;
+  }
+  if (typeof data === "object") return Object.keys(data).length === 0;
+  return false;
+};
+function md5(inputString) {
+  if (typeof inputString !== "string") inputString = JSON.stringify(inputString);
+  const hc = "0123456789abcdef";
+  function rh(n) {
+    let j, s = "";
+    for (j = 0; j <= 3; j++) s += hc.charAt(n >> j * 8 + 4 & 15) + hc.charAt(n >> j * 8 & 15);
+    return s;
+  }
+  function ad(x2, y) {
+    const l = (x2 & 65535) + (y & 65535);
+    const m = (x2 >> 16) + (y >> 16) + (l >> 16);
+    return m << 16 | l & 65535;
+  }
+  function rl(n, c2) {
+    return n << c2 | n >>> 32 - c2;
+  }
+  function cm(q, a2, b2, x2, s, t2) {
+    return ad(rl(ad(ad(a2, q), ad(x2, t2)), s), b2);
+  }
+  function ff(a2, b2, c2, d2, x2, s, t2) {
+    return cm(b2 & c2 | ~b2 & d2, a2, b2, x2, s, t2);
+  }
+  function gg(a2, b2, c2, d2, x2, s, t2) {
+    return cm(b2 & d2 | c2 & ~d2, a2, b2, x2, s, t2);
+  }
+  function hh(a2, b2, c2, d2, x2, s, t2) {
+    return cm(b2 ^ c2 ^ d2, a2, b2, x2, s, t2);
+  }
+  function ii(a2, b2, c2, d2, x2, s, t2) {
+    return cm(c2 ^ (b2 | ~d2), a2, b2, x2, s, t2);
+  }
+  function sb(x2) {
+    let i2;
+    const nblk = (x2.length + 8 >> 6) + 1;
+    const blks = new Array(nblk * 16);
+    for (i2 = 0; i2 < nblk * 16; i2++) blks[i2] = 0;
+    for (i2 = 0; i2 < x2.length; i2++) blks[i2 >> 2] |= x2.charCodeAt(i2) << i2 % 4 * 8;
+    blks[i2 >> 2] |= 128 << i2 % 4 * 8;
+    blks[nblk * 16 - 2] = x2.length * 8;
+    return blks;
+  }
+  let i, x = sb("" + inputString), a = 1732584193, b = -271733879, c = -1732584194, d = 271733878, olda, oldb, oldc, oldd;
+  for (i = 0; i < x.length; i += 16) {
+    olda = a;
+    oldb = b;
+    oldc = c;
+    oldd = d;
+    a = ff(a, b, c, d, x[i + 0], 7, -680876936);
+    d = ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = gg(b, c, d, a, x[i + 0], 20, -373897302);
+    a = gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = hh(d, a, b, c, x[i + 0], 11, -358537222);
+    c = hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = ii(a, b, c, d, x[i + 0], 6, -198630844);
+    d = ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = ad(a, olda);
+    b = ad(b, oldb);
+    c = ad(c, oldc);
+    d = ad(d, oldd);
+  }
+  return rh(a) + rh(b) + rh(c) + rh(d);
+}
+
+// src/translate.ts
+var TRANSLATABLE_ATTRIBUTES = [
+  "placeholder",
+  "alt",
+  "title",
+  "aria-label",
+  "aria-placeholder",
+  "data-error",
+  "data-error-message",
+  "data-validation-message",
+  "data-invalid-message",
+  "data-required-message",
+  "data-pattern-message"
+];
+var VALUE_TRANSLATABLE_ELEMENTS = ["button"];
+var VALUE_TRANSLATABLE_INPUT_TYPES = ["submit", "button"];
+var SEMANTIC_STYLE_PROPERTIES = [
+  "font-size",
+  "font-weight",
+  "font-style",
+  "font-variant",
+  "line-height",
+  "letter-spacing",
+  "word-spacing",
+  "text-align",
+  "text-decoration",
+  "text-transform",
+  "text-indent",
+  "text-shadow",
+  "white-space",
+  "-webkit-font-smoothing",
+  "color",
+  "background-color",
+  "background-image",
+  "background-position",
+  "background-size",
+  "background-repeat",
+  "border",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-radius",
+  "border-color",
+  "border-width",
+  "border-style",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "box-shadow",
+  "opacity",
+  "filter",
+  "display",
+  "visibility",
+  "list-style",
+  "list-style-type",
+  "cursor"
+];
+var Translate = class {
+  constructor(element, options = {}) {
+    this.contentClone = null;
+    this.tokens = [];
+    this.parseComplete = false;
+    this.isTokenizing = false;
+    this.lastTranslatedLocale = "";
+    this.unsubscribeLocale = null;
+    this.element = element;
+    this.options = { ...options };
+    this.custom_id = options.custom_id || "";
+    void this.tokenizeContent();
+    this.unsubscribeLocale = currentlyLoadedLocale.subscribe((locale) => {
+      if (locale && this.parseComplete) this.translateUpdate(locale);
+    });
+  }
+  /** Stop reacting to locale changes. Safe to call multiple times. */
+  destroy() {
+    if (this.unsubscribeLocale) {
+      this.unsubscribeLocale();
+      this.unsubscribeLocale = null;
+    }
+  }
+  translateUpdate(currentLocale) {
+    if (!this.element?.innerHTML || !this.parseComplete) return;
+    if (this.lastTranslatedLocale === currentLocale) return;
+    const { category = "" } = this.options;
+    if (this.tokens.length === 1) {
+      this.element.innerText = LangsysApp.Translations.t(category, this.tokens[0]);
+    } else {
+      this.translate(Array.from(this.element.childNodes));
+      this.lastTranslatedLocale = currentLocale;
+    }
+  }
+  async tokenizeContent() {
+    if (this.isTokenizing) return false;
+    if (!this.element || !this.element.childNodes.length) {
+      this.parseComplete = true;
+      this.isTokenizing = false;
+      return false;
+    }
+    this.isTokenizing = true;
+    this.contentClone = this.element.cloneNode(true);
+    const nodes = Array.from(this.contentClone.childNodes || []);
+    this.tokenize(nodes);
+    const { category = "" } = this.options;
+    if (this.tokens.length === 1) {
+      this.element.innerText = LangsysApp.Translations.t(category, this.tokens[0]);
+    } else {
+      const contentBlock = {
+        custom_id: "",
+        category,
+        label: this.options.label,
+        content: this.contentClone.outerHTML,
+        tokens: this.tokens
+      };
+      await this.handleContentBlock(contentBlock);
+    }
+    this.parseComplete = true;
+    this.isTokenizing = false;
+    return true;
+  }
+  async handleContentBlock(contentBlock) {
+    if (isEmpty(this.custom_id)) this.custom_id = this.generateCustomId(contentBlock);
+    contentBlock.custom_id = this.custom_id;
+    const current = contentBlocks.get();
+    const existing = current.find((b) => b.custom_id === this.custom_id);
+    if (!existing) {
+      if (config.key_type === "write") {
+        LangsysAppAPI.post("projects/[projectid]/content-blocks", contentBlock).then((response) => {
+          if (!response.status) {
+            logger.error("Could not save content block", response.errors);
+          } else {
+            contentBlocks.update((blocks) => [...blocks, contentBlock]);
+          }
+        }).catch((err) => logger.error("Could not save content block", err));
+      } else if (config.debug) {
+        logger.log(`Skipping content block save (API key is ${config.key_type || "unknown"})`);
+      }
+      if (this.tokens.length > 1 && this.element) {
+        this.translate(Array.from(this.element.childNodes));
+        this.lastTranslatedLocale = currentlyLoadedLocale.get();
+      }
+    }
+  }
+  tokenize(nodes, indices = []) {
+    nodes.forEach((node, index) => {
+      if (node?.nodeType === Node.ELEMENT_NODE) {
+        const element = node;
+        if (element.getAttribute("translate") === "no") return;
+      }
+      if (node?.hasChildNodes()) {
+        this.applyStylesToNode(node, [...indices, index]);
+      }
+      if (node?.nodeType === Node.ELEMENT_NODE) {
+        this.tokenizeAttributes(node);
+      }
+      const contentToken = node.nodeValue?.replace(/\s+/g, " ").trim();
+      if (node?.nodeType === Node.TEXT_NODE && contentToken) {
+        this.tokens.push(contentToken);
+        return;
+      }
+      if (!node?.hasChildNodes()) return;
+      this.tokenize(Array.from(node.childNodes), [...indices, index]);
+    });
+  }
+  tokenizeAttributes(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (tagName === "img") {
+      const img = element;
+      if (img.src) element.setAttribute("src", img.src);
+    }
+    for (const attr of TRANSLATABLE_ATTRIBUTES) {
+      const value = element.getAttribute(attr)?.trim();
+      if (value) this.tokens.push(value);
+    }
+    if (VALUE_TRANSLATABLE_ELEMENTS.includes(tagName)) {
+      const value = element.getAttribute("value")?.trim();
+      if (value) this.tokens.push(value);
+    }
+    if (tagName === "input") {
+      const inputType = element.getAttribute("type")?.toLowerCase();
+      if (inputType && VALUE_TRANSLATABLE_INPUT_TYPES.includes(inputType)) {
+        const value = element.getAttribute("value")?.trim();
+        if (value) this.tokens.push(value);
+      }
+    }
+    if (tagName === "select") {
+      const options = element.querySelectorAll("option");
+      options.forEach((option) => {
+        const optionText = option.textContent?.trim();
+        if (optionText) this.tokens.push(optionText);
+      });
+    }
+  }
+  findNode(nodes, indices) {
+    let currentNode = nodes[indices[0]];
+    for (let i = 1; i < indices.length; i++) {
+      if (!currentNode || !currentNode.hasChildNodes()) return void 0;
+      currentNode = Array.from(currentNode.childNodes)[indices[i]];
+    }
+    return currentNode;
+  }
+  translate(nodes) {
+    const currentLocale = currentlyLoadedLocale.get();
+    if (currentLocale === config.baseLocale && (this.lastTranslatedLocale === "" || this.lastTranslatedLocale === config.baseLocale)) {
+      return;
+    }
+    nodes.forEach((node) => {
+      if (node?.nodeType === Node.ELEMENT_NODE) {
+        const element = node;
+        if (element.getAttribute("translate") === "no") return;
+        this.translateAttributes(node);
+      }
+      if (node?.nodeType !== Node.TEXT_NODE) {
+        if (!node?.hasChildNodes()) return;
+        this.translate(Array.from(node.childNodes));
+        return;
+      }
+      if (isEmpty(node.nodeValue?.trim())) return;
+      if (isEmpty(node.originalNodeValue)) {
+        node.originalNodeValue = node.nodeValue;
+      }
+      const contentToken = node.originalNodeValue?.replace(/\s+/g, " ").trim();
+      if (!contentToken) return;
+      const translation = this.getTranslation(contentToken);
+      if (translation && contentToken && node.originalNodeValue) {
+        node.nodeValue = node.originalNodeValue.replace(contentToken, translation);
+      } else if (node.originalNodeValue) {
+        node.nodeValue = node.originalNodeValue;
+      }
+    });
+  }
+  getTranslation(token) {
+    if (!token) return null;
+    const { category = "" } = this.options;
+    return LangsysApp.Translations.lookupContent(category, this.custom_id, token);
+  }
+  translateAttributes(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (!element.originalAttributes) element.originalAttributes = {};
+    for (const attr of TRANSLATABLE_ATTRIBUTES) {
+      this.translateAttribute(element, attr);
+    }
+    if (VALUE_TRANSLATABLE_ELEMENTS.includes(tagName)) {
+      this.translateAttribute(element, "value");
+    }
+    if (tagName === "input") {
+      const inputType = element.getAttribute("type")?.toLowerCase();
+      if (inputType && VALUE_TRANSLATABLE_INPUT_TYPES.includes(inputType)) {
+        this.translateAttribute(element, "value");
+      }
+    }
+    if (tagName === "select") {
+      const options = element.querySelectorAll("option");
+      options.forEach((option) => {
+        const optionEl = option;
+        if (!optionEl.originalAttributes) optionEl.originalAttributes = {};
+        if (optionEl.originalAttributes["textContent"] === void 0) {
+          optionEl.originalAttributes["textContent"] = option.textContent || "";
+        }
+        const originalText = optionEl.originalAttributes["textContent"].trim();
+        if (originalText) {
+          const translation = this.getTranslation(originalText);
+          option.textContent = translation || optionEl.originalAttributes["textContent"];
+        }
+      });
+    }
+  }
+  translateAttribute(element, attr) {
+    const currentValue = element.getAttribute(attr);
+    if (!currentValue) return;
+    if (element.originalAttributes[attr] === void 0) {
+      element.originalAttributes[attr] = currentValue;
+    }
+    const originalValue = element.originalAttributes[attr].trim();
+    if (!originalValue) return;
+    const translation = this.getTranslation(originalValue);
+    if (translation) element.setAttribute(attr, translation);
+    else element.setAttribute(attr, element.originalAttributes[attr]);
+  }
+  generateCustomId(contentBlock) {
+    return md5(`${contentBlock.category}-${contentBlock.tokens.join("-")}`);
+  }
+  applyStylesToNode(node, indices) {
+    if (!this.element || typeof window === "undefined") return;
+    const domNode = this.findNode(Array.from(this.element.childNodes), indices);
+    if (!domNode) return;
+    const tagName = domNode.tagName.toLowerCase();
+    const reference = document.createElement(tagName);
+    reference.style.visibility = "hidden";
+    reference.style.position = "absolute";
+    document.body.appendChild(reference);
+    const computed = window.getComputedStyle(domNode);
+    const defaults = window.getComputedStyle(reference);
+    for (const prop of SEMANTIC_STYLE_PROPERTIES) {
+      const value = computed.getPropertyValue(prop);
+      const defaultValue = defaults.getPropertyValue(prop);
+      if (value && value !== defaultValue) {
+        node.style.setProperty(prop, value);
+      }
+    }
+    document.body.removeChild(reference);
+    node.removeAttribute("class");
+  }
+};
+
+// src/index.ts
+var t = ((category, phrase, ...args) => {
+  return LangsysApp.Translations.t(category, phrase, ...args);
+});
+var tSignal = LangsysApp.Translations.tSignal;
+
+exports.LangsysApp = LangsysApp;
+exports.LangsysAppAPI = LangsysAppAPI;
+exports.Logger = Logger;
+exports.Translate = Translate;
+exports.Translations = Translations;
+exports.contentBlocks = contentBlocks;
+exports.createSignal = createSignal;
+exports.currentlyLoadedLocale = currentlyLoadedLocale;
+exports.getValue = getValue;
+exports.interpolate = interpolate;
+exports.isEmpty = isEmpty;
+exports.logger = logger;
+exports.md5 = md5;
+exports.persist = persist;
+exports.sTranslations = sTranslations;
+exports.t = t;
+exports.tSignal = tSignal;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map