intor 2.2.14 → 2.3.0

package/dist/index.js

@@ -1,214 +0,0 @@
-import merge from 'lodash.merge';
-export { Translator } from 'intor-translator';
-
-// src/shared/constants/prefix-placeholder.ts
-var PREFIX_PLACEHOLDER = "{locale}";
-var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  if (!loadedMessages) return { ...staticMessages };
-  return merge({}, staticMessages, loadedMessages);
-};
-
-// src/shared/utils/normalize-cache-key.ts
-var CACHE_KEY_DELIMITER = "|";
-var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
-var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
-  if (key === null || key === void 0) return null;
-  if (Array.isArray(key)) {
-    if (key.length === 0) return null;
-    const normalized = key.map((k) => {
-      if (k === null) return "__null";
-      if (k === void 0) return "__undefined";
-      if (typeof k === "boolean") return k ? "__true" : "__false";
-      return sanitize(String(k));
-    });
-    return normalized.join(delimiter);
-  }
-  if (typeof key === "boolean") return key ? "__true" : "__false";
-  return String(key);
-};
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  const { loader } = config;
-  const { routeNamespaces = {}, namespaces } = loader || {};
-  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
-    return void 0;
-  const standardizedPathname = standardizePathname({ config, pathname });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${PREFIX_PLACEHOLDER}`,
-    ""
-  );
-  const collected = [
-    ...routeNamespaces.default || [],
-    // default
-    ...namespaces || [],
-    // default
-    ...routeNamespaces[standardizedPathname] || [],
-    // exact match
-    ...routeNamespaces[placeholderRemovedPathname] || []
-    // exact match
-  ];
-  const prefixPatterns = Object.keys(routeNamespaces).filter(
-    (pattern) => pattern.endsWith("/*")
-  );
-  for (const pattern of prefixPatterns) {
-    const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath) || placeholderRemovedPathname.startsWith(basePath)) {
-      collected.push(...routeNamespaces[pattern] || []);
-    }
-  }
-  return [...new Set(collected)];
-};
-
-// src/shared/utils/locale/normalize-locale.ts
-var toCanonical = (input) => {
-  try {
-    return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
-  } catch {
-    return;
-  }
-};
-var normalizeLocale = (locale = "", supportedLocales = []) => {
-  if (!locale || supportedLocales.length === 0) return;
-  const canonicalLocale = toCanonical(locale);
-  if (!canonicalLocale) return;
-  const supportedCanonicalMap = /* @__PURE__ */ new Map();
-  for (const l of supportedLocales) {
-    const normalized = toCanonical(l);
-    if (normalized) {
-      supportedCanonicalMap.set(normalized, l);
-    }
-  }
-  if (supportedCanonicalMap.has(canonicalLocale)) {
-    return supportedCanonicalMap.get(canonicalLocale);
-  }
-  const baseLang = canonicalLocale.split("-")[0];
-  for (const [key, original] of supportedCanonicalMap) {
-    const supportedBase = key.split("-")[0];
-    if (supportedBase === baseLang) {
-      return original;
-    }
-  }
-  return;
-};
-
-// src/shared/utils/locale/resolve-preferred-locale.ts
-var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
-  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
-    return;
-  }
-  const supportedLocalesSet = new Set(supportedLocales);
-  const preferred = acceptLanguageHeader.split(",").map((part) => {
-    const [lang, qValue] = part.split(";");
-    const q = qValue ? Number.parseFloat(qValue.split("=")[1]) : 1;
-    if (Number.isNaN(q)) {
-      return { lang: lang.trim(), q: 0 };
-    }
-    return { lang: lang.trim(), q };
-  }).toSorted((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-  return preferred;
-};
-
-// src/shared/utils/pathname/normalize-pathname.ts
-var normalizePathname = (rawPathname, options = {}) => {
-  const length = rawPathname.length;
-  let start = 0;
-  let end = length - 1;
-  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
-  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
-  if (start > end) return "/";
-  let result = "";
-  let hasSlash = false;
-  for (let i = start; i <= end; i++) {
-    const char = rawPathname[i];
-    if (char === "/") {
-      if (!hasSlash) {
-        hasSlash = true;
-      }
-    } else {
-      result += hasSlash || result === "" ? "/" + char : char;
-      hasSlash = false;
-    }
-  }
-  if (options.removeLeadingSlash && result.startsWith("/")) {
-    result = result.slice(1);
-  }
-  return result || "/";
-};
-
-// src/shared/utils/pathname/extract-pathname.ts
-var extractPathname = ({
-  config,
-  pathname: rawPathname
-}) => {
-  const { routing, defaultLocale } = config;
-  const { basePath, prefix } = routing;
-  const normalizedPathname = normalizePathname(rawPathname);
-  let prefixedPathname = normalizedPathname;
-  if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-    prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
-  } else if (basePath && normalizedPathname === basePath) {
-    prefixedPathname = "/";
-  }
-  const pathPart = prefixedPathname.split("/").find(Boolean);
-  const maybeLocale = pathPart || "";
-  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
-  let unprefixedPathname = prefixedPathname;
-  if (prefix === "all") {
-    if (isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  } else if (prefix === "except-default") {
-    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  }
-  return {
-    basePath,
-    prefixedPathname,
-    unprefixedPathname,
-    maybeLocale,
-    isLocalePrefixed: Boolean(isLocalePrefixed)
-  };
-};
-
-// src/shared/utils/pathname/standardize-pathname.ts
-var standardizePathname = ({
-  config,
-  pathname
-}) => {
-  const { routing } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    PREFIX_PLACEHOLDER,
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/shared/error/intor-error.ts
-var IntorError = class extends Error {
-  code;
-  id;
-  constructor({ message, code, id }) {
-    const fullMessage = id ? `[${id}] ${message}` : message;
-    super(fullMessage);
-    this.name = "IntorError";
-    this.id = id;
-    this.code = code;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var IntorErrorCode = /* @__PURE__ */ ((IntorErrorCode2) => {
-  IntorErrorCode2["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
-  IntorErrorCode2["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
-  IntorErrorCode2["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
-  return IntorErrorCode2;
-})(IntorErrorCode || {});
-
-export { IntorError, IntorErrorCode, PREFIX_PLACEHOLDER, extractPathname, mergeMessages, normalizeCacheKey, normalizeLocale, normalizePathname, resolveNamespaces, resolvePreferredLocale, standardizePathname };