intor 2.2.13 → 2.2.15

package/dist/next/middleware/index.js

@@ -1,384 +0,0 @@
-import { NextResponse } from 'next/server';
-import { headers } from 'next/headers';
-
-// src/adapters/next/middleware/utils/create-response.ts
-
-// src/adapters/next/middleware/utils/set-locale-cookie-edge.ts
-function setLocaleCookieEdge({
-  request,
-  response,
-  cookie,
-  locale,
-  override = false
-  // Default to not override existed cookie
-}) {
-  if (!cookie.enabled || !cookie.autoSetCookie) return;
-  const isCookieExists = request.cookies.has(cookie.name);
-  if (isCookieExists && !override) return;
-  response.cookies.set(cookie.name, locale, {
-    maxAge: cookie.maxAge,
-    path: cookie.path,
-    ...cookie.domain ? { domain: cookie.domain } : {},
-    secure: cookie.secure,
-    httpOnly: cookie.httpOnly,
-    sameSite: cookie.sameSite
-  });
-}
-
-// src/adapters/next/shared/constants/pathname-header-name.ts
-var PATHNAME_HEADER_NAME = "x-intor-pathname";
-
-// src/adapters/next/middleware/utils/set-pathname-header.ts
-var setPathnameHeader = ({
-  request,
-  response,
-  key = PATHNAME_HEADER_NAME
-}) => {
-  const pathname = request.nextUrl.pathname;
-  response.headers.set(key, pathname);
-  return response;
-};
-
-// src/shared/constants/prefix-placeholder.ts
-var PREFIX_PLACEHOLDER = "{locale}";
-
-// src/shared/utils/locale/normalize-locale.ts
-var toCanonical = (input) => {
-  try {
-    return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
-  } catch {
-    return;
-  }
-};
-var normalizeLocale = (locale = "", supportedLocales = []) => {
-  if (!locale || supportedLocales.length === 0) return;
-  const canonicalLocale = toCanonical(locale);
-  if (!canonicalLocale) return;
-  const supportedCanonicalMap = /* @__PURE__ */ new Map();
-  for (const l of supportedLocales) {
-    const normalized = toCanonical(l);
-    if (normalized) {
-      supportedCanonicalMap.set(normalized, l);
-    }
-  }
-  if (supportedCanonicalMap.has(canonicalLocale)) {
-    return supportedCanonicalMap.get(canonicalLocale);
-  }
-  const baseLang = canonicalLocale.split("-")[0];
-  for (const [key, original] of supportedCanonicalMap) {
-    const supportedBase = key.split("-")[0];
-    if (supportedBase === baseLang) {
-      return original;
-    }
-  }
-  return;
-};
-
-// src/shared/utils/locale/resolve-preferred-locale.ts
-var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
-  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
-    return;
-  }
-  const supportedLocalesSet = new Set(supportedLocales);
-  const preferred = acceptLanguageHeader.split(",").map((part) => {
-    const [lang, qValue] = part.split(";");
-    const q = qValue ? Number.parseFloat(qValue.split("=")[1]) : 1;
-    if (Number.isNaN(q)) {
-      return { lang: lang.trim(), q: 0 };
-    }
-    return { lang: lang.trim(), q };
-  }).toSorted((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-  return preferred;
-};
-
-// src/shared/utils/pathname/normalize-pathname.ts
-var normalizePathname = (rawPathname, options = {}) => {
-  const length = rawPathname.length;
-  let start = 0;
-  let end = length - 1;
-  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
-  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
-  if (start > end) return "/";
-  let result = "";
-  let hasSlash = false;
-  for (let i = start; i <= end; i++) {
-    const char = rawPathname[i];
-    if (char === "/") {
-      if (!hasSlash) {
-        hasSlash = true;
-      }
-    } else {
-      result += hasSlash || result === "" ? "/" + char : char;
-      hasSlash = false;
-    }
-  }
-  if (options.removeLeadingSlash && result.startsWith("/")) {
-    result = result.slice(1);
-  }
-  return result || "/";
-};
-
-// src/shared/utils/pathname/extract-pathname.ts
-var extractPathname = ({
-  config,
-  pathname: rawPathname
-}) => {
-  const { routing, defaultLocale } = config;
-  const { basePath, prefix } = routing;
-  const normalizedPathname = normalizePathname(rawPathname);
-  let prefixedPathname = normalizedPathname;
-  if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-    prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
-  } else if (basePath && normalizedPathname === basePath) {
-    prefixedPathname = "/";
-  }
-  const pathPart = prefixedPathname.split("/").find(Boolean);
-  const maybeLocale = pathPart || "";
-  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
-  let unprefixedPathname = prefixedPathname;
-  if (prefix === "all") {
-    if (isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  } else if (prefix === "except-default") {
-    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  }
-  return {
-    basePath,
-    prefixedPathname,
-    unprefixedPathname,
-    maybeLocale,
-    isLocalePrefixed: Boolean(isLocalePrefixed)
-  };
-};
-
-// src/shared/utils/pathname/standardize-pathname.ts
-var standardizePathname = ({
-  config,
-  pathname
-}) => {
-  const { routing } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    PREFIX_PLACEHOLDER,
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/adapters/next/shared/utils/locale-prefix-pathname.ts
-var localePrefixPathname = ({
-  config,
-  pathname: standardizedPathname,
-  locale
-}) => {
-  const { routing } = config;
-  const { prefix } = routing;
-  if (prefix !== "none" && !locale) {
-    throw new Error('No locale when using prefix "all", "except-default"');
-  }
-  if (prefix === "all") {
-    return normalizePathname(
-      standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
-    );
-  }
-  if (prefix === "except-default") {
-    return locale === config.defaultLocale ? normalizePathname(
-      standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
-    ) : normalizePathname(
-      standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
-    );
-  }
-  return normalizePathname(
-    standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
-  );
-};
-
-// src/adapters/next/shared/utils/localize-pathname.ts
-var localizePathname = ({
-  config,
-  pathname: rawPathname,
-  locale
-}) => {
-  const { unprefixedPathname } = extractPathname({
-    config,
-    pathname: rawPathname
-  });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
-  const localePrefixedPathname = localePrefixPathname({
-    config,
-    pathname: standardizedPathname,
-    locale
-  });
-  return {
-    unprefixedPathname,
-    standardizedPathname,
-    localePrefixedPathname
-  };
-};
-
-// src/adapters/next/middleware/utils/create-response.ts
-var createResponse = ({
-  request,
-  config,
-  locale,
-  responseType = "next",
-  setCookieOptions = { override: false }
-}) => {
-  const { cookie } = config;
-  const { override } = setCookieOptions;
-  const url = request.nextUrl.clone();
-  const { localePrefixedPathname } = localizePathname({
-    config,
-    pathname: url.pathname,
-    locale
-  });
-  url.pathname = localePrefixedPathname;
-  const response = responseType === "redirect" ? NextResponse.redirect(url) : NextResponse.next();
-  if (locale) {
-    setLocaleCookieEdge({
-      request,
-      response,
-      locale,
-      cookie,
-      override
-    });
-  }
-  const finalResponse = setPathnameHeader({
-    request,
-    response
-  });
-  return finalResponse;
-};
-var determineInitialLocale = async (config) => {
-  const { defaultLocale, supportedLocales, routing } = config;
-  let initialLocale = defaultLocale;
-  if (routing.firstVisit.localeSource === "browser") {
-    const headersStore = await headers();
-    const acceptLanguageHeader = headersStore.get("accept-language") || void 0;
-    const preferredLocale = resolvePreferredLocale(
-      acceptLanguageHeader,
-      supportedLocales
-    );
-    initialLocale = normalizeLocale(preferredLocale, supportedLocales) || defaultLocale;
-  }
-  return initialLocale;
-};
-
-// src/adapters/next/middleware/handle-prefix/handle-prefix-all.ts
-var handlePrefixAll = async (config, request) => {
-  const { cookie, routing } = config;
-  const { maybeLocale, isLocalePrefixed } = extractPathname({
-    config,
-    pathname: request.nextUrl.pathname
-  });
-  const localeFromCookie = request.cookies.get(cookie.name)?.value;
-  if (isLocalePrefixed) {
-    return createResponse({
-      request,
-      config,
-      locale: maybeLocale,
-      setCookieOptions: { override: true }
-    });
-  }
-  if (!localeFromCookie) {
-    if (!routing.firstVisit.redirect) {
-      return createResponse({ request, config });
-    }
-    const initialLocale = await determineInitialLocale(config);
-    return createResponse({
-      request,
-      config,
-      locale: initialLocale,
-      // Use locale from 'browser' | 'default'
-      responseType: "redirect"
-    });
-  }
-  return createResponse({
-    request,
-    config,
-    locale: localeFromCookie,
-    // Use locale from cookie
-    responseType: "redirect"
-  });
-};
-
-// src/adapters/next/middleware/handle-prefix/handle-prefix-except-default.ts
-var handlePrefixExceptDefault = async (config, request) => {
-  const { defaultLocale, cookie, routing } = config;
-  const { maybeLocale, isLocalePrefixed } = extractPathname({
-    config,
-    pathname: request.nextUrl.pathname
-  });
-  const localeFromCookie = request.cookies.get(cookie.name)?.value;
-  if (isLocalePrefixed && maybeLocale !== defaultLocale) {
-    return createResponse({
-      request,
-      config,
-      locale: maybeLocale,
-      setCookieOptions: { override: true }
-    });
-  }
-  if (!localeFromCookie) {
-    if (!routing.firstVisit.redirect) {
-      return createResponse({ request, config });
-    }
-    const initialLocale = await determineInitialLocale(config);
-    const isDefaultLocale2 = initialLocale === defaultLocale;
-    if (isDefaultLocale2) {
-      return createResponse({
-        request,
-        config,
-        locale: defaultLocale
-      });
-    }
-    return createResponse({
-      request,
-      config,
-      locale: initialLocale,
-      // Use locale from 'browser' | 'default'
-      responseType: "redirect"
-    });
-  }
-  const isDefaultLocale = localeFromCookie === defaultLocale;
-  if (isDefaultLocale) {
-    return createResponse({ request, config, locale: localeFromCookie });
-  }
-  return createResponse({
-    request,
-    config,
-    locale: localeFromCookie,
-    // Use locale from cookie
-    responseType: "redirect"
-  });
-};
-
-// src/adapters/next/middleware/handle-prefix/handle-prefix-none.ts
-var handlePrefixNone = async (config, request) => {
-  let locale = request.cookies.get(config.cookie.name)?.value;
-  if (!locale) {
-    locale = await determineInitialLocale(config);
-  }
-  return createResponse({ request, config, locale });
-};
-
-// src/adapters/next/middleware/intor-middleware.ts
-async function intorMiddleware(config, request) {
-  const { prefix } = config.routing;
-  if (prefix === "none") {
-    return handlePrefixNone(config, request);
-  }
-  if (prefix === "except-default") {
-    return await handlePrefixExceptDefault(config, request);
-  }
-  return await handlePrefixAll(config, request);
-}
-
-export { PATHNAME_HEADER_NAME, intorMiddleware };