intor 2.4.14 → 2.4.16

package/dist/core/export/index.js

@@ -1,10 +1,11 @@
 export { LOCALE_PLACEHOLDER } from '../src/core/constants/locale-placeholder.js';
 export { IntorError, IntorErrorCode } from '../src/core/error/intor-error.js';
+export { matchLocale } from '../src/core/locale/match-locale.js';
 import 'logry';
 export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 import 'p-limit';
 export { mergeMessages } from '../src/core/messages/merge-messages.js';
-import 'intor-translator';
+export { Translator } from 'intor-translator';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
 export { localizePathname } from '../src/routing/pathname/localize-pathname.js';

package/dist/core/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/core/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/core/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/core/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/express/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/express/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/express/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/express/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/fastify/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/fastify/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/fastify/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/fastify/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/hono/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/hono/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/hono/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/hono/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/next/src/adapters/next/server/get-locale.js

@@ -1,7 +1,7 @@
 import { headers, cookies } from 'next/headers';
 import { INTOR_HEADERS } from '../../../core/constants/headers.js';
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -23,9 +23,9 @@ const getLocale = async (config) => {
     const cookieStore = await cookies();
     const cookieLocale = cookieStore.get(config.cookie.name)?.value;
     if (cookieLocale) {
-        const resolved = normalizeLocale(cookieLocale, config.supportedLocales);
-        if (resolved)
-            return resolved;
+        const matched = matchLocale(cookieLocale, config.supportedLocales);
+        if (matched)
+            return matched;
     }
     // Explicit default
     return config.defaultLocale;

package/dist/next/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/next/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };