intor 2.5.0 → 2.6.0

package/dist/vue/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -4,98 +4,81 @@ import { collectRemoteResources } from './collect-remote-resources.js';
 import { fetchRemoteResource } from './fetch-remote-resource.js';
 import { resolveRemoteResources } from './resolve-remote-resources.js';
 
-/**
- * Load locale messages from a remote source.
- *
- * This function serves as the orchestration layer for remote message loading.
- * It coordinates:
- *
- * - Locale resolution with fallbacks
- * - Concurrency control for network requests
- * - Remote resource fetching and message merging
- *
- * Remote messages are fetched on demand and are not memoized at the process level.
- *
- * Network requests and response validation are delegated to lower-level utilities.
- */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }) => {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "load-remote-messages" });
-    // Abort early if the request has already been cancelled
-    if (signal?.aborted) {
-        logger.debug("Remote message loading aborted before fetch.");
+const loadRemoteMessages = async ({
+  locale,
+  fallbackLocales,
+  namespaces,
+  concurrency,
+  fetch,
+  url: baseUrl,
+  headers,
+  signal,
+  loggerOptions
+}) => {
+  const baseLogger = getLogger(loggerOptions);
+  const logger = baseLogger.child({ scope: "load-remote-messages" });
+  if (signal?.aborted) {
+    logger.debug("Remote message loading aborted before fetch.");
+    return;
+  }
+  const start = performance.now();
+  logger.debug("Loading remote messages.", { baseUrl });
+  const limit = concurrency ? pLimit(concurrency) : void 0;
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
+    try {
+      const resources = collectRemoteResources({
+        locale: candidateLocale,
+        baseUrl,
+        ...namespaces !== void 0 ? { namespaces } : {}
+      });
+      const fetchUrl = (url) => fetchRemoteResource({
+        url,
+        ...headers !== void 0 ? { headers } : {},
+        ...signal !== void 0 ? { signal } : {},
+        loggerOptions,
+        fetch
+      });
+      const results = await Promise.all(
+        resources.map(
+          ({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)
+        )
+      );
+      if (!results.some(Boolean)) continue;
+      const resolved = resolveRemoteResources(
+        resources.map((res, i) => {
+          const data = results[i];
+          return { path: res.path, ...data !== void 0 ? { data } : {} };
+        })
+      );
+      messages = { [candidateLocale]: resolved };
+      break;
+    } catch {
+      if (signal?.aborted) {
+        logger.debug("Remote message loading aborted.");
         return;
-    }
-    const start = performance.now();
-    logger.debug("Loading remote messages.", { baseUrl });
-    // ----------------------------------------------------------------
-    // Resolve locale messages with ordered fallback strategy
-    // ----------------------------------------------------------------
-    const limit = concurrency ? pLimit(concurrency) : undefined;
-    const candidateLocales = [locale, ...(fallbackLocales || [])];
-    let messages;
-    for (const candidateLocale of candidateLocales) {
-        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
-        try {
-            // -----------------------------------------------------------------
-            // Collect remote message resources for the locale
-            // -----------------------------------------------------------------
-            const resources = collectRemoteResources({
-                locale: candidateLocale,
-                baseUrl,
-                ...(namespaces !== undefined ? { namespaces } : {}),
-            });
-            // -----------------------------------------------------------------
-            // Fetch all message chunks in parallel
-            // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({
-                url,
-                ...(headers !== undefined ? { headers } : {}),
-                ...(signal !== undefined ? { signal } : {}),
-                loggerOptions,
-                fetch,
-            });
-            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
-            // Guard: no valid remote resources
-            if (!results.some(Boolean))
-                continue;
-            // -----------------------------------------------------------------
-            // Resolve and merge remote message resources
-            // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => {
-                const data = results[i];
-                return { path: res.path, ...(data !== undefined ? { data } : {}) };
-            }));
-            // -----------------------------------------------------------------
-            // Wrap resolved messages into locale-scoped LocaleMessages
-            // -----------------------------------------------------------------
-            messages = { [candidateLocale]: resolved };
-            break;
-        }
-        catch {
-            if (signal?.aborted) {
-                logger.debug("Remote message loading aborted.");
-                return;
-            }
-            if (isLast) {
-                logger.warn("Failed to load messages for all candidate locales.", {
-                    locale,
-                    fallbackLocales,
-                });
-            }
-            else {
-                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
-            }
-        }
-    }
-    // Final success log with resolved locale and timing
-    if (messages) {
-        logger.trace("Finished loading remote messages.", {
-            loadedLocale: Object.keys(messages)[0],
-            duration: `${Math.round(performance.now() - start)} ms`,
+      }
+      if (isLast) {
+        logger.warn("Failed to load messages for all candidate locales.", {
+          locale,
+          fallbackLocales
         });
+      } else {
+        logger.warn(
+          `Failed to load locale messages for "${candidateLocale}", trying next fallback.`
+        );
+      }
     }
-    return messages;
+  }
+  if (messages) {
+    logger.trace("Finished loading remote messages.", {
+      loadedLocale: Object.keys(messages)[0],
+      duration: `${Math.round(performance.now() - start)} ms`
+    });
+  }
+  return messages;
 };
 
 export { loadRemoteMessages };

