intor 2.3.2 → 2.3.4

package/dist/src/shared/error/intor-error.d.ts

@@ -1,10 +1,10 @@
-type IntorErrorOptions = {
+interface IntorErrorOptions {
     message: string;
-    code?: string;
+    code?: IntorErrorCode;
     id?: string;
-};
+}
 export declare class IntorError extends Error {
-    readonly code?: string;
+    readonly code?: IntorErrorCode;
     readonly id?: string;
     constructor({ message, code, id }: IntorErrorOptions);
 }

package/dist/src/shared/types/generated.d.ts

@@ -0,0 +1,53 @@
+import type { PREFIX_PLACEHOLDER } from "../../shared/constants/prefix-placeholder";
+import type { LocaleMessages } from "intor-translator";
+/**
+ * ================================================
+ * Generated-aware type system for Intor.
+ *
+ * This module defines conditional and fallback types that adapt
+ * based on whether generated types are present.
+ * ================================================
+ */
+/**
+ * Internal sentinel key indicating that Intor generated types are present.
+ * - Used by conditional types to switch between fallback and generated modes.
+ * - Type-level only. Not for runtime or user-facing usage.
+ */
+export type INTOR_GENERATED_KEY = "__intor_generated__";
+/**
+ * Conditional type for generated types.
+ * - Uses key presence on `IntorGeneratedTypes` to detect generation.
+ */
+export type IfGen<Then, Else = never> = IntorGeneratedTypes extends {
+    [K in INTOR_GENERATED_KEY]: true;
+} ? Then : Else;
+/**
+ * Config keys provided by generated types.
+ * - Excludes internal sentinel
+ */
+type GeneratedConfigKeys = Exclude<keyof IntorGeneratedTypes, INTOR_GENERATED_KEY>;
+/**
+ * Union of all configuration keys.
+ * - Defaults to `string` if `IntorGeneratedTypes` does not exist.
+ */
+export type GenConfigKeys = IfGen<GeneratedConfigKeys, string>;
+/**
+ * Configuration shape for a given config key.
+ * - If `IntorGeneratedTypes` is not defined, falls back to default shape.
+ * Otherwise, picks `Locales` and `Messages` according to the key.
+ */
+export type GenConfig<CK extends GenConfigKeys> = IfGen<CK extends keyof IntorGeneratedTypes ? IntorGeneratedTypes[CK] extends {
+    Locales: infer L extends string;
+    Messages: Record<typeof PREFIX_PLACEHOLDER, infer M>;
+} ? {
+    Locales: L;
+    Messages: Record<L, M>;
+} : never : never, {
+    Locales: string;
+    Messages: LocaleMessages;
+}>;
+/** Extracts messages for a given config key */
+export type GenMessages<CK extends GenConfigKeys> = GenConfig<CK>["Messages"];
+/** Extracts locales for a given config key */
+export type GenLocale<CK extends GenConfigKeys> = GenConfig<CK>["Locales"];
+export {};

package/dist/src/shared/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { INTOR_GENERATED_KEY, GenConfigKeys, GenConfig, GenMessages, GenLocale, } from "./generated";
+export type { Key, TranslatorInstance, TranslatorInstanceClient, } from "./translator-instance";

package/dist/src/shared/types/routing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Locale resolution sources used by routing and config.
+ *
+ * - Represents resolved data sources, not detection strategies.
+ */
+export type RoutingLocaleSource = "path" | "host" | "query" | "cookie" | "detected";

package/dist/src/shared/types/{translator-instance.types.d.ts → translator-instance.d.ts}

@@ -1,33 +1,31 @@
-import type { IfGen } from "../../shared/types/generated.types";
+import type { IfGen } from "../../shared/types/generated";
 import { type Locale, type Replacement, type ScopedLeafKeys, type LocalizedLeafKeys, type LocaleMessages } from "intor-translator";
