intor 2.2.14 → 2.2.15

package/dist/src/shared/utils/locale/resolve-preferred-locale.js

@@ -0,0 +1,26 @@
+/**
+ * Resolves the preferred locale based on the Accept-Language header and supported locales.
+ */
+const 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 }; // Treat invalid q values as having 0 priority
+        }
+        return { lang: lang.trim(), q };
+    })
+        .toSorted((a, b) => b.q - a.q)
+        .find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+    return preferred;
+};
+
+export { resolvePreferredLocale };

package/dist/src/shared/utils/merge-messages.d.ts

@@ -0,0 +1,6 @@
+import type { LocaleMessages } from "intor-translator";
+/**
+ * Deeply merges loaded messages into static messages by locale.
+ * - Loaded messages override static ones on conflict.
+ */
+export declare const mergeMessages: (staticMessages?: LocaleMessages, loadedMessages?: LocaleMessages | undefined) => LocaleMessages;

package/dist/src/shared/utils/merge-messages.js

@@ -0,0 +1,13 @@
+import merge from 'lodash.merge';
+
+/**
+ * Deeply merges loaded messages into static messages by locale.
+ * - Loaded messages override static ones on conflict.
+ */
+const mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
+    if (!loadedMessages)
+        return { ...staticMessages };
+    return merge({}, staticMessages, loadedMessages);
+};
+
+export { mergeMessages };

package/dist/src/shared/utils/normalize-cache-key.d.ts

@@ -0,0 +1,3 @@
+type RawCacheKey = string | boolean | Array<string | number | boolean | undefined | null>;
+export declare const normalizeCacheKey: (key?: RawCacheKey, delimiter?: string) => string | null;
+export {};

package/dist/src/shared/utils/normalize-cache-key.js

@@ -0,0 +1,29 @@
+const CACHE_KEY_DELIMITER = "|";
+// Helper FC
+const sanitize = (k) => k
+    .replaceAll(/[\u200B-\u200D\uFEFF]/g, "")
+    .replaceAll(/[\r\n]/g, "")
+    .trim();
+const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+    if (key === null || key === undefined)
+        return null;
+    if (Array.isArray(key)) {
+        if (key.length === 0)
+            return null;
+        const normalized = key.map((k) => {
+            if (k === null)
+                return "__null";
+            if (k === undefined)
+                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);
+};
+
+export { normalizeCacheKey };

package/dist/src/shared/utils/pathname/extract-pathname.d.ts

@@ -0,0 +1,28 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+interface ExtractPathnameOptions {
+    config: IntorResolvedConfig;
+    pathname: string;
+}
+interface ExtractPathnameResult {
+    basePath: string;
+    prefixedPathname: string;
+    unprefixedPathname: string;
+    maybeLocale: string;
+    isLocalePrefixed: boolean;
+}
+/**
+ * Extracts basePath and locale info from a raw pathname.
+ *
+ * ```ts
+ * extractPathname({ config, pathname: '/app/en/about' });
+ * => {
+ *   basePath: '/app',
+ *   prefixedPathname: '/en/about',
+ *   unprefixedPathname: '/about',
+ *   maybeLocale: 'en',
+ *   isLocalePrefixed: true
+ * }
+ * ```
+ */
+export declare const extractPathname: ({ config, pathname: rawPathname, }: ExtractPathnameOptions) => ExtractPathnameResult;
+export {};

package/dist/src/shared/utils/pathname/extract-pathname.js

@@ -0,0 +1,58 @@
+import { normalizePathname } from './normalize-pathname.js';
+
+/**
+ * Extracts basePath and locale info from a raw pathname.
+ *
+ * ```ts
+ * extractPathname({ config, pathname: '/app/en/about' });
+ * => {
+ *   basePath: '/app',
+ *   prefixedPathname: '/en/about',
+ *   unprefixedPathname: '/about',
+ *   maybeLocale: 'en',
+ *   isLocalePrefixed: true
+ * }
+ * ```
+ */
+const extractPathname = ({ config, pathname: rawPathname, }) => {
+    const { routing, defaultLocale } = config;
+    const { basePath, prefix } = routing;
+    const normalizedPathname = normalizePathname(rawPathname);
+    let prefixedPathname = normalizedPathname;
+    // Remove basePath if exists
+    if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+        prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
+    }
+    else if (basePath && normalizedPathname === basePath) {
+        prefixedPathname = "/";
+    }
+    // Extract potential locale from pathname
+    const pathPart = prefixedPathname.split("/").find(Boolean);
+    const maybeLocale = pathPart || "";
+    const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale); // Check by supportedLocales
+    // prefix: "none"
+    let unprefixedPathname = prefixedPathname;
+    // prefix: "all"
+    if (prefix === "all") {
+        if (isLocalePrefixed) {
+            unprefixedPathname =
+                prefixedPathname.slice(maybeLocale.length + 1) || "/";
+        }
+    }
+    // prefix: "except-default",
+    else if (prefix === "except-default") {
+        if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
+            unprefixedPathname =
+                prefixedPathname.slice(maybeLocale.length + 1) || "/";
+        }
+    }
+    return {
+        basePath,
+        prefixedPathname,
+        unprefixedPathname,
+        maybeLocale,
+        isLocalePrefixed: Boolean(isLocalePrefixed),
+    };
+};
+
+export { extractPathname };

