nuxtseo-shared 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/client/composables/rpc.d.mts

@@ -0,0 +1,21 @@
+import * as vue from 'vue';
+import * as nitropack from 'nitropack';
+import { NuxtDevtoolsClient } from '@nuxt/devtools-kit/types';
+import { $Fetch } from 'nitropack/types';
+
+declare const appFetch: vue.Ref<$Fetch<unknown, nitropack.NitroFetchRequest> | undefined, $Fetch<unknown, nitropack.NitroFetchRequest> | undefined>;
+declare const devtools: vue.Ref<NuxtDevtoolsClient | undefined, NuxtDevtoolsClient | undefined>;
+declare const colorMode: vue.Ref<"dark" | "light", "dark" | "light">;
+interface DevtoolsConnectionOptions {
+    onConnected?: (client: any) => void;
+    onRouteChange?: (route: any) => void;
+}
+/**
+ * Initialize the base devtools connection.
+ * Call this in your module's devtools client setup.
+ * Returns a cleanup function.
+ */
+declare function useDevtoolsConnection(options?: DevtoolsConnectionOptions): void;
+
+export { appFetch, colorMode, devtools, useDevtoolsConnection };
+export type { DevtoolsConnectionOptions };

package/dist/client/composables/rpc.d.ts

@@ -0,0 +1,21 @@
+import * as vue from 'vue';
+import * as nitropack from 'nitropack';
+import { NuxtDevtoolsClient } from '@nuxt/devtools-kit/types';
+import { $Fetch } from 'nitropack/types';
+
+declare const appFetch: vue.Ref<$Fetch<unknown, nitropack.NitroFetchRequest> | undefined, $Fetch<unknown, nitropack.NitroFetchRequest> | undefined>;
+declare const devtools: vue.Ref<NuxtDevtoolsClient | undefined, NuxtDevtoolsClient | undefined>;
+declare const colorMode: vue.Ref<"dark" | "light", "dark" | "light">;
+interface DevtoolsConnectionOptions {
+    onConnected?: (client: any) => void;
+    onRouteChange?: (route: any) => void;
+}
+/**
+ * Initialize the base devtools connection.
+ * Call this in your module's devtools client setup.
+ * Returns a cleanup function.
+ */
+declare function useDevtoolsConnection(options?: DevtoolsConnectionOptions): void;
+
+export { appFetch, colorMode, devtools, useDevtoolsConnection };
+export type { DevtoolsConnectionOptions };

package/dist/client/composables/rpc.mjs

@@ -0,0 +1,25 @@
+import { onDevtoolsClientConnected } from '@nuxt/devtools-kit/iframe-client';
+import { ref, watchEffect } from 'vue';
+
+const appFetch = ref();
+const devtools = ref();
+const colorMode = ref("dark");
+function useDevtoolsConnection(options = {}) {
+  onDevtoolsClientConnected(async (client) => {
+    appFetch.value = client.host.app.$fetch;
+    watchEffect(() => {
+      colorMode.value = client.host.app.colorMode.value;
+    });
+    devtools.value = client.devtools;
+    options.onConnected?.(client);
+    if (options.onRouteChange) {
+      const $route = client.host.nuxt.vueApp.config.globalProperties?.$route;
+      options.onRouteChange($route);
+      client.host.nuxt.$router.afterEach((route) => {
+        options.onRouteChange(route);
+      });
+    }
+  });
+}
+
+export { appFetch, colorMode, devtools, useDevtoolsConnection };

package/dist/client/composables/shiki.d.mts

@@ -0,0 +1,13 @@
+import * as vue from 'vue';
+import { MaybeRef, ComputedRef } from 'vue';
+import { LanguageRegistration, HighlighterCore } from 'shiki';
+
+declare const shiki: vue.Ref<HighlighterCore | undefined, HighlighterCore | undefined>;
+interface LoadShikiOptions {
+    extraLangs?: (LanguageRegistration | Promise<LanguageRegistration>)[];
+}
+declare function loadShiki(options?: LoadShikiOptions): Promise<HighlighterCore>;
+declare function useRenderCodeHighlight(code: MaybeRef<string>, lang: string): ComputedRef<string>;
+
+export { loadShiki, shiki, useRenderCodeHighlight };
+export type { LoadShikiOptions };