package/dist/vue/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -1,24 +1,14 @@
 import { deepMerge } from '../../utils/deep-merge.js';
 import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
 
-/**
- * Resolve remote message resources into a single MessageObject.
- *
- * - Applies semantic nesting based on resource path
- * - Merges all resolved message chunks
- *
- * Always returns a MessageObject.
- * An empty object represents an empty translation domain.
- */
 function resolveRemoteResources(resources) {
-    let result = {};
-    for (const { path, data } of resources) {
-        if (!data)
-            continue;
-        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
-        result = deepMerge(result, resolved);
-    }
-    return result;
+  let result = {};
+  for (const { path, data } of resources) {
+    if (!data) continue;
+    const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
+    result = deepMerge(result, resolved);
+  }
+  return result;
 }
 
 export { resolveRemoteResources };

package/dist/vue/src/core/messages/merge-messages.js

@@ -1,35 +1,24 @@
 import { getLogger } from '../logger/get-logger.js';
 import { deepMerge } from '../utils/deep-merge.js';
 
-/**
- * Merge locale-specific messages with runtime overrides.
- *
- * - Only merges messages under the given locale
- * - Emits debug logs for add / override events
- *
- * @public
- */
 function mergeMessages(a, b, { config, locale, onEvent }) {
-    const baseLogger = getLogger({ ...config.logger, id: config.id });
-    const logger = baseLogger.child({ scope: "merge-messages" });
-    // Merge messages for the active locale only
-    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
-        onOverride: (event) => {
-            if (onEvent) {
-                onEvent(event);
-                return;
-            }
-            const { kind, path, next, prev } = event;
-            if (kind === "add")
-                return;
-            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
-        },
-    });
-    // Preserve other locales, update only the target one
-    return {
-        ...a,
-        [locale]: merged,
-    };
+  const baseLogger = getLogger({ ...config.logger, id: config.id });
+  const logger = baseLogger.child({ scope: "merge-messages" });
+  const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
+    onOverride: (event) => {
+      if (onEvent) {
+        onEvent(event);
+        return;
+      }
+      const { kind, path, next, prev } = event;
+      if (kind === "add") return;
+      logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
+    }
+  });
+  return {
+    ...a,
+    [locale]: merged
+  };
 }
 
 export { mergeMessages };

package/dist/vue/src/core/messages/utils/is-valid-messages.js

@@ -1,44 +1,29 @@
-/** Check if a value is a plain object (not null, not array) */
 function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/**
- * Check if a value is a valid MessageObject.
- *
- * - Supports all MessageValue variants (primitive, array, object).
- * - Uses an iterative approach to avoid stack overflow.
- */
 function isValidMessages(value) {
-    if (!isPlainObject(value))
-        return false;
-    const stack = [value];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        // primitives are always valid
-        if (current === null ||
-            typeof current === "string" ||
-            typeof current === "number" ||
-            typeof current === "boolean") {
-            continue;
-        }
-        // array → validate each item
-        if (Array.isArray(current)) {
-            for (const item of current) {
-                stack.push(item);
-            }
-            continue;
-        }
-        // object → validate each value
-        if (isPlainObject(current)) {
-            for (const v of Object.values(current)) {
-                stack.push(v);
-            }
-            continue;
-        }
-        // everything else is invalid
-        return false;
+  if (!isPlainObject(value)) return false;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === null || typeof current === "string" || typeof current === "number" || typeof current === "boolean") {
+      continue;
     }
-    return true;
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        stack.push(item);
+      }
+      continue;
+    }
+    if (isPlainObject(current)) {
+      for (const v of Object.values(current)) {
+        stack.push(v);
+      }
+      continue;
+    }
+    return false;
+  }
+  return true;
 }
 
 export { isPlainObject, isValidMessages };

package/dist/vue/src/core/messages/utils/nest-object-from-path.js