package/dist/src/shared/utils/pathname/normalize-pathname.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Normalize a raw pathname string to ensure consistent formatting.
+ *
+ * - Trims leading and trailing whitespace (code points ≤ 32).
+ * - Collapses consecutive slashes into a single slash.
+ * - Ensures a leading slash and removes trailing slashes.
+ * - Optionally removes the leading slash.
+ * - Avoids intermediate array allocations for performance.
+ */
+export declare const normalizePathname: (rawPathname: string, options?: {
+    removeLeadingSlash?: boolean;
+}) => string;

package/dist/src/shared/utils/pathname/normalize-pathname.js

@@ -0,0 +1,43 @@
+/**
+ * Normalize a raw pathname string to ensure consistent formatting.
+ *
+ * - Trims leading and trailing whitespace (code points ≤ 32).
+ * - Collapses consecutive slashes into a single slash.
+ * - Ensures a leading slash and removes trailing slashes.
+ * - Optionally removes the leading slash.
+ * - Avoids intermediate array allocations for performance.
+ */
+const normalizePathname = (rawPathname, options = {}) => {
+    const length = rawPathname.length;
+    let start = 0;
+    let end = length - 1;
+    // Trim leading whitespace
+    while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32)
+        start++;
+    // Trim trailing whitespace
+    while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32)
+        end--;
+    if (start > end)
+        return "/"; // Only whitespace
+    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 the result has a leading slash and we want to remove it, do so
+    if (options.removeLeadingSlash && result.startsWith("/")) {
+        result = result.slice(1);
+    }
+    return result || "/";
+};
+
+export { normalizePathname };

package/dist/src/shared/utils/pathname/standardize-pathname.d.ts

@@ -0,0 +1,18 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+interface StandardizePathnameOptions {
+    config: IntorResolvedConfig;
+    pathname: string;
+}
+/**
+ * Standardize a pathname by prepending the base path and prefix placeholder,
+ * then normalize the result to remove redundant slashes.
+ *
+ * ```ts
+ * standardizePathname({ config, pathname: "/cms" });
+ * // basePath: "/asd/qwe"
+ * // prefixPlaceHolder: "{locale}"
+ * => "/asd/qwe/{locale}/cms"
+ * ```
+ */
+export declare const standardizePathname: ({ config, pathname, }: StandardizePathnameOptions) => string;
+export {};

package/dist/src/shared/utils/pathname/standardize-pathname.js