-/** Base properties shared by all translator instances. */
-export interface TranslatorBaseProps<M = unknown> {
-    /** `messages`: The message object containing all translations. */
-    messages: M;
-    /** Current locale in use. */
-    locale: Locale<M>;
-}
-/** Properties specific to client-side translator behavior. */
-export interface TranslatorClientProps<M = unknown> {
-    /** `isLoading`: Indicates whether translations are currently loading. */
-    isLoading: boolean;
-    /** `setLocale`: Function to update the current locale. */
-    setLocale: (locale: Locale<M>) => void;
-}
 /**
  * Conditional key type for TranslatorInstance.
+ *
  * - Resolves to `ScopedLeafKeys` if a pre-key `PK` is provided,
  * otherwise resolves to `LocalizedLeafKeys`.
  */
-type Key<M extends LocaleMessages, PK> = IfGen<PK extends string ? ScopedLeafKeys<M, PK> : LocalizedLeafKeys<M>, string>;
+export type Key<M extends LocaleMessages, PK> = IfGen<PK extends string ? ScopedLeafKeys<M, PK> : LocalizedLeafKeys<M>, string>;
 /**
  * Translator instance type.
- * Combines base props, client props, and core translation methods.
  */
 export type TranslatorInstance<M extends LocaleMessages, PK extends string | undefined = undefined> = {
+    /** `messages`: The message object containing all translations. */
+    messages: M;
+    /** Current locale in use. */
+    locale: Locale<M>;
     /** Check if a given key exists in the messages. */
     hasKey: (key?: Key<M, PK>, targetLocale?: Locale<M>) => boolean;
     /** Translate a given key into its string representation. */
     t: <Result = string>(key?: Key<M, PK>, replacements?: Replacement) => Result;
-} & TranslatorBaseProps<M> & TranslatorClientProps<M>;
-export {};
+};
+/**
+ * Translator instance type for client-side.
+ */
+export type TranslatorInstanceClient<M extends LocaleMessages, PK extends string | undefined = undefined> = TranslatorInstance<M, PK> & {
+    /** `isLoading`: Indicates whether translations are currently loading. */
+    isLoading: boolean;
+    /** `setLocale`: Function to update the current locale. */
+    setLocale: (locale: Locale<M>) => void;
+};

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

@@ -0,0 +1,8 @@
+type PlainObject = Record<string, unknown>;
+/**
+ * Deeply merges two objects.
+ * - Nested objects → merged recursively
+ * - Array / primitive → b overwrites a
+ */
+export declare const deepMerge: <T extends PlainObject, U extends PlainObject>(a?: T, b?: U) => (T & U) | T | U | undefined;
+export {};

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

@@ -0,0 +1,36 @@
+/**
+ * Deeply merges two objects.
+ * - Nested objects → merged recursively
+ * - Array / primitive → b overwrites a
+ */
+const deepMerge = (a, b) => {
+    if (!a && !b)
+        return undefined;
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const result = { ...a };
+    for (const key in b) {
+        if (Object.prototype.hasOwnProperty.call(b, key)) {
+            const av = a[key];
+            const bv = b[key];
+            if (av &&
+                bv &&
+                typeof av === "object" &&
+                typeof bv === "object" &&
+                !Array.isArray(av) &&
+                !Array.isArray(bv)) {
+                // recursive merge
+                result[key] = deepMerge(av, bv);
+            }
+            else {
+                // overwrite with primitive or array
+                result[key] = bv;
+            }
+        }
+    }
+    return result;
+};
+
+export { deepMerge };

package/dist/src/shared/utils/index.d.ts

@@ -1,8 +1,4 @@
-export { mergeMessages } from "./merge-messages";
-export { normalizeCacheKey } from "./normalize-cache-key";
-export { resolveNamespaces } from "./resolve-namespaces";
-export { normalizeLocale } from "./locale/normalize-locale";
-export { resolvePreferredLocale } from "./locale/resolve-preferred-locale";
-export { extractPathname } from "./pathname/extract-pathname";
-export { normalizePathname } from "./pathname/normalize-pathname";
-export { standardizePathname } from "./pathname/standardize-pathname";
+export { deepMerge } from "./deep-merge";
+export { normalizeCacheKey, normalizeLocale, normalizePathname, } from "./normalizers";
+export { getLocaleFromAcceptLanguage, getLocaleFromPathname, getLocaleFromHost, getLocaleFromQuery, } from "./locale";
+export { localizePathname } from "./pathname";