package/dist/client/composables/shiki.d.ts

@@ -0,0 +1,13 @@
+import * as vue from 'vue';
+import { MaybeRef, ComputedRef } from 'vue';
+import { LanguageRegistration, HighlighterCore } from 'shiki';
+
+declare const shiki: vue.Ref<HighlighterCore | undefined, HighlighterCore | undefined>;
+interface LoadShikiOptions {
+    extraLangs?: (LanguageRegistration | Promise<LanguageRegistration>)[];
+}
+declare function loadShiki(options?: LoadShikiOptions): Promise<HighlighterCore>;
+declare function useRenderCodeHighlight(code: MaybeRef<string>, lang: string): ComputedRef<string>;
+
+export { loadShiki, shiki, useRenderCodeHighlight };
+export type { LoadShikiOptions };

package/dist/client/composables/shiki.mjs

@@ -0,0 +1,39 @@
+import { createHighlighterCore } from 'shiki/core';
+import { createJavaScriptRegexEngine } from 'shiki/engine/javascript';
+import { ref, computed, toValue } from 'vue';
+import { colorMode } from './rpc.mjs';
+import '@nuxt/devtools-kit/iframe-client';
+
+const shiki = ref();
+async function loadShiki(options = {}) {
+  const langs = [
+    import('@shikijs/langs/xml'),
+    import('@shikijs/langs/json'),
+    import('@shikijs/langs/js')
+  ];
+  if (options.extraLangs) {
+    langs.push(...options.extraLangs);
+  }
+  shiki.value = await createHighlighterCore({
+    themes: [
+      import('@shikijs/themes/vitesse-light'),
+      import('@shikijs/themes/vitesse-dark')
+    ],
+    langs,
+    engine: createJavaScriptRegexEngine()
+  });
+  return shiki.value;
+}
+function useRenderCodeHighlight(code, lang) {
+  return computed(() => {
+    if (!shiki.value)
+      return "";
+    const theme = colorMode.value === "dark" ? "vitesse-dark" : "vitesse-light";
+    return shiki.value.codeToHtml(toValue(code) || "", {
+      lang,
+      theme
+    }) || "";
+  });
+}
+
+export { loadShiki, shiki, useRenderCodeHighlight };

package/dist/client/index.d.mts

@@ -0,0 +1,7 @@
+export { appFetch, colorMode, devtools } from './composables/rpc.mjs';
+export { loadShiki, shiki, useRenderCodeHighlight } from './composables/shiki.mjs';
+import 'vue';
+import 'nitropack';
+import '@nuxt/devtools-kit/types';
+import 'nitropack/types';
+import 'shiki';

package/dist/client/index.d.ts

@@ -0,0 +1,7 @@
+export { appFetch, colorMode, devtools } from './composables/rpc.js';
+export { loadShiki, shiki, useRenderCodeHighlight } from './composables/shiki.js';
+import 'vue';
+import 'nitropack';
+import '@nuxt/devtools-kit/types';
+import 'nitropack/types';
+import 'shiki';

package/dist/client/index.mjs

@@ -0,0 +1,6 @@
+export { appFetch, colorMode, devtools } from './composables/rpc.mjs';
+export { loadShiki, shiki, useRenderCodeHighlight } from './composables/shiki.mjs';
+import '@nuxt/devtools-kit/iframe-client';
+import 'vue';
+import 'shiki/core';
+import 'shiki/engine/javascript';