@@ -1,21 +1,9 @@
-/**
- * Wraps a value inside nested objects according to a given path.
- *
- * @example
- * ```ts
- * const value = { a: "A" };
- *
- * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
- *
- * nestObjectFromPath([], value); // →  { a: "A" }
- * ```
- */
 function nestObjectFromPath(path, value) {
-    let obj = value;
-    for (let i = path.length - 1; i >= 0; i--) {
-        obj = { [path[i]]: obj };
-    }
-    return obj;
+  let obj = value;
+  for (let i = path.length - 1; i >= 0; i--) {
+    obj = { [path[i]]: obj };
+  }
+  return obj;
 }
 
 export { nestObjectFromPath };

package/dist/vue/src/core/utils/deep-merge.js

@@ -1,47 +1,29 @@
-/**
- * Deeply merges two plain objects.
- *
- * - Nested plain objects → merged recursively
- * - Arrays / primitives → `b` overwrites `a`
- *
- * Debug behavior (optional):
- * - Emits override events via `onOverride`
- * - Zero overhead when no options are provided
- *
- * This function always returns a new plain object.
- */
 const deepMerge = (a = {}, b = {}, options) => {
-    const result = { ...a };
-    const basePath = options?._path ?? [];
-    // Iterate only over b's own enumerable properties
-    for (const key in b) {
-        if (!Object.prototype.hasOwnProperty.call(b, key))
-            continue;
-        const aValue = a[key];
-        const bValue = b[key];
-        const nextPath = [...basePath, key];
-        // Recursively merge when both sides are plain objects
-        if (aValue &&
-            bValue &&
-            typeof aValue === "object" &&
-            typeof bValue === "object" &&
-            !Array.isArray(aValue) &&
-            !Array.isArray(bValue)) {
-            result[key] = deepMerge(aValue, bValue, options ? { ...options, _path: nextPath } : undefined);
-        }
-        else {
-            // Emit override event only when debugging is enabled
-            const isAdd = aValue === undefined;
-            options?.onOverride?.({
-                path: nextPath.join("."),
-                prev: aValue,
-                next: bValue,
-                kind: isAdd ? "add" : "override",
-            });
-            result[key] = bValue;
-        }
+  const result = { ...a };
+  const basePath = options?._path ?? [];
+  for (const key in b) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) continue;
+    const aValue = a[key];
+    const bValue = b[key];
+    const nextPath = [...basePath, key];
+    if (aValue && bValue && typeof aValue === "object" && typeof bValue === "object" && !Array.isArray(aValue) && !Array.isArray(bValue)) {
+      result[key] = deepMerge(
+        aValue,
+        bValue,
+        options ? { ...options, _path: nextPath } : void 0
+      );
+    } else {
+      const isAdd = aValue === void 0;
+      options?.onOverride?.({
+        path: nextPath.join("."),
+        prev: aValue,
+        next: bValue,
+        kind: isAdd ? "add" : "override"
+      });
+      result[key] = bValue;
     }
-    return result;
+  }
+  return result;
 };
 
 export { deepMerge };

package/dist/vue/src/core/utils/resolve-loader-options.js