package/dist/src/shared/utils/is-external-destination.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines whether a navigation target should bypass app routing.
+ *
+ * Any value with an explicit scheme (e.g. http:, https:, mailto:)
+ * is treated as external navigation.
+ */
+export declare const isExternalDestination: (destination: string) => boolean;

package/dist/src/shared/utils/is-external-destination.js

@@ -0,0 +1,11 @@
+/**
+ * Determines whether a navigation target should bypass app routing.
+ *
+ * Any value with an explicit scheme (e.g. http:, https:, mailto:)
+ * is treated as external navigation.
+ */
+const isExternalDestination = (destination) => {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
+};
+
+export { isExternalDestination };

package/dist/src/shared/utils/locale/get-locale-from-accept-language.d.ts

@@ -0,0 +1,19 @@
+import type { IntorResolvedConfig } from "../../../config";
+/**
+ * Resolve locale from the `Accept-Language` header.
+ *
+ * - Parses language priorities (`q` values) from the header.
+ * - Selects the highest-priority language supported by the application.
+ * - Normalizes the matched locale against `supportedLocales`.
+ *
+ * If no supported locale can be resolved, `undefined` is returned.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
+ * // => "en-US"
+ * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
+ * // => undefined
+ * ```
+ */
+export declare const getLocaleFromAcceptLanguage: (config: IntorResolvedConfig, acceptLanguageHeader: string | undefined) => string | undefined;

package/dist/src/shared/utils/locale/get-locale-from-accept-language.js

@@ -0,0 +1,45 @@
+import { normalizeLocale } from '../normalizers/normalize-locale.js';
+
+/**
+ * Resolve locale from the `Accept-Language` header.
+ *
+ * - Parses language priorities (`q` values) from the header.
+ * - Selects the highest-priority language supported by the application.
+ * - Normalizes the matched locale against `supportedLocales`.
+ *
+ * If no supported locale can be resolved, `undefined` is returned.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
+ * // => "en-US"
+ * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
+ * // => undefined
+ * ```
+ */
+const getLocaleFromAcceptLanguage = (config, acceptLanguageHeader) => {
+    const { supportedLocales } = config;
+    if (!acceptLanguageHeader ||
+        !supportedLocales ||
+        supportedLocales.length === 0) {
+        return;
+    }
+    const supportedLocalesSet = new Set(supportedLocales);
+    // 1. Parse Accept-Language header into language + priority pairs
+    const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
+        const [rawLang, rawQ] = part.split(";");
+        const lang = rawLang.trim();
+        const q = rawQ ? Number.parseFloat(rawQ.split("=")[1]) : 1;
+        return {
+            lang,
+            q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
+        };
+    });
+    // 2. Sort by priority (highest first)
+    const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
+    // 3. Pick the first language explicitly supported
+    const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+    return normalizeLocale(preferred, supportedLocales);
+};
+
+export { getLocaleFromAcceptLanguage };

package/dist/src/shared/utils/locale/get-locale-from-host.d.ts

@@ -0,0 +1,17 @@
+import type { IntorResolvedConfig } from "../../../config";
+/**
+ * Extract locale from hostname.
+ *
+ * Only the left-most subdomain is considered as a locale candidate, if present.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromHost(config, "en.example.com")
+ * // => "en"
+ * getLocaleFromHost(config, "example.com")
+ * // => undefined
+ * getLocaleFromHost(config, "api.jp.example.com")
+ * // => undefined
+ * ```
+ */
+export declare function getLocaleFromHost(config: IntorResolvedConfig, host: string | undefined): string | undefined;

package/dist/src/shared/utils/locale/get-locale-from-host.js