package/dist/content.d.mts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+
+type ZodInstance = typeof z;
+type ZodTypeAny = z.ZodTypeAny;
+interface ContentSchemaOptions {
+    /**
+     * Pass the `z` instance from `@nuxt/content` to ensure `.editor()` works
+     * across Zod versions. When omitted, the module's bundled `z` is used.
+     */
+    z?: ZodInstance;
+}
+interface ContentEditorConfig {
+    hidden?: boolean;
+    input?: 'media' | 'icon' | 'textarea';
+    iconLibraries?: string[];
+}
+/**
+ * Apply Nuxt Content `.editor()` metadata to a zod schema field.
+ * No-ops gracefully when `.editor()` is not patched onto ZodType (outside Nuxt Content).
+ */
+declare function withEditor<T extends ZodTypeAny>(schema: T, config: ContentEditorConfig): T;
+/**
+ * Hide a zod schema field from the Nuxt Content / Studio editor.
+ * Only use for fields that genuinely don't work in a form (freeform JSON, deeply nested arrays).
+ */
+declare function withEditorHidden<T extends ZodTypeAny>(schema: T): T;
+interface DefineContentSchemaConfig<TSchema extends ZodTypeAny> {
+    /**
+     * The field name used in frontmatter (e.g. 'robots', 'sitemap', 'ogImage').
+     */
+    fieldName: string;
+    /**
+     * Build the zod schema for this field. Receives the zod instance
+     * (either the user's `@nuxt/content` patched version or the module's bundled one).
+     */
+    buildSchema: (z: ZodInstance) => TSchema;
+    /**
+     * Module label for deprecation warnings (e.g. 'robots', 'sitemap').
+     */
+    label: string;
+    /**
+     * Documentation URL for migration guidance.
+     */
+    docsUrl?: string;
+}
+/**
+ * Factory for creating a module's `define*Schema()` and deprecated `as*Collection()` exports.
+ *
+ * Each module provides its own schema builder. The factory handles:
+ * - Zod instance passthrough for `@nuxt/content` version compatibility
+ * - Consistent `DefineSchemaOptions` interface
+ * - Deprecated `asXxxCollection()` wrapper with migration warning
+ *
+ * @example
+ * // In @nuxtjs/robots/content.ts
+ * import { z } from 'zod'
+ * import { createContentSchemaFactory } from 'nuxtseo-shared/content'
+ *
+ * const { defineSchema, asCollection, schema } = createContentSchemaFactory({
+ *   fieldName: 'robots',
+ *   label: 'robots',
+ *   docsUrl: 'https://nuxtseo.com/robots/guides/content',
+ *   buildSchema: (z) => z.enum(['index, follow', 'noindex', 'nofollow', 'noindex, nofollow', 'none']).optional(),
+ * }, z)
+ *
+ * export { defineSchema as defineRobotsSchema, asCollection as asRobotsCollection, schema }
+ */
+declare function createContentSchemaFactory<TSchema extends ZodTypeAny>(config: DefineContentSchemaConfig<TSchema>, defaultZ: ZodInstance): {
+    defineSchema: (options?: ContentSchemaOptions) => TSchema;
+    asCollection: <T>(collection: any) => T;
+    schema: z.ZodObject<{
+        [x: string]: TSchema;
+    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+        [x: string]: TSchema;
+    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+        [x: string]: TSchema;
+    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+    fieldSchema: TSchema;
+};
+
+export { createContentSchemaFactory, withEditor, withEditorHidden };
+export type { ContentEditorConfig, ContentSchemaOptions, DefineContentSchemaConfig };

package/dist/content.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+
+type ZodInstance = typeof z;
+type ZodTypeAny = z.ZodTypeAny;
+interface ContentSchemaOptions {
+    /**
+     * Pass the `z` instance from `@nuxt/content` to ensure `.editor()` works
+     * across Zod versions. When omitted, the module's bundled `z` is used.
+     */
+    z?: ZodInstance;
+}
+interface ContentEditorConfig {
+    hidden?: boolean;
+    input?: 'media' | 'icon' | 'textarea';
+    iconLibraries?: string[];
+}
+/**
+ * Apply Nuxt Content `.editor()` metadata to a zod schema field.
+ * No-ops gracefully when `.editor()` is not patched onto ZodType (outside Nuxt Content).
+ */
+declare function withEditor<T extends ZodTypeAny>(schema: T, config: ContentEditorConfig): T;
+/**
+ * Hide a zod schema field from the Nuxt Content / Studio editor.
+ * Only use for fields that genuinely don't work in a form (freeform JSON, deeply nested arrays).
+ */
+declare function withEditorHidden<T extends ZodTypeAny>(schema: T): T;
+interface DefineContentSchemaConfig<TSchema extends ZodTypeAny> {
+    /**
+     * The field name used in frontmatter (e.g. 'robots', 'sitemap', 'ogImage').
+     */
+    fieldName: string;
+    /**
+     * Build the zod schema for this field. Receives the zod instance
+     * (either the user's `@nuxt/content` patched version or the module's bundled one).
+     */
+    buildSchema: (z: ZodInstance) => TSchema;
+    /**
+     * Module label for deprecation warnings (e.g. 'robots', 'sitemap').
+     */
+    label: string;
+    /**
+     * Documentation URL for migration guidance.
+     */
+    docsUrl?: string;
+}
+/**
+ * Factory for creating a module's `define*Schema()` and deprecated `as*Collection()` exports.
+ *
+ * Each module provides its own schema builder. The factory handles:
+ * - Zod instance passthrough for `@nuxt/content` version compatibility
+ * - Consistent `DefineSchemaOptions` interface
+ * - Deprecated `asXxxCollection()` wrapper with migration warning
+ *
+ * @example
+ * // In @nuxtjs/robots/content.ts
+ * import { z } from 'zod'
+ * import { createContentSchemaFactory } from 'nuxtseo-shared/content'
+ *
+ * const { defineSchema, asCollection, schema } = createContentSchemaFactory({
+ *   fieldName: 'robots',
+ *   label: 'robots',
+ *   docsUrl: 'https://nuxtseo.com/robots/guides/content',
+ *   buildSchema: (z) => z.enum(['index, follow', 'noindex', 'nofollow', 'noindex, nofollow', 'none']).optional(),
+ * }, z)
+ *
+ * export { defineSchema as defineRobotsSchema, asCollection as asRobotsCollection, schema }
+ */
+declare function createContentSchemaFactory<TSchema extends ZodTypeAny>(config: DefineContentSchemaConfig<TSchema>, defaultZ: ZodInstance): {
+    defineSchema: (options?: ContentSchemaOptions) => TSchema;
+    asCollection: <T>(collection: any) => T;
+    schema: z.ZodObject<{
+        [x: string]: TSchema;
+    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+        [x: string]: TSchema;
+    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+        [x: string]: TSchema;
+    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+    fieldSchema: TSchema;
+};
+
+export { createContentSchemaFactory, withEditor, withEditorHidden };
+export type { ContentEditorConfig, ContentSchemaOptions, DefineContentSchemaConfig };

package/dist/content.mjs

@@ -0,0 +1,38 @@
+function withEditor(schema, config) {
+  if (typeof schema.editor === "function")
+    return schema.editor(config);
+  return schema;
+}
+function withEditorHidden(schema) {
+  return withEditor(schema, { hidden: true });
+}
+function createContentSchemaFactory(config, defaultZ) {
+  const { fieldName, buildSchema, label, docsUrl } = config;
+  const defaultSchema = buildSchema(defaultZ);
+  const schemaObject = defaultZ.object({ [fieldName]: defaultSchema });
+  function defineSchema(options) {
+    const _z = options?.z ?? defaultZ;
+    if (_z === defaultZ)
+      return defaultSchema;
+    return buildSchema(_z);
+  }
+  function asCollection(collection) {
+    const migrationHint = docsUrl ? ` See ${docsUrl}` : "";
+    console.warn(`[${label}] \`as${capitalize(label)}Collection()\` is deprecated. Use \`define${capitalize(label)}Schema()\` in your collection schema instead.${migrationHint}`);
+    if (collection.type === "page") {
+      collection.schema = collection.schema ? schemaObject.extend(collection.schema.shape) : schemaObject;
+    }
+    return collection;
+  }
+  return {
+    defineSchema,
+    asCollection,
+    schema: schemaObject,
+    fieldSchema: defaultSchema
+  };
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+export { createContentSchemaFactory, withEditor, withEditorHidden };

package/dist/devtools.d.mts

@@ -0,0 +1,14 @@
+import { Resolver } from '@nuxt/kit';
+import { Nuxt } from 'nuxt/schema';
+
+interface DevToolsUIConfig {
+    route: string;
+    name: string;
+    title: string;
+    icon: string;
+    devPort?: number;
+}
+declare function setupDevToolsUI(config: DevToolsUIConfig, resolve: Resolver['resolve'], nuxt?: Nuxt): void;
+
+export { setupDevToolsUI };
+export type { DevToolsUIConfig };

package/dist/devtools.d.ts

@@ -0,0 +1,14 @@
+import { Resolver } from '@nuxt/kit';
+import { Nuxt } from 'nuxt/schema';
+
+interface DevToolsUIConfig {
+    route: string;
+    name: string;
+    title: string;
+    icon: string;
+    devPort?: number;
+}
+declare function setupDevToolsUI(config: DevToolsUIConfig, resolve: Resolver['resolve'], nuxt?: Nuxt): void;
+
+export { setupDevToolsUI };
+export type { DevToolsUIConfig };

package/dist/devtools.mjs

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import { addCustomTab } from '@nuxt/devtools-kit';
+import { useNuxt } from '@nuxt/kit';
+
+function setupDevToolsUI(config, resolve, nuxt = useNuxt()) {
+  const { route, name, title, icon, devPort = 3030 } = config;
+  const clientPath = resolve("./client");
+  const isProductionBuild = existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(
+        route,
+        sirv(clientPath, { dev: true, single: true })
+      );
+    });
+  } else {
+    nuxt.hook("vite:extendConfig", (config2) => {
+      Object.assign(config2, {
+        server: {
+          ...config2.server,
+          proxy: {
+            ...config2.server?.proxy,
+            [route]: {
+              target: `http://localhost:${devPort}${route}`,
+              changeOrigin: true,
+              followRedirects: true,
+              rewrite: (p) => p.replace(route, "")
+            }
+          }
+        }
+      });
+    });
+  }
+  addCustomTab({
+    name,
+    title,
+    icon,
+    view: {
+      type: "iframe",
+      src: route
+    }
+  });
+}
+
+export { setupDevToolsUI };

