sitero 0.2.0 → 0.4.0

package/dist/src/shared/client/react-query/use-command.js

@@ -1,11 +1,16 @@
 "use client";
 import { useMutation } from '@tanstack/react-query';
-import { useState } from 'react';
+import { useState, useRef } from 'react';
 import { queryClient } from './client.js';
+import { mapOperationFieldErrors } from './field-errors.js';
+import { OperationClientError, getOperationError } from './operation-client-error.js';
 
 function useCommand(fn, mutationOptions) {
   const [isRedirecting, setIsRedirecting] = useState(false);
-  const [errors, setErrors] = useState([]);
+  const [fieldErrors, setFieldErrors] = useState([]);
+  const latestExecutionIdRef = useRef(0);
+  const latestMutationIdRef = useRef(0);
+  const errors = fieldErrors.map((field) => field.path);
   const {
     shouldTrigger,
     clearAll = true,
@@ -15,36 +20,48 @@ function useCommand(fn, mutationOptions) {
   const mutation = useMutation({
     ...reactQueryOptions,
     mutationFn: async (params) => {
+      const mutationId = ++latestMutationIdRef.current;
+      const isLatestMutation = () => mutationId === latestMutationIdRef.current;
       const response = await fn(params);
       if (response.success) {
-        setErrors([]);
+        if (isLatestMutation()) setFieldErrors([]);
         if (clearAll) await queryClient.invalidateQueries();
         return response.data;
       }
-      setErrors(
-        (response.error.fields ?? []).map((field) => field.path.join(".")).filter((f) => typeof f === "string")
-      );
-      onFailure?.(response.error);
-      throw new Error(response.error.code);
+      const nextFieldErrors = mapOperationFieldErrors(response.error.fields);
+      if (isLatestMutation()) {
+        setFieldErrors(nextFieldErrors);
+        onFailure?.(response.error);
+      }
+      throw new OperationClientError(response.error);
     }
   });
   const execute = (async (params) => {
+    let executionId;
     try {
       if (shouldTrigger) {
         const shouldProceed = await shouldTrigger(params);
-        if (!shouldProceed) {
-          setIsRedirecting(false);
-          return void 0;
-        }
+        if (!shouldProceed) return void 0;
       }
+      executionId = ++latestExecutionIdRef.current;
       setIsRedirecting(true);
       return await mutation.mutateAsync(params);
     } catch {
-      setIsRedirecting(false);
       return void 0;
+    } finally {
+      if (executionId !== void 0 && latestExecutionIdRef.current === executionId) {
+        setIsRedirecting(false);
+      }
     }
   });
-  return { ...mutation, execute, isRedirecting, errors };
+  return {
+    ...mutation,
+    execute,
+    isRedirecting,
+    errors,
+    fieldErrors,
+    operationError: getOperationError(mutation.error)
+  };
 }
 
 export { useCommand };

package/dist/src/shared/client/react-query/use-query.js

@@ -1,19 +1,20 @@
 "use client";
 import { useQuery as useQuery$1 } from '@tanstack/react-query';
+import { OperationClientError, getOperationError } from './operation-client-error.js';
 
 function useQuery(fn, queryKey, queryOptions) {
-  const { params, ...rest } = queryOptions || {};
   const query = useQuery$1({
-    queryKey: params ? [...queryKey, params] : queryKey,
+    queryKey,
     queryFn: async () => {
-      const response = await fn(params);
+      const response = await fn();
       if (response.success) return response.data;
-      throw new Error(response.error.code);
+      throw new OperationClientError(response.error);
     },
-    ...rest
+    ...queryOptions
   });
+  const operationError = getOperationError(query.error);
   const isNotFound = !query.isPending && !query.data;
-  return { ...query, isNotFound };
+  return { ...query, operationError, isNotFound };
 }
 
 export { useQuery };

package/dist/src/shared/client/storage/local-storage.js

@@ -0,0 +1,62 @@
+const LOCAL_STORAGE_CHANGE_EVENT = "sitero:local-storage-change";
+function getLocalStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function notifyChange(key) {
+  window.dispatchEvent(
+    new CustomEvent(LOCAL_STORAGE_CHANGE_EVENT, {
+      detail: { key }
+    })
+  );
+}
+const localStorageService = {
+  get(key) {
+    try {
+      return getLocalStorage()?.getItem(key) ?? null;
+    } catch {
+      return null;
+    }
+  },
+  set(key, value) {
+    const storage = getLocalStorage();
+    if (!storage) return;
+    try {
+      storage.setItem(key, value);
+      notifyChange(key);
+    } catch {
+    }
+  },
+  remove(key) {
+    const storage = getLocalStorage();
+    if (!storage) return;
+    try {
+      storage.removeItem(key);
+      notifyChange(key);
+    } catch {
+    }
+  },
+  subscribe(key, onChange) {
+    if (typeof window === "undefined") return () => {
+    };
+    const handleStorageChange = (event) => {
+      if (event.key === key) onChange();
+    };
+    const handleLocalChange = (event) => {
+      const { detail } = event;
+      if (detail?.key === key) onChange();
+    };
+    window.addEventListener("storage", handleStorageChange);
+    window.addEventListener(LOCAL_STORAGE_CHANGE_EVENT, handleLocalChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+      window.removeEventListener(LOCAL_STORAGE_CHANGE_EVENT, handleLocalChange);
+    };
+  }
+};
+
+export { localStorageService };

package/dist/src/shared/next/server/response.js

@@ -1,12 +1,7 @@
 import { NextResponse } from 'next/server';
-import { operationResult } from 'sitero-server';
+import { operationResult, normalizeOperationError } from 'sitero-server';
 import { ZodError } from 'zod';
 
-function toFieldPath(path) {
-  return path.filter(
-    (item) => typeof item === "string" || typeof item === "number"
-  );
-}
 function getOperationFailureStatus(error) {
   switch (error.code) {
     case "RATE_LIMITED":
@@ -33,11 +28,7 @@ function toNextErrorResponse(error) {
   if (error instanceof ZodError) {
     return toNextFailureJsonResponse(
       {
-        code: "VALIDATION_FAILED",
-        fields: error.issues.map((issue) => ({
-          path: toFieldPath(issue.path),
-          code: issue.code
-        }))
+        ...normalizeOperationError(error)
       },
       { status: 422 }
     );

package/dist/src/shared/seo-metadata.js

@@ -12,11 +12,6 @@ const OG_TYPE_ARRAY = [
   "video.movie",
   "video.episode"
 ];
-const TWITTER_CARD_ARRAY = [
-  "summary",
-  "summary_large_image",
-  "player",
-  "app"
-];
+const TWITTER_CARD_ARRAY = ["summary", "summary_large_image"];
 
 export { OG_TYPE_ARRAY, TWITTER_CARD_ARRAY };

package/dist/src/shared/translation/find-translation.js

@@ -1,5 +1,8 @@
-function findTranslation(translations, locale, defaultValue) {
-  const fallback = translations?.[0];
+function findTranslation(translations, locale, {
+  fallbackToFirst = true,
+  defaultValue
+} = {}) {
+  const fallback = fallbackToFirst ? translations?.[0] : void 0;
   const translation = translations?.find((t) => t.locale === locale) ?? fallback;
   if (!translation) return { locale: locale ?? "" };
   const result = { ...translation };

package/dist/src/shared/translation/get-translation-value.js

@@ -0,0 +1,10 @@
+function getTranslationValue(translations = [], locale, fieldName = "") {
+  const translation = translations.find((translation2) => {
+    return translation2.locale === locale;
+  });
+  if (!translation) return null;
+  const value = translation[fieldName];
+  return value === null || value === void 0 ? null : value;
+}
+
+export { getTranslationValue };

package/dist/src/shared/translation/update-translations.js

@@ -0,0 +1,14 @@
+function updateTranslations(translations = [], locale, fieldName, value) {
+  const hasLocale = translations.some((translation) => {
+    return translation.locale === locale;
+  });
+  const updatedTranslations = translations.map((translation) => {
+    return translation.locale === locale ? { ...translation, [fieldName]: value } : translation;
+  });
+  if (!hasLocale) {
+    updatedTranslations.push({ locale, [fieldName]: value });
+  }
+  return updatedTranslations;
+}
+
+export { updateTranslations };

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

@@ -0,0 +1,5 @@
+function getLocaleLanguageCode(locale) {
+  return locale?.split("-")[0];
+}
+
+export { getLocaleLanguageCode };

package/dist/src/web/client/applications/structured-data/build-breadcrumb.js

@@ -0,0 +1,15 @@
+function buildBreadcrumb(items, resolveUrl) {
+  if (items.length === 0) return void 0;
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name,
+      item: resolveUrl(item.pathname)
+    }))
+  };
+}
+
+export { buildBreadcrumb };

package/dist/src/web/server/seo/create-web-seo.js

@@ -3,7 +3,6 @@ import { createResolveUrls } from './metadata/resolve-urls.js';
 import { createBuildMetadata } from './metadata/build-metadata.js';
 import { createBuildUrlsFromPathname } from './sitemap/build-urls-from-pathname.js';
 import { createGetPageItems } from './sitemap/get-page-items.js';
-import { createGetFlatPostItems } from './sitemap/get-flat-post-items.js';
 import { createGetCategoryItems } from './sitemap/get-category-items.js';
 import { createGetSubcategoryItems } from './sitemap/get-subcategory-items.js';
 import { createGetPostItems } from './sitemap/get-post-items.js';
@@ -24,7 +23,6 @@ function createWebSeo(input) {
     sitemap: {
       createBuildUrlsFromPathname,
       createGetPageItems,
-      createGetFlatPostItems,
       createGetCategoryItems,
       createGetSubcategoryItems,
       createGetPostItems

package/dist/src/web/server/seo/metadata/build-alternate-pathnames.js

@@ -2,10 +2,9 @@ import { localizePathname } from 'intor';
 
 function buildAlternatePathnames({
   rawPathname,
-  webClientIntorConfig,
-  locales,
-  defaultLocale
+  webClientIntorConfig
 }) {
+  const { defaultLocale, supportedLocales: locales } = webClientIntorConfig;
   const result = {};
   for (const locale of locales) {
     const { pathname } = localizePathname(

package/dist/src/web/server/seo/metadata/build-metadata.js

@@ -1,129 +1,84 @@
-import 'mime-types';
-import 'sitero-domain';
-import { findTranslation } from '../../../../shared/translation/find-translation.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import { joinUrl } from '../../../../shared/utils/join-url.js';
 import { toIsoTime } from '../../../../shared/utils/to-iso-time.js';
-import 'zod';
 import { buildAlternateMap } from './utils/build-alternate-map.js';
 import { buildOgImages } from './utils/build-og-image.js';
 import { ensureOgType } from './utils/ensure-og-type.js';
 import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { resolveRobots } from './utils/resolve-robots.js';
 import { sanitizeStringArray } from './utils/sanitize-string-array.js';
 import { toOgLocale } from './utils/to-og-locale.js';
 
+const text = (value) => value?.trim() || void 0;
 function createBuildMetadata(ctx) {
-  const { siteConfig, storageUrl } = ctx.constants;
-  return function buildMetadata(urls, post, locale, isArticle = false) {
-    const { defaultLocale, webLocales: locales, site } = siteConfig;
+  const { siteConfig, webClientIntorConfig } = ctx.constants;
+  return function buildMetadata(urls, post, locale, isArticle = false, options = {}) {
+    const { site, sharing } = siteConfig;
+    const { defaultLocale, supportedLocales: locales } = webClientIntorConfig;
     const resolvedLocale = locale || defaultLocale;
-    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
-    const authorT = findTranslation(post?.author?.translations, locale);
-    const coverImageT = findTranslation(post?.coverImage?.translations, locale);
-    const tags = sanitizeStringArray(
-      post?.tags.map((t) => findTranslation(t.translations, locale).title)
+    const seo = post?.seoMetadatas.find(
+      (item) => item.locale === resolvedLocale
     );
-    const articleCoverImageUrl = joinUrl(storageUrl, post?.coverImage?.key);
+    const title = text(seo?.title);
+    const description = text(seo?.description);
+    const canonical = text(seo?.canonical) || urls.canonical;
+    const ogTitle = text(seo?.ogTitle) || title;
+    const ogDescription = text(seo?.ogDescription) || description;
+    const ogImage = text(seo?.ogImage);
+    const images = ogImage ? buildOgImages({
+      url: ogImage,
+      secureUrl: ogImage.startsWith("https://") ? ogImage : void 0,
+      alt: text(seo?.ogImageAlt),
+      type: text(seo?.ogImageType),
+      width: seo?.ogImageWidth,
+      height: seo?.ogImageHeight
+    }) : buildOgImages({
+      url: sharing.defaultImage.url,
+      secureUrl: sharing.defaultImage.url.startsWith("https://") ? sharing.defaultImage.url : void 0,
+      alt: sharing.defaultImage.alt,
+      type: sharing.defaultImage.mimeType,
+      width: sharing.defaultImage.width,
+      height: sharing.defaultImage.height
+    });
+    const author = text(seo?.author);
+    const articleAuthor = text(seo?.ogArticleAuthor);
     return {
-      metadataBase: site.url,
-      // -----------------------------------------------------------------------
-      // Basic
-      // -----------------------------------------------------------------------
-      title: seoMetadata.title || site.name[resolvedLocale],
-      description: seoMetadata.description || site.description[resolvedLocale],
-      // identity
-      ...isArticle ? {
-        authors: [
-          {
-            name: seoMetadata.author || authorT.authorName || void 0,
-            url: authorT.url || void 0
-          }
-        ]
-      } : {},
-      // url
+      metadataBase: new URL(site.url),
+      title: title ?? null,
+      description: description ?? null,
+      authors: isArticle && author ? [{ name: author }] : null,
       alternates: {
-        canonical: seoMetadata.canonical || urls.canonical,
-        languages: seoMetadata.alternate?.length ? buildAlternateMap(seoMetadata.alternate) : urls.alternates
+        canonical,
+        languages: seo?.alternate?.length ? buildAlternateMap(seo.alternate) : urls.alternates
       },
-      // robots
-      robots: seoMetadata.robots || {
-        index: true,
-        follow: true,
-        "max-image-preview": "large"
-      },
-      // -----------------------------------------------------------------------
-      // Open Graph
-      // -----------------------------------------------------------------------
+      robots: resolveRobots(
+        seo?.robots,
+        !!ctx.constants.forceNoIndex || !!options.forceNoIndex
+      ),
       openGraph: {
-        title: seoMetadata.ogTitle || void 0,
-        description: seoMetadata.ogDescription || void 0,
-        // url
-        url: seoMetadata.ogUrl || seoMetadata.canonical || void 0,
-        // identity
-        type: ensureOgType(
-          isArticle ? "article" : "website",
-          seoMetadata.ogType
-        ),
-        siteName: seoMetadata.ogSiteName || site.name[resolvedLocale],
-        // image
-        images: isArticle ? buildOgImages({
-          url: seoMetadata.ogImage || articleCoverImageUrl,
-          secureUrl: seoMetadata.ogImage || articleCoverImageUrl,
-          alt: seoMetadata.ogImageAlt || coverImageT.alt,
-          type: seoMetadata.ogImageType,
-          width: seoMetadata.ogImageWidth,
-          height: seoMetadata.ogImageHeight
-        }) : (
-          // is `website`
-          seoMetadata.ogImage ? buildOgImages({
-            url: seoMetadata.ogImage,
-            secureUrl: seoMetadata.ogImage,
-            alt: seoMetadata.ogImageAlt,
-            type: seoMetadata.ogImageType,
-            width: seoMetadata.ogImageWidth,
-            height: seoMetadata.ogImageHeight
-          }) : (
-            // default
-            buildOgImages({
-              url: site.defaultImage.url,
-              secureUrl: site.defaultImage.url,
-              alt: site.defaultImage.alt,
-              type: site.defaultImage.mimeType,
-              width: site.defaultImage.width,
-              height: site.defaultImage.height
-            })
-          )
-        ),
-        // locale
-        locale: seoMetadata.ogLocale || toOgLocale(resolvedLocale),
+        title: ogTitle,
+        description: ogDescription,
+        url: text(seo?.ogUrl) || canonical,
+        type: ensureOgType(isArticle ? "article" : "website", seo?.ogType),
+        siteName: text(seo?.ogSiteName) || site.name[resolvedLocale],
+        images,
+        locale: text(seo?.ogLocale) || toOgLocale(resolvedLocale),
         alternateLocale: sanitizeStringArray(
-          seoMetadata.ogLocaleAlternate?.length ? seoMetadata.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
+          seo?.ogLocaleAlternate?.length ? seo.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
         ),
-        // article
         ...isArticle ? {
-          publishedTime: toIsoTime(seoMetadata.ogArticlePublishedTime),
-          modifiedTime: toIsoTime(seoMetadata.ogArticleModifiedTime),
-          authors: [
-            seoMetadata.ogArticleAuthor || authorT.authorName
-          ].filter(Boolean),
-          section: seoMetadata.ogArticleSection,
-          tags: sanitizeStringArray(seoMetadata.ogArticleTag) || tags
+          publishedTime: toIsoTime(seo?.ogArticlePublishedTime),
+          modifiedTime: toIsoTime(seo?.ogArticleModifiedTime),
+          authors: articleAuthor ? [articleAuthor] : void 0,
+          section: text(seo?.ogArticleSection),
+          tags: sanitizeStringArray(seo?.ogArticleTag)
         } : {}
       },
-      // -----------------------------------------------------------------------
-      // Twitter
-      // -----------------------------------------------------------------------
       twitter: {
-        card: ensureTwitterCard("summary_large_image", seoMetadata.twitterCard),
-        // identity
-        site: seoMetadata.twitterSite || void 0,
-        creator: seoMetadata.twitterCreator || void 0
+        card: ensureTwitterCard("summary_large_image", seo?.twitterCard),
+        title: ogTitle,
+        description: ogDescription,
+        images,
+        site: text(seo?.twitterSite),
+        creator: text(seo?.twitterCreator)
       }
     };
   };

package/dist/src/web/server/seo/metadata/resolve-urls.js

@@ -3,12 +3,9 @@ import { readIntorUrlState } from 'intor/next/server';
 import { buildAlternatePathnames } from './build-alternate-pathnames.js';
 
 function createResolveUrls(ctx) {
-  const {
-    webClientIntorConfig,
-    defaultLocale,
-    webLocales: locales
-  } = ctx.constants;
-  return async function resolveUrls(locale) {
+  const { webClientIntorConfig } = ctx.constants;
+  const { defaultLocale } = webClientIntorConfig;
+  return async function resolveUrls(locale = defaultLocale) {
     const { pathname: rawPathname } = await readIntorUrlState();
     if (!rawPathname) throw new Error("[metadata] Missing x-intor-pathname");
     const canonicalPathname = localizePathname(
@@ -18,9 +15,7 @@ function createResolveUrls(ctx) {
     ).pathname;
     const alternates = buildAlternatePathnames({
       rawPathname,
-      webClientIntorConfig,
-      defaultLocale,
-      locales
+      webClientIntorConfig
     });
     return {
       canonical: canonicalPathname,

package/dist/src/web/server/seo/metadata/utils/build-og-image.js

@@ -17,8 +17,8 @@ const buildOgImages = ({
       secureUrl: secureUrl ?? void 0,
       alt: alt ?? void 0,
       type: type ?? validType,
-      width: typeof width === "number" && width > 0 ? width : 1200,
-      height: typeof height === "number" && height > 0 ? height : 630
+      width: typeof width === "number" && width > 0 ? width : void 0,
+      height: typeof height === "number" && height > 0 ? height : void 0
     }
   ];
 };

package/dist/src/web/server/seo/metadata/utils/ensure-og-type.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { OG_TYPE_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureOgType = (fallback, ogType) => {
   if (typeof ogType !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/ensure-twitter-card.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { TWITTER_CARD_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureTwitterCard = (fallback, twitterCard) => {
   if (typeof twitterCard !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/resolve-robots.js

@@ -0,0 +1,17 @@
+function resolveRobots(value, forceNoIndex = false) {
+  const directives = value?.trim();
+  if (!directives) {
+    return {
+      index: !forceNoIndex,
+      follow: true,
+      "max-image-preview": "large"
+    };
+  }
+  if (!forceNoIndex) return directives;
+  const preserved = directives.split(",").map((item) => item.trim()).filter(
+    (item) => item && !["index", "all", "noindex"].includes(item.toLowerCase())
+  );
+  return [...preserved, "noindex"].join(", ");
+}
+
+export { resolveRobots };

package/dist/src/web/server/seo/sitemap/build-entries.js

@@ -0,0 +1,47 @@
+import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
+import { createBuildMetadata } from '../metadata/build-metadata.js';
+
+function createBuildSitemapEntries(ctx) {
+  const { webClientIntorConfig, siteConfig } = ctx.constants;
+  const buildMetadata = createBuildMetadata(ctx);
+  const base = new URL(siteConfig.site.url);
+  const absoluteUrl = (value) => {
+    if (typeof value !== "string" && !(value instanceof URL)) {
+      throw new Error("[sitemap] Expected a URL from the metadata builder");
+    }
+    return new URL(value, base);
+  };
+  return function buildEntries(pathname, seoSource, lastModified, isArticle = false) {
+    const alternates = buildAlternatePathnames({
+      rawPathname: pathname,
+      webClientIntorConfig
+    });
+    const entries = [];
+    for (const locale of webClientIntorConfig.supportedLocales) {
+      const metadata = buildMetadata(
+        { canonical: alternates[locale], alternates },
+        seoSource,
+        locale,
+        isArticle
+      );
+      const robots = metadata.robots;
+      const noindex = typeof robots === "string" ? /(?:^|,)\s*(?:noindex|none)\s*(?:,|$)/i.test(robots) : robots?.index === false;
+      if (noindex) continue;
+      const url = absoluteUrl(metadata.alternates?.canonical);
+      if (url.origin !== base.origin) continue;
+      const languages = Object.fromEntries(
+        Object.entries(metadata.alternates?.languages ?? {}).map(
+          ([language, href]) => [language, absoluteUrl(href).href]
+        )
+      );
+      entries.push({
+        url: url.href,
+        alternates: { languages },
+        ...lastModified ? { lastModified: new Date(lastModified) } : {}
+      });
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
+  };
+}
+
+export { createBuildSitemapEntries };

package/dist/src/web/server/seo/sitemap/build-urls-from-pathname.js

@@ -1,30 +1,15 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
 import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
-import 'intor';
-import 'intor/next/server';
 
 function createBuildUrlsFromPathname({
   webClientIntorConfig,
-  webLocales: locales,
-  defaultLocale,
   webUrl
 }) {
+  const { defaultLocale } = webClientIntorConfig;
   return function buildUrlsFromPathname(pathname) {
     const alternates = buildAlternatePathnames({
       rawPathname: pathname,
-      webClientIntorConfig,
-      locales,
-      defaultLocale
+      webClientIntorConfig
     });
     const localizedMap = Object.fromEntries(
       Object.entries(alternates).map(([locale, path]) => [