@@ -0,0 +1,31 @@
+import { normalizeLocale } from '../normalizers/normalize-locale.js';
+
+/**
+ * Extract locale from hostname.
+ *
+ * Only the left-most subdomain is considered as a locale candidate, if present.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromHost(config, "en.example.com")
+ * // => "en"
+ * getLocaleFromHost(config, "example.com")
+ * // => undefined
+ * getLocaleFromHost(config, "api.jp.example.com")
+ * // => undefined
+ * ```
+ */
+function getLocaleFromHost(config, host) {
+    if (!host)
+        return;
+    const { supportedLocales } = config;
+    // Remove port (e.g. localhost:3000)
+    const hostname = host.split(":")[0];
+    const parts = hostname.split(".");
+    if (parts.length < 2)
+        return;
+    const candidate = parts[0];
+    return normalizeLocale(candidate, supportedLocales);
+}
+
+export { getLocaleFromHost };

package/dist/src/shared/utils/locale/get-locale-from-pathname.d.ts

@@ -0,0 +1,31 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+/**
+ * Extracts the locale from a pathname, if present.
+ *
+ * - Normalizes the raw pathname.
+ * - Strips the configured basePath.
+ * - Inspects the first path segment to determine whether
+ *   it matches a supported locale.
+ *
+ * If no locale segment is found, `undefined` is returned.
+ *
+ * Note:
+ * - The pathname is treated as a canonical source.
+ * - Only exact matches against `supportedLocales` are accepted.
+ * - ___Locale normalization is intentionally not applied here.___
+ *
+ * @example
+ * ```ts
+ * getLocaleFromPathname(config, "/en/about")
+ * // => "en"
+ * getLocaleFromPathname(config, "/zh-TW")
+ * // => "zh-TW"
+ * getLocaleFromPathname(config, "/about")
+ * // => undefined
+ *
+ * // config.routing.basePath: "/app"
+ * getLocaleFromPathname(config, "/app/en/dashboard")
+ * // => "en"
+ * ```
+ */
+export declare function getLocaleFromPathname(config: IntorResolvedConfig, pathname: string): string | undefined;

package/dist/src/shared/utils/locale/get-locale-from-pathname.js

@@ -0,0 +1,52 @@
+import { normalizePathname } from '../normalizers/normalize-pathname.js';
+
+/**
+ * Extracts the locale from a pathname, if present.
+ *
+ * - Normalizes the raw pathname.
+ * - Strips the configured basePath.
+ * - Inspects the first path segment to determine whether
+ *   it matches a supported locale.
+ *
+ * If no locale segment is found, `undefined` is returned.
+ *
+ * Note:
+ * - The pathname is treated as a canonical source.
+ * - Only exact matches against `supportedLocales` are accepted.
+ * - ___Locale normalization is intentionally not applied here.___
+ *
+ * @example
+ * ```ts
+ * getLocaleFromPathname(config, "/en/about")
+ * // => "en"
+ * getLocaleFromPathname(config, "/zh-TW")
+ * // => "zh-TW"
+ * getLocaleFromPathname(config, "/about")
+ * // => undefined
+ *
+ * // config.routing.basePath: "/app"
+ * getLocaleFromPathname(config, "/app/en/dashboard")
+ * // => "en"
+ * ```
+ */
+function getLocaleFromPathname(config, pathname) {
+    const { routing, supportedLocales } = config;
+    const { basePath } = routing;
+    // 1. Normalize pathname
+    const normalizedPathname = normalizePathname(pathname);
+    // 2. Strip basePath
+    let prefixedPathname = normalizedPathname;
+    if (basePath && normalizedPathname === basePath) {
+        prefixedPathname = "/";
+    }
+    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+        prefixedPathname = normalizedPathname.slice(basePath.length);
+    }
+    // 3. Detect locale segment
+    const firstSegment = prefixedPathname.split("/").find(Boolean);
+    return firstSegment && supportedLocales.includes(firstSegment)
+        ? firstSegment
+        : undefined;
+}
+
+export { getLocaleFromPathname };

package/dist/src/shared/utils/locale/get-locale-from-query.d.ts

@@ -0,0 +1,20 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+/**
+ * Extracts locale from URL query parameters.
+ *
+ * - Reads the configured locale query key.
+ * - Normalizes the value against supported locales.
+ *
+ * If no valid locale is found, `undefined` is returned.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromQuery(config, { locale: "en" })
+ * // => "en"
+ * getLocaleFromQuery(config, {})
+ * // => undefined
+ * getLocaleFromQuery(config, { locale: ["zh-TW"] })
+ * // => "zh-TW"
+ * ```
+ */
+export declare function getLocaleFromQuery(config: IntorResolvedConfig, query: Record<string, string | string[] | undefined> | undefined): string | undefined;