package/dist/i18n.d.mts

@@ -0,0 +1,28 @@
+import { LocaleObject, NuxtI18nOptions } from '@nuxtjs/i18n';
+
+type Strategies = 'no_prefix' | 'prefix_except_default' | 'prefix' | 'prefix_and_default';
+interface AutoI18nConfig {
+    locales: LocaleObject[];
+    defaultLocale: string;
+    strategy: Strategies;
+    differentDomains?: boolean;
+    pages?: Record<string, Record<string, string | false>>;
+}
+interface StrategyProps {
+    localeCode: string;
+    pageLocales: string;
+    nuxtI18nConfig: NuxtI18nOptions;
+    forcedStrategy?: Strategies;
+    normalisedLocales: AutoI18nConfig['locales'];
+}
+declare function generatePathForI18nPages(ctx: StrategyProps): string;
+declare function splitPathForI18nLocales(path: string, autoI18n: AutoI18nConfig): string | string[];
+declare function normalizeLocales(nuxtI18nConfig: NuxtI18nOptions): AutoI18nConfig['locales'];
+declare function mapPathForI18nPages(path: string, autoI18n: AutoI18nConfig): string[] | false;
+declare function resolveI18nConfig(logger?: {
+    warn: (msg: string) => void;
+}): Promise<false | AutoI18nConfig>;
+declare function mergeOnKey<T extends Record<string, any>>(arr: T[], key: keyof T): T[];
+
+export { generatePathForI18nPages, mapPathForI18nPages, mergeOnKey, normalizeLocales, resolveI18nConfig, splitPathForI18nLocales };
+export type { AutoI18nConfig, Strategies, StrategyProps };

