@nuxtjs/i18n-edge 8.0.0-alpha.0-27419678.39bcf0f

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) Nuxt Community
+Copyright (c) Rafał Chłodnicki (@rchl)
+Copyright (c) Paul Gascou-Vaillancourt (@paulgv)
+Copyright (c) Kazuya Kawaguchi (@kazupon)
+
+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/README.md

@@ -0,0 +1,7 @@
+# nuxt-i18n-next
+
+⚠️ This nuxt module is PoC of `@nuxtjs/i18n` next
+
+## ©️ LICENSE
+
+MIT

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -0,0 +1,52 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import * as vue_i18n_routing from 'vue-i18n-routing';
+import { LocaleObject, BaseUrlResolveHandler, VueI18nRoutingOptions } from 'vue-i18n-routing';
+import { Locale, I18nOptions, Composer } from 'vue-i18n';
+
+declare type RedirectOnOptions = 'all' | 'root' | 'no prefix';
+interface LazyOptions {
+    skipNuxtState?: boolean;
+}
+interface DetectBrowserLanguageOptions {
+    alwaysRedirect?: boolean;
+    cookieCrossOrigin?: boolean;
+    cookieDomain?: string | null;
+    cookieKey?: string;
+    cookieSecure?: boolean;
+    fallbackLocale?: Locale | null;
+    redirectOn?: RedirectOnOptions;
+    useCookie?: boolean;
+}
+declare type LocaleInfo = {
+    path: string;
+} & LocaleObject;
+interface RootRedirectOptions {
+    path: string;
+    statusCode: number;
+}
+declare type CustomRoutePages = {
+    [key: string]: false | {
+        [key: string]: false | string;
+    };
+};
+declare type NuxtI18nOptions<BaseUrl extends BaseUrlResolveHandler = BaseUrlResolveHandler> = {
+    langDir?: string | null;
+    lazy?: boolean | LazyOptions;
+    pages?: CustomRoutePages;
+    vueI18n?: I18nOptions | string;
+} & Pick<VueI18nRoutingOptions<BaseUrl>, 'baseUrl' | 'strategy' | 'defaultDirection' | 'defaultLocale' | 'defaultLocaleRouteNameSuffix' | 'locales' | 'routesNameSeparator' | 'trailingSlash'>;
+
+declare const _default: _nuxt_schema.NuxtModule<NuxtI18nOptions<vue_i18n_routing.BaseUrlResolveHandler>>;
+
+declare module '@nuxt/kit' {
+    interface NuxtApp {
+        $i18n: Composer;
+    }
+}
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        i18n?: NuxtI18nOptions;
+    }
+}
+
+export { CustomRoutePages, DetectBrowserLanguageOptions, LazyOptions, LocaleInfo, NuxtI18nOptions, RedirectOnOptions, RootRedirectOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,5 @@
+{
+  "name": "@nuxtjs/i18n",
+  "configKey": "i18n",
+  "version": "8.0.0-alpha.0-27419678.39bcf0f"
+}

package/dist/module.mjs

@@ -0,0 +1,280 @@
+import createDebug from 'debug';
+import { isString, isObject, isRegExp, isFunction, isArray } from '@intlify/shared';
+import { resolveModule, addPluginTemplate, extendWebpackConfig, extendViteConfig, resolveFiles, extendPages, templateUtils, defineNuxtModule, isNuxt2, isNuxt3, getNuxtVersion, addTemplate } from '@nuxt/kit';
+import { dirname, resolve, parse } from 'pathe';
+import defu from 'defu';
+import webpack from 'webpack';
+import { fileURLToPath } from 'url';
+import { vueI18n } from '@intlify/vite-plugin-vue-i18n';
+import { localizeRoutes } from 'vue-i18n-routing';
+import { genImport } from 'knitwork';
+
+const distDir = dirname(fileURLToPath(import.meta.url));
+
+async function setupNuxtBridge(nuxt) {
+  nuxt.options.alias["vue-i18n"] = resolveModule("vue-i18n-legacy/dist/vue-i18n.esm.js", {
+    paths: nuxt.options.modulesDir
+  });
+  nuxt.options.build.transpile.push("vue-i18n");
+  const vueI18nBridgePath = nuxt.options.dev ? "vue-i18n-bridge/dist/vue-i18n-bridge.esm-bundler.js" : "vue-i18n-bridge/dist/vue-i18n-bridge-runtime.esm-bundler.js";
+  nuxt.options.alias["vue-i18n-bridge"] = resolveModule(vueI18nBridgePath, {
+    paths: nuxt.options.modulesDir
+  });
+  nuxt.options.build.transpile.push("vue-i18n-bridge");
+  addPluginTemplate({
+    filename: "runtime/bridge.plugin.mjs",
+    src: resolve(distDir, "runtime/bridge.plugin.mjs")
+  });
+  extendWebpackConfig((config) => {
+    config.plugins.push(new webpack.DefinePlugin({
+      __VUE_I18N_FULL_INSTALL__: "true",
+      __VUE_I18N_LEGACY_API__: "true",
+      __INTLIFY_PROD_DEVTOOLS__: "false"
+    }));
+  });
+}
+
+async function setupAutoImports(nuxt) {
+}
+
+async function extendBundler(hasLocaleFiles, langPath) {
+  extendViteConfig((config) => {
+    const viteOptions = {
+      compositionOnly: false
+    };
+    if (hasLocaleFiles) {
+      viteOptions["include"] = resolve(langPath, "./**");
+    }
+    config.plugins.push(vueI18n(viteOptions));
+  });
+}
+
+async function setupNuxt3(nuxt) {
+  const vueI18nPath = nuxt.options.dev ? "vue-i18n/dist/vue-i18n.esm-bundler.js" : "vue-i18n/dist/vue-i18n.runtime.esm-bundler.js";
+  nuxt.options.alias["vue-i18n"] = resolveModule(vueI18nPath, {
+    paths: nuxt.options.modulesDir
+  });
+  nuxt.options.build.transpile.push("vue-i18n");
+  addPluginTemplate({
+    filename: "runtime/nuxt3.plugin.mjs",
+    src: resolve(distDir, "runtime/nuxt3.plugin.mjs")
+  });
+}
+
+const STRATEGY_PREFIX = "prefix";
+const STRATEGY_PREFIX_EXCEPT_DEFAULT = "prefix_except_default";
+const STRATEGY_PREFIX_AND_DEFAULT = "prefix_and_default";
+const STRATEGY_NO_PREFIX = "no_prefix";
+const STRATEGIES = {
+  PREFIX: STRATEGY_PREFIX,
+  PREFIX_EXCEPT_DEFAULT: STRATEGY_PREFIX_EXCEPT_DEFAULT,
+  PREFIX_AND_DEFAULT: STRATEGY_PREFIX_AND_DEFAULT,
+  NO_PREFIX: STRATEGY_NO_PREFIX
+};
+const DEFAULT_OPTIONS = {
+  vueI18n: void 0,
+  locales: [],
+  defaultLocale: "",
+  defaultDirection: "ltr",
+  routesNameSeparator: "___",
+  trailingSlash: false,
+  defaultLocaleRouteNameSuffix: "default",
+  strategy: STRATEGY_PREFIX_EXCEPT_DEFAULT,
+  langDir: null,
+  baseUrl: "",
+  pages: {}
+};
+
+function getNormalizedLocales(locales) {
+  locales = locales || [];
+  const normalized = [];
+  for (const locale of locales) {
+    if (isString(locale)) {
+      normalized.push({ code: locale });
+    } else {
+      normalized.push(locale);
+    }
+  }
+  return normalized;
+}
+async function resolveLocales(path, locales) {
+  const files = await resolveFiles(path, "**/*{json,json5,yaml,yml}");
+  return files.map((file) => {
+    const parsed = parse(file);
+    const locale = findLocales(locales, parsed.base);
+    return locales == null ? {
+      path: file,
+      file: parsed.base,
+      code: parsed.name
+    } : Object.assign({ path: file }, locale);
+  });
+}
+function findLocales(locales, filename) {
+  const ret = locales.find((locale) => isObject(locale) && locale.file === filename);
+  return ret != null ? ret : null;
+}
+
+const debug$2 = createDebug("@nuxtjs/i18n:pages");
+function setupPages(options, nuxt, additionalOptions = {
+  isBridge: false,
+  localeCodes: []
+}) {
+  const { isBridge } = additionalOptions;
+  let includeUprefixedFallback = nuxt.options.target === "static";
+  nuxt.hook("generate:before", () => {
+    debug$2("called generate:before hook");
+    includeUprefixedFallback = true;
+  });
+  const pagesDir = nuxt.options.dir && nuxt.options.dir.pages ? nuxt.options.dir.pages : "pages";
+  const { trailingSlash } = nuxt.options.router;
+  debug$2(`pagesDir: ${pagesDir}, tailingSlash: ${trailingSlash}`);
+  extendPages((pages) => {
+    const localizedPages = localizeRoutes(pages, {
+      ...options,
+      includeUprefixedFallback,
+      optionsResolver: getRouteOptionsResolver(options.pages, pagesDir, options.defaultLocale)
+    });
+    if (isBridge) {
+      pages.splice(0, pages.length);
+      pages.unshift(...localizedPages);
+    } else {
+      localizedPages.forEach((page) => pages.push(page));
+    }
+    debug$2("made pages ...", pages);
+  });
+}
+function getRouteOptionsResolver(pages, pagesDir, defaultLocale) {
+  return (route, localeCodes) => {
+    const options = {
+      locales: localeCodes,
+      paths: {}
+    };
+    const pattern = new RegExp(`${pagesDir}/`, "i");
+    const chunkName = route.chunkName ? route.chunkName.replace(pattern, "") : route.name;
+    const pageOptions = chunkName ? pages[chunkName] : void 0;
+    if (pageOptions === false) {
+      return null;
+    }
+    if (!pageOptions) {
+      return options;
+    }
+    options.locales = options.locales.filter((locale) => pageOptions[locale] !== false);
+    for (const locale of options.locales) {
+      const customLocalePath = pageOptions[locale];
+      if (typeof customLocalePath === "string") {
+        options.paths[locale] = customLocalePath;
+        continue;
+      }
+      const customDefaultLocalePath = pageOptions[defaultLocale];
+      if (typeof customDefaultLocalePath === "string") {
+        options.paths[locale] = customDefaultLocalePath;
+      }
+    }
+    return options;
+  };
+}
+
+const debug$1 = createDebug("@nuxtjs/i18n:gen");
+function generateLoaderOptions(options = {}) {
+  const genCode = `${Object.entries(options).map(([rootKey, rootValue]) => {
+    if (rootKey === "nuxtI18nOptions") {
+      return `export const ${rootKey} = Object({${Object.entries(rootValue).map(([key, value]) => {
+        if (key === "vueI18n") {
+          return `${key}: ${isObject(value) ? toCode(value) : isString(value) ? `(context) => import(${toCode(value)}).then(r => (r.default || r)(context))` : `${toCode({})}`}`;
+        } else {
+          return `${key}: ${toCode(value)}`;
+        }
+      }).join(`,`)}})`;
+    } else if (rootKey === "localeInfo") {
+      const localeInfo = options.localeInfo || [];
+      const importMapper =  new Map();
+      localeInfo.forEach(({ code }) => {
+        importMapper.set(code, templateUtils.importName(`locale_${code}`));
+      });
+      return `${localeInfo.map((l) => genImport(l.path, importMapper.get(l.code))).join(`
+`)}
+export const messages = () => Promise.resolve(Object({${[...importMapper].map((i) => `${templateUtils.serialize(i[0])}:${i[1]}`).join(`,`)}}))`;
+    } else {
+      return `export const ${rootKey} = ${toCode(rootValue)}`;
+    }
+  }).join("\n")}`;
+  debug$1("generate code", genCode);
+  return genCode;
+}
+function stringifyObj(obj) {
+  return `Object({${Object.entries(obj).map(([key, value]) => `${JSON.stringify(key)}:${toCode(value)}`).join(`,`)}})`;
+}
+function toCode(code) {
+  if (code === null) {
+    return `null`;
+  }
+  if (code === void 0) {
+    return `undefined`;
+  }
+  if (isString(code)) {
+    return JSON.stringify(code);
+  }
+  if (isRegExp(code) && code.toString) {
+    return code.toString();
+  }
+  if (isFunction(code) && code.toString) {
+    return `(${code.toString()})`;
+  }
+  if (isArray(code)) {
+    return `[${code.map((c) => toCode(c)).join(`,`)}]`;
+  }
+  if (isObject(code)) {
+    return stringifyObj(code);
+  }
+  return code + ``;
+}
+
+const debug = createDebug("@nuxtjs/i18n:module");
+const module = defineNuxtModule({
+  meta: {
+    name: "@nuxtjs/i18n",
+    configKey: "i18n"
+  },
+  defaults: {},
+  async setup(i18nOptions, nuxt) {
+    const options = defu(i18nOptions, DEFAULT_OPTIONS);
+    options.langDir = options.langDir || "locales";
+    debug("options", options);
+    if (isNuxt2(nuxt)) {
+      await setupNuxtBridge(nuxt);
+    } else if (isNuxt3(nuxt)) {
+      await setupNuxt3(nuxt);
+    } else {
+      throw new Error(`Cannot support nuxt version: ${getNuxtVersion(nuxt)}`);
+    }
+    const langPath = resolve(nuxt.options.srcDir, options.langDir);
+    debug("langDir path", langPath);
+    const normalizedLocales = options.locales = getNormalizedLocales(options.locales);
+    const hasLocaleFiles = normalizedLocales.length > 0;
+    const localeCodes = normalizedLocales.map((locale) => locale.code);
+    const localeInfo = await resolveLocales(langPath, normalizedLocales);
+    debug("localeInfo", localeInfo);
+    options.vueI18n = isObject(options.vueI18n) ? options.vueI18n : isString(options.vueI18n) ? resolve(nuxt.options.rootDir, options.vueI18n) : {};
+    if (options.strategy !== STRATEGIES.NO_PREFIX && localeCodes.length) {
+      await setupPages(options, nuxt, { isBridge: isNuxt2(nuxt), localeCodes });
+    }
+    nuxt.options.alias["@intlify/shared"] = resolveModule("@intlify/shared/dist/shared.esm-bundler.js", {
+      paths: nuxt.options.modulesDir
+    });
+    nuxt.options.build.transpile.push("@intlify/shared");
+    nuxt.options.alias["vue-i18n-routing"] = resolveModule("vue-i18n-routing/dist/vue-i18n-routing.es.js", {
+      paths: nuxt.options.modulesDir
+    });
+    nuxt.options.build.transpile.push("vue-i18n-routing");
+    addTemplate({
+      filename: "i18n.options.mjs",
+      getContents: () => {
+        return generateLoaderOptions({ localeCodes, localeInfo, nuxtI18nOptions: options });
+      }
+    });
+    await setupAutoImports();
+    await extendBundler(hasLocaleFiles, langPath);
+  }
+});
+
+export { module as default };

package/dist/runtime/bridge.plugin.d.ts

@@ -0,0 +1 @@
+export default function (context: any, inject: any): Promise<void>;

package/dist/runtime/bridge.plugin.mjs

@@ -0,0 +1,54 @@
+import Vue from "vue";
+import { install, ref, computed } from "vue-demi";
+import VueI18n from "vue-i18n";
+import { createI18n } from "vue-i18n-bridge";
+import { createLocaleFromRouteGetter, resolveBaseUrl } from "vue-i18n-routing";
+import { isEmptyObject } from "@intlify/shared";
+import {
+  messages as loadMessages,
+  localeCodes,
+  nuxtI18nOptions
+} from "#build/i18n.options.mjs";
+install();
+const getLocaleFromRoute = createLocaleFromRouteGetter(localeCodes, nuxtI18nOptions.routesNameSeparator, nuxtI18nOptions.defaultLocaleRouteNameSuffix);
+export default async function(context, inject) {
+  console.log("bridge.plugin setup", context);
+  Vue.use(VueI18n, { bridge: true });
+  const messages = await loadMessages();
+  if (!isEmptyObject(messages)) {
+    nuxtI18nOptions.vueI18n.messages = messages;
+  }
+  const initialLocale = nuxtI18nOptions.vueI18n.locale;
+  const i18n = createI18n({
+    legacy: false,
+    globalInjection: true,
+    ...nuxtI18nOptions.vueI18n,
+    locale: nuxtI18nOptions.defaultLocale
+  }, VueI18n);
+  Vue.use(i18n);
+  const global = i18n.global;
+  const _locales = ref(nuxtI18nOptions.locales);
+  const _localeCodes = ref(localeCodes);
+  global.locales = computed(() => _locales.value);
+  global.localeCodes = computed(() => _localeCodes.value);
+  global.__baseUrl = resolveBaseUrl(nuxtI18nOptions.baseUrl, {});
+  inject("i18n", global);
+  context.app.i18n = global;
+  if (i18n.mode === "composition" && process.client) {
+    ;
+    ["t", "d", "n"].forEach((key) => inject(key, (...args) => Reflect.apply(composer[key], composer, [...args])));
+  }
+  if (process.client) {
+    context.app.router.beforeEach(async (to, from, next) => {
+      const currentLocale = global.locale.value;
+      const finalLocale = getLocaleFromRoute(to) || nuxtI18nOptions.defaultLocale || initialLocale;
+      if (currentLocale !== finalLocale) {
+        global.locale.value = finalLocale;
+      }
+      next();
+    });
+  } else {
+    const finalLocale = getLocaleFromRoute(context.route) || nuxtI18nOptions.defaultLocale || initialLocale;
+    global.locale.value = finalLocale;
+  }
+}

package/dist/runtime/nuxt3.plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/nuxt3.plugin.mjs

@@ -0,0 +1,46 @@
+import { ref, computed } from "vue-demi";
+import { createI18n } from "vue-i18n";
+import { isEmptyObject } from "@intlify/shared";
+import { createLocaleFromRouteGetter, resolveBaseUrl } from "vue-i18n-routing";
+import { defineNuxtPlugin } from "#app";
+import {
+  messages as loadMessages,
+  localeCodes,
+  nuxtI18nOptions
+} from "#build/i18n.options.mjs";
+const getLocaleFromRoute = createLocaleFromRouteGetter(localeCodes, nuxtI18nOptions.routesNameSeparator, nuxtI18nOptions.defaultLocaleRouteNameSuffix);
+export default defineNuxtPlugin(async (nuxt) => {
+  const { vueApp: app } = nuxt;
+  console.log("nuxt.plugin setup", nuxt);
+  const messages = await loadMessages();
+  if (!isEmptyObject(messages)) {
+    nuxtI18nOptions.vueI18n.messages = messages;
+  }
+  const initialLocale = nuxtI18nOptions.vueI18n.locale;
+  const i18n = createI18n({
+    legacy: false,
+    globalInjection: true,
+    ...nuxtI18nOptions.vueI18n,
+    locale: nuxtI18nOptions.defaultLocale
+  });
+  const global = i18n.global;
+  const _locales = ref(nuxtI18nOptions.locales);
+  const _localeCodes = ref(localeCodes);
+  global.locales = computed(() => _locales.value);
+  global.localeCodes = computed(() => _localeCodes.value);
+  global.__baseUrl = resolveBaseUrl(nuxtI18nOptions.baseUrl, {});
+  app.use(i18n);
+  nuxt.provide("i18n", global);
+  if (process.client) {
+    addRouteMiddleware("locale-changing", (to, from) => {
+      const currentLocale = global.locale.value;
+      const finalLocale = getLocaleFromRoute(to) || nuxtI18nOptions.defaultLocale || initialLocale;
+      if (currentLocale !== finalLocale) {
+        global.locale.value = finalLocale;
+      }
+    }, { global: true });
+  } else {
+    const finalLocale = getLocaleFromRoute(nuxt.ssrContext.url) || nuxtI18nOptions.defaultLocale || initialLocale;
+    global.locale.value = finalLocale;
+  }
+});

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+
+import {  } from './module'
+
+
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nuxtjs/i18n-edge",
+  "description": "i18n for Nuxt",
+  "version": "8.0.0-alpha.0-27419678.39bcf0f",
+  "homepage": "https://i18n.nuxtjs.org",
+  "bugs": {
+    "url": "https://github.com/nuxt-community/i18n-module/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuxt-community/i18n-module.git",
+    "directory": "packages/nuxt-i18n"
+  },
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Paul Gascou-Vaillancourt (@paulgv)"
+    },
+    {
+      "name": "Rafal Chlodnicki (@rchl)"
+    },
+    {
+      "name": "Kazuya Kawaguchi (@kazupon)"
+    }
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "nuxt-module-build",
+    "stub": "nuxt-module-build --stub",
+    "postinstall": "node ./scripts/postinstall.mjs"
+  },
+  "dependencies": {
+    "@intlify/shared": "next",
+    "@intlify/vite-plugin-vue-i18n": "next",
+    "@intlify/vue-i18n-loader": "next",
+    "@nuxt/kit": "npm:@nuxt/kit-edge@3.0.0-27398533.8edd481",
+    "debug": "^4.3.2",
+    "defu": "latest",
+    "knitwork": "^0.1.0",
+    "mlly": "^0.3.19",
+    "pathe": "^0.2.0",
+    "vue-i18n": "beta",
+    "vue-i18n-bridge": "beta",
+    "vue-i18n-legacy": "npm:vue-i18n@8",
+    "vue-i18n-routing": "edge"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "latest",
+    "@nuxt/schema": "npm:@nuxt/schema-edge@3.0.0-27398533.8edd481",
+    "@types/debug": "^4.1.7",
+    "nuxt3": "latest"
+  },
+  "engines": {
+    "node": "^14.16.0 || ^16.11.0 || ^17.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,8 @@
+import { loadModule } from './utils.mjs'
+;(async () => {
+  const Vue = loadModule('vue')
+  if (Vue && Vue.version.startsWith('2.')) {
+    const { switchVersion } = loadModule('@intlify/vue-i18n-bridge/scripts/utils.js')
+    switchVersion(8, 'vue-i18n-legacy')
+  }
+})()

package/scripts/utils.mjs

@@ -0,0 +1,38 @@
+// import { pathToFileURL } from 'url'
+import { createCommonJS } from 'mlly'
+
+const NUXT_I18N_ID = '@nuxtjs/i18n'
+
+const cjs = createCommonJS(import.meta.url)
+
+/*
+const _default = r => r.default || r
+
+// FIXME: https://github.com/microsoft/TypeScript/issues/43329
+// module: node12 will be replace it
+const _importDynamic = new Function('modulePath', 'return import(modulePath)')
+function importModule(path) {
+  return _importDynamic(pathToFileURL(path).href).then(_default)
+}
+*/
+
+export function loadModule(name) {
+  try {
+    return cjs.require(name)
+  } catch (e) {
+    err(e)
+    return undefined
+  }
+}
+
+export function err(...args) {
+  console.error(`[${NUXT_I18N_ID}] `, ...args)
+}
+
+export function warn(...args) {
+  console.warn(`[${NUXT_I18N_ID}] `, ...args)
+}
+
+export function log(...args) {
+  console.log(`[${NUXT_I18N_ID}] `, ...args)
+}