package/dist/src/shared/utils/locale/get-locale-from-query.js

@@ -0,0 +1,33 @@
+import { normalizeLocale } from '../normalizers/normalize-locale.js';
+
+/**
+ * Extracts locale from URL query parameters.
+ *
+ * - Reads the configured locale query key.
+ * - Normalizes the value against supported locales.
+ *
+ * If no valid locale is found, `undefined` is returned.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromQuery(config, { locale: "en" })
+ * // => "en"
+ * getLocaleFromQuery(config, {})
+ * // => undefined
+ * getLocaleFromQuery(config, { locale: ["zh-TW"] })
+ * // => "zh-TW"
+ * ```
+ */
+function getLocaleFromQuery(config, query) {
+    if (!query)
+        return;
+    const { supportedLocales, routing } = config;
+    const key = routing.locale.queryKey ?? "locale";
+    const raw = query[key];
+    if (!raw)
+        return;
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    return normalizeLocale(value, supportedLocales);
+}
+
+export { getLocaleFromQuery };

package/dist/src/shared/utils/locale/index.d.ts

@@ -0,0 +1,4 @@
+export { getLocaleFromAcceptLanguage } from "./get-locale-from-accept-language";
+export { getLocaleFromPathname } from "./get-locale-from-pathname";
+export { getLocaleFromHost } from "./get-locale-from-host";
+export { getLocaleFromQuery } from "./get-locale-from-query";

package/dist/src/shared/utils/normalizers/index.d.ts

@@ -0,0 +1,3 @@
+export { normalizeCacheKey } from "./normalize-cache-key";
+export { normalizePathname } from "./normalize-pathname";
+export { normalizeLocale } from "./normalize-locale";

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

@@ -0,0 +1,14 @@
+type RawCacheKey = string | boolean | Array<string | number | boolean | undefined | null>;
+/**
+ * Normalizes a value into a stable cache key string.
+ *
+ * - Supports primitive values and structured array keys.
+ * - Produces deterministic output suitable for cache identifiers.
+ *
+ * Notes:
+ * - `null`, `undefined`, or empty arrays return `null`.
+ * - Special tokens are used for boolean, null, and undefined values
+ *   to preserve semantic differences.
+ */
+export declare const normalizeCacheKey: (key?: RawCacheKey, delimiter?: string) => string | null;
+export {};

package/dist/src/shared/utils/{normalize-cache-key.js → normalizers/normalize-cache-key.js}

@@ -1,16 +1,29 @@
 const CACHE_KEY_DELIMITER = "|";
-// Helper FC
 const sanitize = (k) => k
     .replaceAll(/[\u200B-\u200D\uFEFF]/g, "")
     .replaceAll(/[\r\n]/g, "")
     .trim();
+/**
+ * Normalizes a value into a stable cache key string.
+ *
+ * - Supports primitive values and structured array keys.
+ * - Produces deterministic output suitable for cache identifiers.
+ *
+ * Notes:
+ * - `null`, `undefined`, or empty arrays return `null`.
+ * - Special tokens are used for boolean, null, and undefined values
+ *   to preserve semantic differences.
+ */
 const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+    // Treat nullish values as "no cache key"
     if (key === null || key === undefined)
         return null;
     if (Array.isArray(key)) {
+        // Empty array produces no meaningful cache key
         if (key.length === 0)
             return null;
         const normalized = key.map((k) => {
+            // Preserve semantic differences for special values
             if (k === null)
                 return "__null";
             if (k === undefined)
@@ -19,10 +32,13 @@ const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
                 return k ? "__true" : "__false";
             return sanitize(String(k));
         });
+        // Join segments into a single deterministic cache key
         return normalized.join(delimiter);
     }
+    // Normalize boolean primitives explicitly
     if (typeof key === "boolean")
         return key ? "__true" : "__false";