@@ -0,0 +1,30 @@
+import { PREFIX_PLACEHOLDER } from '../../constants/prefix-placeholder.js';
+import { normalizePathname } from './normalize-pathname.js';
+
+/**
+ * Standardize a pathname by prepending the base path and prefix placeholder,
+ * then normalize the result to remove redundant slashes.
+ *
+ * ```ts
+ * standardizePathname({ config, pathname: "/cms" });
+ * // basePath: "/asd/qwe"
+ * // prefixPlaceHolder: "{locale}"
+ * => "/asd/qwe/{locale}/cms"
+ * ```
+ */
+const standardizePathname = ({ config, pathname, }) => {
+    const { routing } = config;
+    const { basePath } = routing;
+    // Normalize each segment before join to avoid redundant slashes
+    const parts = [
+        normalizePathname(basePath),
+        PREFIX_PLACEHOLDER,
+        normalizePathname(pathname),
+    ];
+    // Avoid double slashes between segments
+    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
+    // Final normalization to ensure leading slash, no trailing
+    return normalizePathname(standardizedPathname);
+};
+
+export { standardizePathname };

package/dist/src/shared/utils/resolve-namespaces.d.ts

@@ -0,0 +1,10 @@
+import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
+interface ResolveNamespacesOptions {
+    config: IntorResolvedConfig;
+    pathname: string;
+}
+/**
+ * Resolves namespaces based on pathname.
+ */
+export declare const resolveNamespaces: ({ config, pathname, }: ResolveNamespacesOptions) => string[] | undefined;
+export {};

package/dist/src/shared/utils/resolve-namespaces.js

@@ -0,0 +1,33 @@
+import { PREFIX_PLACEHOLDER } from '../constants/prefix-placeholder.js';
+import { standardizePathname } from './pathname/standardize-pathname.js';
+
+/**
+ * Resolves namespaces based on pathname.
+ */
+const resolveNamespaces = ({ config, pathname, }) => {
+    const { loader } = config;
+    const { routeNamespaces = {}, namespaces } = loader || {};
+    if (Object.keys(routeNamespaces).length === 0 && !namespaces)
+        return undefined;
+    // "/{locale}/...", "__basePath__/{locale}/...""
+    const standardizedPathname = standardizePathname({ config, pathname });
+    // "/...", "__basePath__/...""
+    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] || [])); // match pattern
+        }
+    }
+    return [...new Set(collected)];
+};
+
+export { resolveNamespaces };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor",
-  "version": "2.2.14",
+  "version": "2.2.15",
   "description": "A modular and extensible i18n core designed for TypeScript and JavaScript projects. Intor enables custom translation logic with support for both frontend and backend environments, featuring runtime configuration, caching, adapters, and message loaders.",
   "author": "Yiming Liao",
   "license": "MIT",
