intor 2.4.17 → 2.5.1

package/dist/svelte-kit/src/routing/inbound/resolve-pathname/strategies/except-default.js

@@ -0,0 +1,16 @@
+function exceptDefault(config, context) {
+  const { hasPathLocale, hasPersisted} = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  const isDefaultLocale = context.locale === config.defaultLocale;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (isFirstVisit) {
+    if (!redirect) return { type: "pass" };
+    return isDefaultLocale ? { type: "pass" } : { type: "redirect" };
+  }
+  return isDefaultLocale ? { type: "pass" } : { type: "redirect" };
+}
+
+export { exceptDefault };

package/dist/svelte-kit/src/routing/inbound/resolve-pathname/strategies/none.js

@@ -0,0 +1,5 @@
+function none() {
+  return { type: "pass" };
+}
+
+export { none };

package/dist/svelte-kit/src/routing/locale/get-locale-from-accept-language.js

@@ -1,38 +1,25 @@
-/**
- * Get locale candidate from the `Accept-Language` header.
- *
- * Parses language priorities and returns the highest-priority
- * language present in `supportedLocales`, without normalization.
- *
- * @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 = (acceptLanguageHeader, supportedLocales) => {
-    if (!acceptLanguageHeader || 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 preferred;
+  if (!acceptLanguageHeader || supportedLocales.length === 0) {
+    return;
+  }
+  const supportedLocalesSet = new Set(supportedLocales);
+  const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
+    const segments = part.split(";");
+    const rawLang = segments[0];
+    const rawQ = segments[1];
+    const lang = rawLang.trim();
+    const q = rawQ !== void 0 ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
+    return {
+      lang,
+      q: Number.isNaN(q) ? 0 : q
+      // Invalid q values have lowest priority
+    };
+  });
+  const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
+  const preferred = sortedByPriority.find(
+    ({ lang }) => supportedLocalesSet.has(lang)
+  )?.lang;
+  return preferred;
 };
 
 export { getLocaleFromAcceptLanguage };

package/dist/svelte-kit/src/routing/locale/get-locale-from-host.js

@@ -1,32 +1,9 @@
-/**
- * Get locale candidate from hostname.
- *
- * Returns the left-most hostname label, without validation or normalization.
- *
- * @example
- * ```ts
- * getLocaleFromHost("en.example.com")
- * // => "en"
- *
- * getLocaleFromHost("example.com")
- * // => "example"
- *
- * getLocaleFromHost("api.jp.example.com")
- * // => "api"
- *
- * getLocaleFromHost("localhost")
- * // => undefined
- * ```
- */
 function getLocaleFromHost(host) {
-    if (!host)
-        return;
-    // Remove port (e.g. localhost:3000)
-    const hostname = host.split(":")[0];
-    const parts = hostname.split(".");
-    if (parts.length < 2)
-        return;
-    return parts[0];
+  if (!host) return;
+  const hostname = host.split(":")[0];
+  const parts = hostname.split(".");
+  if (parts.length < 2) return;
+  return parts[0];
 }
 
 export { getLocaleFromHost };

package/dist/svelte-kit/src/routing/locale/get-locale-from-pathname.js

@@ -1,47 +1,20 @@
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Get locale from pathname.
- *
- * Extracts the first pathname segment (after basePath) as a locale
- * if it exactly matches one of the supported locales.
- *
- * @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(pathname, config) {
-    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;
+  const { routing, supportedLocales } = config;
+  const { basePath } = routing;
+  const normalizedPathname = normalizePathname(pathname);
+  let prefixedPathname = normalizedPathname;
+  if (basePath && normalizedPathname === basePath) {
+    prefixedPathname = "/";
+  } else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+    prefixedPathname = normalizedPathname.slice(basePath.length);
+  }
+  const firstSegment = prefixedPathname.split("/").find(Boolean);
+  return firstSegment && supportedLocales.includes(firstSegment) ? firstSegment : void 0;
 }
 
 export { getLocaleFromPathname };