+    // Fallback: stringify primitive values
     return String(key);
 };
 

package/dist/src/shared/utils/normalizers/normalize-locale.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Normalizes a locale string and resolves the best match
+ * from a list of supported locales.
+ *
+ * Resolution strategy:
+ *
+ * 1. Exact canonical match (BCP 47)
+ * 2. Base language fallback
+ *    - Falls back by base language when no exact match is found
+ *      (e.g. `"en"` → `"en-US"`).
+ *    - Script and region subtags are ignored during this step
+ *      (e.g. `"zh-Hans"` → `"zh-Hant-TW"`)
+ *    - Preference is determined by the order of `supportedLocales`.
+ *
+ * Returns `undefined` if no suitable match is found.
+ *
+ * Notes:
+ * - Invalid locale inputs are ignored gracefully.
+ * - Always returns an original entry from `supportedLocales`.
+ * - Requires `Intl` locale support in the runtime.
+ */
+export declare const normalizeLocale: <Locale extends string>(locale: string | undefined, supportedLocales?: readonly Locale[]) => Locale | undefined;

package/dist/src/shared/utils/{locale → normalizers}/normalize-locale.js

@@ -1,16 +1,33 @@
-// Util
 const toCanonical = (input) => {
     try {
-        return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
+        return Intl.getCanonicalLocales(input)[0];
     }
     catch {
         return;
     }
 };
 /**
- * Normalizes and finds the best matching locale from the supported locales list.
+ * Normalizes a locale string and resolves the best match
+ * from a list of supported locales.
+ *
+ * Resolution strategy:
+ *
+ * 1. Exact canonical match (BCP 47)
+ * 2. Base language fallback
+ *    - Falls back by base language when no exact match is found
+ *      (e.g. `"en"` → `"en-US"`).
+ *    - Script and region subtags are ignored during this step
+ *      (e.g. `"zh-Hans"` → `"zh-Hant-TW"`)
+ *    - Preference is determined by the order of `supportedLocales`.
+ *
+ * Returns `undefined` if no suitable match is found.
+ *
+ * Notes:
+ * - Invalid locale inputs are ignored gracefully.
+ * - Always returns an original entry from `supportedLocales`.
+ * - Requires `Intl` locale support in the runtime.
  */
-const normalizeLocale = (locale = "", supportedLocales = []) => {
+const normalizeLocale = (locale, supportedLocales = []) => {
     if (!locale || supportedLocales.length === 0)
         return;
     const canonicalLocale = toCanonical(locale);

package/dist/src/shared/utils/{pathname → normalizers}/normalize-pathname.d.ts

@@ -3,7 +3,7 @@
  *
  * - Trims leading and trailing whitespace (code points ≤ 32).
  * - Collapses consecutive slashes into a single slash.
- * - Ensures a leading slash and removes trailing slashes.
+ * - Ensures a single leading slash and removes redundant trailing slashes.
  * - Optionally removes the leading slash.
  * - Avoids intermediate array allocations for performance.
  */

package/dist/src/shared/utils/{pathname → normalizers}/normalize-pathname.js

@@ -3,7 +3,7 @@
  *
  * - Trims leading and trailing whitespace (code points ≤ 32).
  * - Collapses consecutive slashes into a single slash.
- * - Ensures a leading slash and removes trailing slashes.
+ * - Ensures a single leading slash and removes redundant trailing slashes.
  * - Optionally removes the leading slash.
  * - Avoids intermediate array allocations for performance.
  */

package/dist/src/shared/utils/pathname/get-unprefixed-pathname.d.ts

@@ -0,0 +1,14 @@
+import type { IntorResolvedConfig } from "../../../config/types/intor-config.types";
+/**
+ * Returns a canonical, locale-agnostic pathname.
+ *
+ * @example
+ * ```ts
+ * // config.supportedLocales: ["en-US"]
+ * // config.routing.basePath: "/app"
+ * // config.routing.prefix: "all"
+ * getUnprefixedPathname(config, "/app/en-US/about" );
+ * // => "/about"
+ *```
+ */
+export declare function getUnprefixedPathname(config: IntorResolvedConfig, rawPathname: string): string;