package/dist/i18n.d.ts

@@ -0,0 +1,28 @@
+import { LocaleObject, NuxtI18nOptions } from '@nuxtjs/i18n';
+
+type Strategies = 'no_prefix' | 'prefix_except_default' | 'prefix' | 'prefix_and_default';
+interface AutoI18nConfig {
+    locales: LocaleObject[];
+    defaultLocale: string;
+    strategy: Strategies;
+    differentDomains?: boolean;
+    pages?: Record<string, Record<string, string | false>>;
+}
+interface StrategyProps {
+    localeCode: string;
+    pageLocales: string;
+    nuxtI18nConfig: NuxtI18nOptions;
+    forcedStrategy?: Strategies;
+    normalisedLocales: AutoI18nConfig['locales'];
+}
+declare function generatePathForI18nPages(ctx: StrategyProps): string;
+declare function splitPathForI18nLocales(path: string, autoI18n: AutoI18nConfig): string | string[];
+declare function normalizeLocales(nuxtI18nConfig: NuxtI18nOptions): AutoI18nConfig['locales'];
+declare function mapPathForI18nPages(path: string, autoI18n: AutoI18nConfig): string[] | false;
+declare function resolveI18nConfig(logger?: {
+    warn: (msg: string) => void;
+}): Promise<false | AutoI18nConfig>;
+declare function mergeOnKey<T extends Record<string, any>>(arr: T[], key: keyof T): T[];
+
+export { generatePathForI18nPages, mapPathForI18nPages, mergeOnKey, normalizeLocales, resolveI18nConfig, splitPathForI18nLocales };
+export type { AutoI18nConfig, Strategies, StrategyProps };