@@ -26,44 +26,34 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "types": "./dist/exports/index.d.ts",
+      "import": "./dist/exports/index.js"
     },
     "./config": {
-      "types": "./dist/config/index.d.ts",
-      "import": "./dist/config/index.js",
-      "require": "./dist/config/index.cjs"
+      "types": "./dist/exports/config/index.d.ts",
+      "import": "./dist/exports/config/index.js"
     },
     "./server": {
-      "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js",
-      "require": "./dist/server/index.cjs"
+      "types": "./dist/exports/server/index.d.ts",
+      "import": "./dist/exports/server/index.js"
     },
     "./react": {
-      "types": "./dist/react/index.d.ts",
-      "import": "./dist/react/index.js",
-      "require": "./dist/react/index.cjs"
+      "types": "./dist/exports/react/index.d.ts",
+      "import": "./dist/exports/react/index.js"
     },
     "./next": {
-      "types": "./dist/next/index.d.ts",
-      "import": "./dist/next/index.js",
-      "require": "./dist/next/index.cjs"
+      "types": "./dist/exports/next/index.d.ts",
+      "import": "./dist/exports/next/index.js"
     },
     "./next/middleware": {
-      "types": "./dist/next/middleware/index.d.ts",
-      "import": "./dist/next/middleware/index.js",
-      "require": "./dist/next/middleware/index.cjs"
+      "types": "./dist/exports/next/middleware/index.d.ts",
+      "import": "./dist/exports/next/middleware/index.js"
     },
     "./next/server": {
-      "types": "./dist/next/server/index.d.ts",
-      "import": "./dist/next/server/index.js",
-      "require": "./dist/next/server/index.cjs"
+      "types": "./dist/exports/next/server/index.d.ts",
+      "import": "./dist/exports/next/server/index.js"
     }
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md",
@@ -71,13 +61,18 @@
   ],
   "type": "module",
   "scripts": {
-    "build": "tsup",
-    "prepublishOnly": "yarn build",
     "type": "tsc --noEmit",
     "lint": "eslint",
     "lint:debug": "eslint --debug",
     "test": "vitest",
-    "knip": "knip --config .config/knip.config.ts"
+    "knip": "knip --config .config/knip.config.ts",
+    "clean": "rm -rf dist",
+    "build:core": "rollup -c .config/rollup/core.js",
+    "build:react": "rollup -c .config/rollup/react.js",
+    "build:next": "rollup -c .config/rollup/next.js",
+    "build:dts": "rollup -c .config/rollup/dts.js",
+    "build": "yarn clean && yarn build:core && yarn build:react && yarn build:next &&  yarn tsc -p tsconfig.build.json && yarn tsc-alias tsconfig.build.json --outDir dist",
+    "prepublishOnly": "yarn build"
   },
   "dependencies": {
     "intor-translator": "^1.1.5",
@@ -88,11 +83,12 @@
   },
   "devDependencies": {
     "@intor/cli": "^0.1.2",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/lodash.merge": "^4.6.9",
     "@types/node": "^24.10.1",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@vitest/coverage-v8": "4.0.9",
+    "@vitest/coverage-v8": "4.0.13",
     "eslint": "^9.27.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
@@ -108,7 +104,9 @@
     "react-dom": "^19.0.0",
     "remark": "^15.0.1",
     "remark-gfm": "^4.0.1",
-    "tsup": "^8.5.1",
+    "rollup": "^4.53.3",
+    "rollup-plugin-preserve-directives": "^0.4.0",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.32.1",
     "vitest": "^4.0.9"

package/dist/config/index.cjs

@@ -1,198 +0,0 @@
-'use strict';
-
-// src/config/constants/cache.constants.ts
-var DEFAULT_CACHE_OPTIONS = {
-  enabled: process.env.NODE_ENV === "production",
-  ttl: 60 * 60 * 1e3
-  // 1 hour
-};
-
-// src/config/resolvers/resolve-cache-options.ts
-var resolveCacheOptions = (cache) => {
-  return {
-    ...DEFAULT_CACHE_OPTIONS,
-    ...cache
-  };
-};
-
-// src/config/constants/cookie.constants.ts
-var DEFAULT_COOKIE_OPTIONS = {
-  enabled: true,
-  autoSetCookie: true,
-  name: "intor.i18n.locale",
-  domain: null,
-  path: "/",
-  maxAge: 60 * 60 * 24 * 365,
-  // 365 days
-  httpOnly: false,
-  secure: process.env.NODE_ENV !== "development",
-  sameSite: "lax"
-};
-
-// src/config/resolvers/resolve-cookie-options.ts
-var resolveCookieOptions = (cookie = {}) => {
-  return {
-    ...DEFAULT_COOKIE_OPTIONS,
-    ...cookie
-  };
-};
-
-// src/config/resolvers/resolve-fallback-locales.ts
-var resolveFallbackLocales = (config, supportedLocales) => {
-  const { defaultLocale, fallbackLocales } = config;
-  if (!fallbackLocales || typeof fallbackLocales !== "object") {
-    return {};
-  }
-  const supportedSet = new Set(supportedLocales);
-  const validMap = {};
-  const invalidFallbackMap = /* @__PURE__ */ new Map();
-  for (const [locale, fallbacks] of Object.entries(fallbackLocales)) {
-    const fallbackArray = Array.isArray(fallbacks) ? fallbacks : [];
-    const validFallbacks = fallbackArray.filter(
-      (fallback) => fallback === "default" || supportedSet.has(fallback) || fallback === defaultLocale
-    );
-    const invalidFallbacks = fallbackArray.filter(
-      (fallback) => fallback !== "default" && !supportedSet.has(fallback) && fallback !== defaultLocale
-    );
-    if (invalidFallbacks.length > 0) {
-      invalidFallbackMap.set(locale, invalidFallbacks);
-    }
-    if (validFallbacks.length > 0) {
-      validMap[locale] = validFallbacks;
-    }
-  }
-  for (const [locale, invalids] of invalidFallbackMap.entries()) {
-    console.warn(
-      `Invalid fallback locales for "${locale}"`,
-      { invalids: [...invalids] },
-      { scope: "resolveFallbackLocales" }
-    );
-  }
-  return validMap;
-};
-
-// src/config/constants/routing.constants.ts
-var DEFAULT_ROUTING_OPTIONS = {
-  prefix: "none",
-  firstVisit: {
-    localeSource: "browser",
-    redirect: true
-  },
-  basePath: "/"
-};
-
-// 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/config/resolvers/resolve-routing-options.ts
-var resolveRoutingOptions = (routing = {}) => {
-  return {
-    ...DEFAULT_ROUTING_OPTIONS,
-    ...routing,
-    firstVisit: {
-      ...DEFAULT_ROUTING_OPTIONS.firstVisit,
-      ...routing.firstVisit
-    },
-    basePath: normalizePathname(routing?.basePath || "")
-  };
-};
-
-// 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);
-  }
-};
-
-// src/config/validators/validate-default-locale.ts
-var validateDefaultLocale = (config, supportedLocales) => {
-  const { id, defaultLocale } = config;
-  if (!defaultLocale) {
-    throw new IntorError({
-      id,
-      code: "INTOR_MISSING_DEFAULT_LOCALE" /* MISSING_DEFAULT_LOCALE */,
-      message: `The defaultLocale is undefined`
-    });
-  }
-  if (!supportedLocales.includes(defaultLocale)) {
-    throw new IntorError({
-      id,
-      code: "INTOR_UNSUPPORTED_DEFAULT_LOCALE" /* UNSUPPORTED_DEFAULT_LOCALE */,
-      message: `The defaultLocale "${defaultLocale}" is not included in the supportedLocales.`
-    });
-  }
-  return defaultLocale;
-};
-
-// src/config/validators/validate-supported-locales.ts
-var validateSupportedLocales = (config) => {
-  const { id, loader, supportedLocales } = config;
-  if (loader && !supportedLocales) {
-    throw new IntorError({
-      id,
-      code: "INTOR_MISSING_SUPPORTED_LOCALES" /* MISSING_SUPPORTED_LOCALES */,
-      message: `"supportedLocales" is required when using loader, but it is missing.`
-    });
-  }
-  return supportedLocales || Object.keys(config.messages || {});
-};
-
-// src/config/define-intor-config.ts
-var defineIntorConfig = (config) => {
-  const id = config.id || `ID${Math.random().toString(36).slice(2, 6)}`;
-  const supportedLocales = validateSupportedLocales(config);
-  const defaultLocale = validateDefaultLocale(config, supportedLocales);
-  const fallbackLocales = resolveFallbackLocales(config, supportedLocales);
-  const cookie = resolveCookieOptions(config.cookie);
-  const routing = resolveRoutingOptions(config.routing);
-  const cache = resolveCacheOptions(config.cache);
-  return {
-    id,
-    messages: config.messages,
-    loader: config.loader,
-    defaultLocale,
-    supportedLocales,
-    fallbackLocales,
-    translator: config.translator,
-    cookie,
-    routing,
-    logger: config.logger,
-    cache
-  };
-};
-
-exports.DEFAULT_CACHE_OPTIONS = DEFAULT_CACHE_OPTIONS;
-exports.DEFAULT_COOKIE_OPTIONS = DEFAULT_COOKIE_OPTIONS;
-exports.DEFAULT_ROUTING_OPTIONS = DEFAULT_ROUTING_OPTIONS;
-exports.defineIntorConfig = defineIntorConfig;