@@ -1,34 +1,11 @@
-/**
- * Resolve the effective message loader for a given runtime.
- *
- * Loader resolution follows an inheritance-based priority model:
- *
- * - client runtime:
- *   client.loader → server.loader → root loader
- *
- * - server runtime:
- *   server.loader → root loader
- *
- * This allows the client runtime to inherit server behavior
- * when no explicit client loader is provided.
- *
- * Notes:
- * - Static `messages` are intentionally NOT handled here.
- * - Returning `undefined` indicates that no loader is enabled
- *   for the given runtime.
- */
 const resolveLoaderOptions = (config, runtime) => {
-    // ------------------------------------------------
-    // runtime: client
-    // ------------------------------------------------
-    {
-        const client = config.client?.loader;
-        if (client) {
-            // Client loader is always remote by design
-            return { mode: "remote", ...client };
-        }
-        return config.server?.loader ?? config.loader;
+  {
+    const client = config.client?.loader;
+    if (client) {
+      return { mode: "remote", ...client };
     }
+    return config.server?.loader ?? config.loader;
+  }
 };
 
 export { resolveLoaderOptions };

package/dist/vue/src/policies/should-persist-on-first-visit.js

@@ -1,8 +1,5 @@
-/**
- * Allow locale persistence based on first-visit policy.
- */
 function shouldPersistOnFirstVisit(isFirstVisit, persistOnFirstVisit) {
-    return !isFirstVisit || persistOnFirstVisit;
+  return !isFirstVisit || persistOnFirstVisit;
 }
 
 export { shouldPersistOnFirstVisit };

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "intor",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "The i18n library for modern JavaScript",
-  "author": "Yiming Liao",
+  "author": {
+    "name": "Yiming Liao",
+    "email": "yimingliao.official@gmail.com",
+    "url": "https://github.com/yiming-liao"
+  },
   "homepage": "https://intor.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yiming-liao/intor"
+    "url": "https://github.com/yiming-liao/intor",
+    "directory": "packages/intor"
   },
   "bugs": {
     "url": "https://github.com/yiming-liao/intor/issues"
@@ -101,76 +106,59 @@
   ],
   "sideEffects": false,
   "engines": {
-    "node": ">=20"
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "logry": "2.1.6",
+    "p-limit": "7.2.0",
+    "intor-translator": "1.5.0"
+  },
+  "peerDependencies": {
+    "react": "^19",
+    "vue": "^3",
+    "svelte": "^5",
+    "next": "^16",
+    "@sveltejs/kit": "^2",
+    "hono": "^4",
+    "fastify": "^5",
+    "fastify-plugin": "^5"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "@sveltejs/kit": {
+      "optional": true
+    },
+    "hono": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    },
+    "fastify-plugin": {
+      "optional": true
+    }
   },
   "scripts": {
     "type": "tsc -p tsconfig.json --noEmit",
-    "lint": "eslint",
     "test": "vitest",
     "test:types": "tsx scripts/test-types.ts",
     "test:check": "tsx scripts/check-test-structure.ts",
-    "knip": "knip --config .config/knip.config.ts",
     "clean": "rm -rf dist",
     "build": "tsx scripts/build.ts",
     "build:types": "tsc -p tsconfig.build.json && tsc-alias tsconfig.build.json --outDir dist/types",
-    "build:release": "yarn clean && yarn build && yarn build:types && yarn api:build",
+    "build:release": "pnpm clean && pnpm build && pnpm build:types && pnpm api:build",
     "api:build": "tsx scripts/api-extractor/build.ts",
-    "api:check": "tsx scripts/api-extractor/check.ts",
-    "prepublishOnly": "yarn build:release"
-  },
-  "dependencies": {
-    "intor-translator": "^1.5.0",
-    "logry": "2.1.6",
-    "p-limit": "7.2.0"
-  },
-  "devDependencies": {
-    "@microsoft/api-extractor": "^7.57.6",
-    "@rollup/plugin-alias": "6.0.0",
-    "@rollup/plugin-typescript": "12.3.0",
-    "@rollup/pluginutils": "5.3.0",
-    "@sveltejs/kit": "2.50.1",
-    "@testing-library/dom": "10.4.1",
-    "@testing-library/jest-dom": "6.9.1",
-    "@testing-library/react": "16.3.1",
-    "@types/express": "5.0.6",
-    "@types/node": "24.10.1",
-    "@types/react": "19.0.0",
-    "@types/react-dom": "19.0.0",
-    "@vitejs/plugin-react": "5.1.2",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vue/test-utils": "^2.4.6",
-    "eslint": "9.39.2",
-    "eslint-config-prettier": "10.1.8",
-    "eslint-import-resolver-typescript": "4.4.4",
-    "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-prettier": "5.5.4",
-    "eslint-plugin-react": "7.37.5",
-    "eslint-plugin-react-hooks": "7.0.1",
-    "eslint-plugin-unicorn": "62.0.0",
-    "eslint-plugin-unused-imports": "4.1.4",
-    "fastify": "^5.7.4",
-    "fastify-plugin": "^5.1.0",
-    "hono": "^4.11.8",
-    "jsdom": "27.3.0",
-    "knip": "5.69.1",
-    "magic-string": "0.30.21",
-    "next": "16.0.3",
-    "prettier": "3.6.2",
-    "react": "19.0.0",
-    "react-dom": "19.0.0",
-    "remark": "15.0.1",
-    "remark-gfm": "4.0.1",
-    "rollup": "4.53.3",
-    "rollup-plugin-copy": "3.5.0",
-    "svelte": "5.46.1",
-    "tsc-alias": "1.8.16",
-    "tsd": "0.33.0",
-    "tsx": "^4.21.0",
-    "typescript": "5.8.3",
-    "typescript-eslint": "^8.56.1",
-    "vite": "7.3.0",
-    "vite-tsconfig-paths": "6.0.3",
-    "vitest": "4.0.16",
-    "vue": "3.5.26"
+    "api:check": "tsx scripts/api-extractor/check.ts"
   }
-}
+}

package/dist/next/src/core/constants/headers.js

@@ -1,8 +0,0 @@
-const INTOR_HEADERS = {
-    LOCALE: "x-intor-locale",
-    LOCALE_SOURCE: "x-intor-locale-source",
-    PATHNAME: "x-intor-pathname",
-    REDIRECTED: "x-intor-redirected",
-};
-
-export { INTOR_HEADERS };

package/dist/types/src/core/constants/headers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../../../src/core/constants/headers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC"}