package/dist/i18n.mjs

@@ -0,0 +1,121 @@
+import { hasNuxtModule, getNuxtModuleVersion, hasNuxtModuleCompatibility } from '@nuxt/kit';
+import { joinURL, withHttps, withBase, withLeadingSlash } from 'ufo';
+import { getNuxtModuleOptions } from './kit.mjs';
+import 'pathe';
+import 'std-env';
+
+const SLASH_PATTERN = /^\/|\/$/g;
+function generatePathForI18nPages(ctx) {
+  const { localeCode, pageLocales, nuxtI18nConfig, forcedStrategy, normalisedLocales } = ctx;
+  const locale = normalisedLocales.find((l) => l.code === localeCode);
+  let path = pageLocales;
+  switch (forcedStrategy ?? nuxtI18nConfig.strategy) {
+    case "prefix_except_default":
+    case "prefix_and_default":
+      path = localeCode === nuxtI18nConfig.defaultLocale ? pageLocales : joinURL(localeCode, pageLocales);
+      break;
+    case "prefix":
+      path = joinURL(localeCode, pageLocales);
+      break;
+  }
+  return locale?.domain ? withHttps(withBase(path, locale.domain)) : path;
+}
+function splitPathForI18nLocales(path, autoI18n) {
+  const locales = autoI18n.strategy === "prefix_except_default" ? autoI18n.locales.filter((l) => l.code !== autoI18n.defaultLocale) : autoI18n.locales;
+  if (!path || path.startsWith("/_"))
+    return path;
+  const hasLocalePrefix = locales.some((l) => path.startsWith(`/${l.code}/`) || path === `/${l.code}`);
+  if (hasLocalePrefix)
+    return path;
+  return [
+    path,
+    ...locales.map((l) => `/${l.code}${path}`)
+  ];
+}
+function normalizeLocales(nuxtI18nConfig) {
+  const rawLocales = nuxtI18nConfig.locales || [];
+  let onlyLocales = nuxtI18nConfig?.bundle?.onlyLocales || [];
+  onlyLocales = typeof onlyLocales === "string" ? [onlyLocales] : onlyLocales;
+  let locales = mergeOnKey(rawLocales.map((locale) => typeof locale === "string" ? { code: locale } : locale), "code");
+  if (onlyLocales.length) {
+    locales = locales.filter((locale) => onlyLocales.includes(locale.code));
+  }
+  return locales.map((locale) => {
+    if (typeof locale.iso === "string" && !locale.language) {
+      locale.language = locale.iso;
+    }
+    const _hreflang = locale.language || locale.code;
+    const _sitemap = locale.language || locale.code;
+    return { ...locale, _hreflang, _sitemap };
+  });
+}
+function mapPathForI18nPages(path, autoI18n) {
+  const pages = autoI18n.pages;
+  if (!pages || !Object.keys(pages).length)
+    return false;
+  const withoutSlashes = path.replace(SLASH_PATTERN, "").replace("/index", "");
+  function resolveForAllLocales(pageName, pageLocales) {
+    return autoI18n.locales.filter((l) => {
+      if (l.code in pageLocales && pageLocales[l.code] === false)
+        return false;
+      if (autoI18n.strategy === "prefix_except_default" && l.code === autoI18n.defaultLocale)
+        return false;
+      return true;
+    }).map((l) => {
+      const localePath = l.code in pageLocales && pageLocales[l.code] !== false ? pageLocales[l.code] : `/${pageName}`;
+      return withLeadingSlash(generatePathForI18nPages({
+        localeCode: l.code,
+        pageLocales: localePath,
+        nuxtI18nConfig: { strategy: autoI18n.strategy, defaultLocale: autoI18n.defaultLocale },
+        normalisedLocales: autoI18n.locales
+      }));
+    });
+  }
+  if (withoutSlashes in pages) {
+    const pageLocales = pages[withoutSlashes];
+    if (pageLocales)
+      return resolveForAllLocales(withoutSlashes, pageLocales);
+  }
+  for (const [pageName, pageLocales] of Object.entries(pages)) {
+    if (!pageLocales)
+      continue;
+    if (autoI18n.defaultLocale in pageLocales && pageLocales[autoI18n.defaultLocale] === path)
+      return resolveForAllLocales(pageName, pageLocales);
+  }
+  return false;
+}
+async function resolveI18nConfig(logger) {
+  if (!hasNuxtModule("@nuxtjs/i18n"))
+    return false;
+  const i18nVersion = await getNuxtModuleVersion("@nuxtjs/i18n");
+  if (!await hasNuxtModuleCompatibility("@nuxtjs/i18n", ">=8")) {
+    logger?.warn(`You are using @nuxtjs/i18n v${i18nVersion}. For the best compatibility, please upgrade to @nuxtjs/i18n v8.0.0 or higher.`);
+  }
+  const nuxtI18nConfig = await getNuxtModuleOptions("@nuxtjs/i18n") || {};
+  const normalisedLocales = normalizeLocales(nuxtI18nConfig);
+  const usingI18nPages = Object.keys(nuxtI18nConfig.pages || {}).length;
+  const hasI18nConfigForAlternatives = nuxtI18nConfig.differentDomains || usingI18nPages || nuxtI18nConfig.strategy !== "no_prefix" && nuxtI18nConfig.locales;
+  if (!hasI18nConfigForAlternatives)
+    return false;
+  return {
+    differentDomains: nuxtI18nConfig.differentDomains,
+    defaultLocale: nuxtI18nConfig.defaultLocale,
+    locales: normalisedLocales,
+    strategy: nuxtI18nConfig.strategy,
+    pages: nuxtI18nConfig.pages
+  };
+}
+function mergeOnKey(arr, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    const k = item[key];
+    if (map.has(k)) {
+      map.set(k, { ...map.get(k), ...item });
+    } else {
+      map.set(k, item);
+    }
+  }
+  return [...map.values()];
+}
+
+export { generatePathForI18nPages, mapPathForI18nPages, mergeOnKey, normalizeLocales, resolveI18nConfig, splitPathForI18nLocales };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+export { setupDevToolsUI } from './devtools.mjs';
+export { createNitroPromise, createPagesPromise, detectTarget, extendTypes, getNuxtModuleOptions, isNuxtGenerate, resolveNitroPreset } from './kit.mjs';
+import '@nuxt/kit';
+import 'nuxt/schema';
+import '@nuxt/schema';
+import 'nitropack';
+import 'nitropack/types';

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { setupDevToolsUI } from './devtools.js';
+export { createNitroPromise, createPagesPromise, detectTarget, extendTypes, getNuxtModuleOptions, isNuxtGenerate, resolveNitroPreset } from './kit.js';
+import '@nuxt/kit';
+import 'nuxt/schema';
+import '@nuxt/schema';
+import 'nitropack';
+import 'nitropack/types';

package/dist/index.mjs

@@ -0,0 +1,7 @@
+export { setupDevToolsUI } from './devtools.mjs';
+export { createNitroPromise, createPagesPromise, detectTarget, extendTypes, getNuxtModuleOptions, isNuxtGenerate, resolveNitroPreset } from './kit.mjs';
+import 'node:fs';
+import '@nuxt/devtools-kit';
+import '@nuxt/kit';
+import 'pathe';
+import 'std-env';