package/dist/svelte-kit/src/routing/locale/get-locale-from-query.js

@@ -1,21 +1,6 @@
-/**
- * Get locale candidate from URL query parameters.
- *
- * Extracts the value of the configured query key, without
- * validation or normalization.
- *
- * @example
- * ```ts
- * getLocaleFromQuery({ locale: "en" }, "locale")
- * // => "en"
- *
- * getLocaleFromQuery({}, "locale")
- * // => undefined
- */
 function getLocaleFromQuery(query, queryKey) {
-    if (!query)
-        return;
-    return query[queryKey];
+  if (!query) return;
+  return query[queryKey];
 }
 
 export { getLocaleFromQuery };

package/dist/svelte-kit/src/routing/outbound/decide-strategy.js

@@ -1,14 +1,14 @@
 import { shouldFullReload } from '../../policies/shoud-full-reload.js';
 
-/**
- * Decide how a resolved navigation target should be executed.
- */
-function decideStrategy(config, target) {
-    // External destinations are always handled by the browser
-    if (target.isExternal) {
-        return "external";
-    }
-    return shouldFullReload(config) ? "reload" : "client";
+function decideStrategy(config, target, currentLocale) {
+  if (target.isExternal) {
+    return "external";
+  }
+  const isLocaleChange = target.locale !== currentLocale;
+  if (isLocaleChange && shouldFullReload(config)) {
+    return "reload";
+  }
+  return "client";
 }
 
 export { decideStrategy };

package/dist/svelte-kit/src/routing/outbound/determine-target.js

@@ -4,52 +4,36 @@ import { deriveHostDestination } from './utils/derive-host-destination.js';
 import { deriveQueryDestination } from './utils/derive-query-destination.js';
 import { isExternalDestination } from './utils/is-external-destination.js';
 
-/**
- * Determines the outbound routing target.
- */
 function determineTarget(config, currentLocale, currentPathname, intent) {
-    const { supportedLocales, routing } = config;
-    // ----------------------------------------------------------------
-    // Resolve effective locale
-    // ----------------------------------------------------------------
-    const locale = intent?.locale && supportedLocales.includes(intent?.locale)
-        ? intent?.locale
-        : currentLocale;
-    // ----------------------------------------------------------------
-    // Resolve raw destination and external flag
-    // ----------------------------------------------------------------
-    // Use the unprefixed logical path as the navigation base.
-    // Locale prefixes are applied later by inbound canonicalization.
-    const rawDestination = intent?.destination ?? canonicalizePathname(currentPathname, config);
-    const isExternal = isExternalDestination(rawDestination);
-    // ----------------------------------------------------------------
-    // Project destination by navigation carrier
-    // ----------------------------------------------------------------
-    let destination = rawDestination;
-    if (!isExternal) {
-        switch (routing.outbound.localeCarrier) {
-            case "path": {
-                destination = localizePathname(rawDestination, config, locale).pathname;
-                break;
-            }
-            case "host": {
-                destination = deriveHostDestination(rawDestination, config, locale);
-                break;
-            }
-            case "query": {
-                destination = deriveQueryDestination(rawDestination, config, locale);
-                break;
-            }
-            default: {
-                destination = rawDestination;
-            }
-        }
+  const { supportedLocales, routing } = config;
+  const locale = intent?.locale && supportedLocales.includes(intent?.locale) ? intent?.locale : currentLocale;
+  const rawDestination = intent?.destination ?? canonicalizePathname(currentPathname, config);
+  const isExternal = isExternalDestination(rawDestination);
+  let destination = rawDestination;
+  if (!isExternal) {
+    switch (routing.outbound.localeCarrier) {
+      case "path": {
+        destination = localizePathname(rawDestination, config, locale).pathname;
+        break;
+      }
+      case "host": {
+        destination = deriveHostDestination(rawDestination, config, locale);
+        break;
+      }
+      case "query": {
+        destination = deriveQueryDestination(rawDestination, config, locale);
+        break;
+      }
+      default: {
+        destination = rawDestination;
+      }
     }
-    return {
-        locale,
-        destination,
-        isExternal,
-    };
+  }
+  return {
+    locale,
+    destination,
+    isExternal
+  };
 }
 
 export { determineTarget };

package/dist/svelte-kit/src/routing/outbound/resolve-outbound.js

@@ -1,23 +1,19 @@
 import { decideStrategy } from './decide-strategy.js';
 import { determineTarget } from './determine-target.js';
 
-/**
- * Resolve an outbound routing attempt into an executable result.
- */
 function resolveOutbound(config, currentLocale, currentPathname, intent) {
-    // --------------------------------------------------
-    // Determine outbound target
-    // --------------------------------------------------
-    const target = determineTarget(config, currentLocale, currentPathname, intent);
-    // --------------------------------------------------
-    // Decide outbound strategy
-    // --------------------------------------------------
-    const strategy = decideStrategy(config, target);
-    return {
-        locale: target.locale,
-        destination: target.destination,
-        kind: strategy,
-    };
+  const target = determineTarget(
+    config,
+    currentLocale,
+    currentPathname,
+    intent
+  );
+  const strategy = decideStrategy(config, target, currentLocale);
+  return {
+    locale: target.locale,
+    destination: target.destination,
+    kind: strategy
+  };
 }
 
 export { resolveOutbound };

package/dist/svelte-kit/src/routing/outbound/utils/derive-host-destination.js

@@ -1,13 +1,9 @@
-/**
- * Derives a locale-specific destination using host-based navigation.
- */
 const deriveHostDestination = (rawDestination, config, locale) => {
-    const { host } = config.routing.outbound;
-    const resolvedHost = host.map[locale] ?? host.default;
-    if (!resolvedHost)
-        return rawDestination;
-    const url = new URL(rawDestination, "http://internal");
-    return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
+  const { host } = config.routing.outbound;
+  const resolvedHost = host.map[locale] ?? host.default;
+  if (!resolvedHost) return rawDestination;
+  const url = new URL(rawDestination, "http://localhost");
+  return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
 };
 
 export { deriveHostDestination };

package/dist/svelte-kit/src/routing/outbound/utils/derive-query-destination.js

@@ -1,11 +1,8 @@
-/**
- *  Derives a locale-specific destination using query-based navigation.
- */
 const deriveQueryDestination = (rawDestination, config, locale) => {
-    const { queryKey } = config.routing.outbound;
-    const url = new URL(rawDestination, "http://internal");
-    url.searchParams.set(queryKey, locale);
-    return `${url.pathname}${url.search}`;
+  const { queryKey } = config.routing.outbound;
+  const url = new URL(rawDestination, "http://localhost");
+  url.searchParams.set(queryKey, locale);
+  return `${url.pathname}${url.search}`;
 };
 
 export { deriveQueryDestination };

package/dist/svelte-kit/src/routing/outbound/utils/is-external-destination.js

@@ -1,11 +1,5 @@
-/**
- * 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);
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
 };
 
 export { isExternalDestination };

package/dist/svelte-kit/src/routing/pathname/canonicalize-pathname.js

@@ -1,47 +1,36 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Returns a canonical, locale-agnostic pathname.
- *
- * Accepts `{locale}` as a locale placeholder segment.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/about", config);
- * // => "/about"
- *```
- */
 function canonicalizePathname(rawPathname, config) {
-    const { routing, supportedLocales } = config;
-    const { basePath } = routing;
-    const normalizedPathname = normalizePathname(rawPathname);
-    // Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
+  const { routing, supportedLocales } = config;
+  const normalizedPathname = normalizePathname(rawPathname);
+  const basePath = routing.basePath === "/" ? "" : routing.basePath;
+  let path = normalizedPathname;
+  if (basePath) {
+    if (path === basePath) {
+      path = "/";
+    } else if (path.startsWith(basePath + "/")) {
+      path = path.slice(basePath.length);
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
-    }
-    // Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment === LOCALE_PLACEHOLDER
-        ? LOCALE_PLACEHOLDER
-        : firstSegment && supportedLocales.includes(firstSegment)
-            ? firstSegment
-            : undefined;
-    // Strip locale segment
-    return locale
-        ? prefixedPathname.slice(locale.length + 1) || "/"
-        : prefixedPathname;
+  }
+  if (path === "/") return "/";
+  const segmentStart = 1;
+  const nextSlash = path.indexOf("/", segmentStart);
+  const firstSegment = nextSlash === -1 ? path.slice(segmentStart) : path.slice(segmentStart, nextSlash);
+  let localeLength;
+  if (firstSegment === LOCALE_PLACEHOLDER) {
+    localeLength = firstSegment.length;
+  } else if (supportedLocales.includes(firstSegment)) {
+    localeLength = firstSegment.length;
+  }
+  if (localeLength !== void 0) {
+    const stripped = path.slice(localeLength + 1);
+    return stripped || "/";
+  }
+  return path;
 }
 
 export { canonicalizePathname };

package/dist/svelte-kit/src/routing/pathname/localize-pathname.js

@@ -2,35 +2,19 @@ import { canonicalizePathname } from './canonicalize-pathname.js';
 import { materializePathname } from './materialize-pathname.js';
 import { standardizePathname } from './standardize-pathname.js';
 
-/**
- * Localizes a pathname by composing canonicalization,
- * standardization, and locale prefix strategies.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * localizePathname("/app/en-US/about", config, "en-US");
- * // => {
- * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
-    return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
-    };
+  const canonicalPathname = canonicalizePathname(rawPathname, config);
+  const standardizedPathname = standardizePathname(canonicalPathname, config);
+  const materializedPathname = materializePathname(
+    standardizedPathname,
+    config,
+    locale
+  );
+  return {
+    canonicalPathname,
+    templatedPathname: standardizedPathname,
+    pathname: materializedPathname
+  };
 };
 
 export { localizePathname };

package/dist/svelte-kit/src/routing/pathname/materialize-pathname.js

@@ -1,42 +1,18 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Materializes a standardized pathname by applying
- * the configured locale prefix behavior.
- *
- * @example
- * ```ts
- * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/about
- * ```
- */
 const materializePathname = (standardizedPathname, config, locale) => {
-    const { localePrefix } = config.routing;
-    if (localePrefix !== "none" && !locale) {
-        throw new Error('No locale when using localePrefix "all", "except-default"');
-    }
-    // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "except-default"
-    if (localePrefix === "except-default") {
-        return locale === config.defaultLocale
-            ? normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""))
-            : normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "none"
-    return normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""));
+  const { localePrefix } = config.routing;
+  const removeLocale = () => {
+    const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+    return result === "" ? "/" : result;
+  };
+  const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+  if (localePrefix === "none") return removeLocale();
+  if (localePrefix === "all") return injectLocale();
+  return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };

package/dist/svelte-kit/src/routing/pathname/standardize-pathname.js

@@ -1,34 +1,15 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
- *
- * @example
- * ```ts
- * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+  const { routing } = config;
+  const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+  if (canonicalPathname === "/") {
+    return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}` : `/${LOCALE_PLACEHOLDER}`;
+  }
+  return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}` : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

package/dist/types/export/edge/index.d.ts

@@ -1,2 +1,3 @@
-export { getTranslator } from "../../src/edge";
-export { resolveInboundFromRequest } from "../../src/routing";
+export * from "../shared-types";
+export { getTranslator, type GetTranslatorParams, } from "../../src/edge";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/edge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/edge/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAEL,aAAa,EACb,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC"}

package/dist/types/export/express/index.d.ts

@@ -1 +1,4 @@
+export * from "../shared-types";
 export { createIntorHandler, getTranslator } from "../../src/adapters/express";
+export type { GetTranslatorParams } from "../../src/server";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/export/express/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../export/express/index.ts"],"names":[],"mappings":"AAEA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}