文件操作 - module.mjs

文件: /var/www/OLD/node_modules/@nuxtjs/i18n/dist/module.mjs

编辑文件内容

import { tryResolveModule, resolvePath, useNuxt, useLogger, addTemplate, addBuildPlugin, addWebpackPlugin, extendViteConfig, addServerImports, addServerPlugin, createResolver, addPlugin, addTypeTemplate, addComponent, addImports, addServerHandler, useNitro, updateTemplates, isIgnored, defineNuxtModule } from '@nuxt/kit';
import createDebug from 'debug';
import { isString, isArray, isRegExp, isFunction, isObject } from '@intlify/shared';
import { parse as parse$2, compileScript } from '@vue/compiler-sfc';
import { walk } from 'estree-walker';
import { mkdir, readFile, writeFile } from 'node:fs/promises';
import MagicString from 'magic-string';
import { readFileSync as readFileSync$1, promises, constants } from 'node:fs';
import { createHash } from 'node:crypto';
import { resolve, parse, join as join$1, relative, isAbsolute, dirname, normalize } from 'pathe';
import { parse as parse$1 } from '@babel/parser';
import { defu } from 'defu';
import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
import { transform } from 'sucrase';
import { encodePath, parseURL, parseQuery, withQuery } from 'ufo';
import { createRoutesContext } from 'unplugin-vue-router';
import { resolveOptions } from 'unplugin-vue-router/options';
import { resolveModuleExportNames } from 'mlly';
import yamlPlugin from '@rollup/plugin-yaml';
import json5Plugin from '@miyaneee/rollup-plugin-json5';
import VueI18nPlugin from '@intlify/unplugin-vue-i18n';
import { createUnplugin } from 'unplugin';
import { pathToFileURL, fileURLToPath } from 'node:url';
import { watch } from 'chokidar';

export interface TypesConfig {
    RouteNamedMapI18n: RouteNamedMapI18n
  }
}

export {}`;
    }
  });
  nuxt.hook("prepare:types", ({ references }) => {
    references.push({ path: declarationFile });
    references.push({ types: "./types/i18n-generated-route-types.d.ts" });
  });
  await createContext(nuxt.apps.default?.pages ?? []).scanPages(false);
  return { createContext };
}
function analyzePagePath(pagePath, parents = 0) {
  const { dir, name } = parse(pagePath);
  if (parents > 0 || dir !== "/") {
    return `${dir.slice(1, dir.length)}/${name}`;
  }
  return name;
}
function analyzeNuxtPages(ctx, pages, pageDirOverride) {
  if (pages == null || pages.length === 0)
    return;
  const pagesPath = resolve(ctx.srcDir, pageDirOverride ?? ctx.pagesDir);
  for (const page of pages) {
    if (page.file == null)
      continue;
    const splits = page.file.split(pagesPath);
    const filePath = splits.at(1);
    if (filePath == null)
      continue;
    ctx.pages.set(page, {
      path: analyzePagePath(filePath, ctx.stack.length),
      // if route has an index child the parent will not have a name
      name: page.name ?? page.children?.find((x) => x.path.endsWith("/index"))?.name,
      inRoot: ctx.stack.length === 0
    });
    ctx.stack.push(page.path);
    analyzeNuxtPages(ctx, page.children, pageDirOverride);
    ctx.stack.pop();
  }
}
function getRouteOptionsResolver(ctx, options) {
  const { pages, defaultLocale, customRoutes } = options;
  const useConfig = customRoutes === "config";
  debug$8("getRouteOptionsResolver useConfig", useConfig);
  return (route, localeCodes) => {
    const ret = useConfig ? getRouteOptionsFromPages(ctx, route, localeCodes, pages, defaultLocale) : getRouteOptionsFromComponent(route, localeCodes);
    debug$8("getRouteOptionsResolver resolved", route.path, route.name, ret);
    return ret;
  };
}
function resolveRoutePath(path) {
  const normalizePath = path.slice(1, path.length);
  const tokens = parseSegment(normalizePath);
  const routePath = getRoutePath(tokens);
  return routePath;
}
function getRouteOptionsFromPages(ctx, route, localeCodes, pages, defaultLocale) {
  const options = {
    locales: localeCodes,
    paths: {}
  };
  const pageMeta = ctx.pages.get(route);
  if (pageMeta == null) {
    console.warn(
      formatMessage(`Couldn't find AnalyzedNuxtPageMeta by NuxtPage (${route.path}), so no custom route for it`)
    );
    return options;
  }
  const valueByName = pageMeta.name ? pages[pageMeta.name] : undefined;
  const pageOptions = valueByName ?? pages[pageMeta.path];
  if (pageOptions === false) {
    return undefined;
  }
  if (!pageOptions) {
    return options;
  }
  options.locales = options.locales.filter((locale) => pageOptions[locale] !== false);
  for (const locale of options.locales) {
    const customLocalePath = pageOptions[locale];
    if (isString(customLocalePath)) {
      options.paths[locale] = resolveRoutePath(customLocalePath);
      continue;
    }
    const customDefaultLocalePath = pageOptions[defaultLocale];
    if (isString(customDefaultLocalePath)) {
      options.paths[locale] = resolveRoutePath(customDefaultLocalePath);
    }
  }
  return options;
}
function getRouteOptionsFromComponent(route, localeCodes) {
  debug$8("getRouteOptionsFromComponent", route);
  const file = route.file;
  if (!isString(file)) {
    return undefined;
  }
  const options = {
    locales: localeCodes,
    paths: {}
  };
  const componentOptions = readComponent(file);
  if (componentOptions == null) {
    return options;
  }
  if (componentOptions === false) {
    return undefined;
  }
  options.locales = componentOptions.locales || localeCodes;
  for (const [locale, path] of Object.entries(componentOptions.paths ?? {})) {
    if (isString(path)) {
      options.paths[locale] = resolveRoutePath(path);
    }
  }
  return options;
}
function readComponent(target) {
  let options = undefined;
  try {
    const content = readFileSync(target);
    const { descriptor } = parse$2(content);
    if (!content.includes(NUXT_I18N_COMPOSABLE_DEFINE_ROUTE)) {
      return options;
    }
    const desc = compileScript(descriptor, { id: target });
    const { scriptSetupAst, scriptAst } = desc;
    let extract = "";
    const genericSetupAst = scriptSetupAst || scriptAst;
    if (genericSetupAst) {
      const s = new MagicString(desc.loc.source);
      genericSetupAst.forEach((ast) => {
        walk(ast, {
          enter(_node) {
            const node = _node;
            if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === NUXT_I18N_COMPOSABLE_DEFINE_ROUTE) {
              const arg = node.arguments[0];
              if (arg.type === "ObjectExpression") {
                if (verifyObjectValue(arg.properties) && arg.start != null && arg.end != null) {
                  extract = s.slice(arg.start, arg.end);
                }
              } else if (arg.type === "BooleanLiteral" && arg.start != null && arg.end != null) {
                extract = s.slice(arg.start, arg.end);
              }
            }
          }
        });
      });
    }
    if (extract) {
      options = evalValue(extract);
    }
  } catch (e) {
    console.warn(formatMessage(`Couldn't read component data at ${target}: (${e.message})`));
  }
  return options;
}
function verifyObjectValue(properties) {
  let ret = true;
  for (const prop of properties) {
    if (prop.type === "ObjectProperty") {
      if (prop.key.type === "Identifier" && prop.key.name === "locales" || prop.key.type === "StringLiteral" && prop.key.value === "locales") {
        if (prop.value.type === "ArrayExpression") {
          ret = verifyLocalesArrayExpression(prop.value.elements);
        } else {
          console.warn(formatMessage(`'locale' value is required array`));
          ret = false;
        }
      } else if (prop.key.type === "Identifier" && prop.key.name === "paths" || prop.key.type === "StringLiteral" && prop.key.value === "paths") {
        if (prop.value.type === "ObjectExpression") {
          ret = verifyPathsObjectExpress(prop.value.properties);
        } else {
          console.warn(formatMessage(`'paths' value is required object`));
          ret = false;
        }
      }
    } else {
      console.warn(formatMessage(`'defineI18nRoute' is required object`));
      ret = false;
    }
  }
  return ret;
}
function verifyPathsObjectExpress(properties) {
  let ret = true;
  for (const prop of properties) {
    if (prop.type === "ObjectProperty") {
      if (prop.key.type === "Identifier" && prop.value.type !== "StringLiteral") {
        console.warn(formatMessage(`'paths.${prop.key.name}' value is required string literal`));
        ret = false;
      } else if (prop.key.type === "StringLiteral" && prop.value.type !== "StringLiteral") {
        console.warn(formatMessage(`'paths.${prop.key.value}' value is required string literal`));
        ret = false;
      }
    } else {
      console.warn(formatMessage(`'paths' is required object`));
      ret = false;
    }
  }
  return ret;
}
function verifyLocalesArrayExpression(elements) {
  let ret = true;
  for (const element of elements) {
    if (element?.type !== "StringLiteral") {
      console.warn(formatMessage(`required 'locales' value string literal`));
      ret = false;
    }
  }
  return ret;
}
function evalValue(value) {
  try {
    return new Function(`return (${value})`)();
  } catch (_e) {
    console.error(formatMessage(`Cannot evaluate value: ${value}`));
    return;
  }
}

const debugLogger = createConsola({ level: ${debug === "verbose" ? 999 : 4} }).withTag('i18n')

export function createLogger(label) {
  return debugLogger.withTag(label)
}`;
    }
  };
});

const debug$2 = createDebug("@nuxtjs/i18n:context");
const resolver = createResolver(import.meta.url);
function createContext(userOptions, nuxt) {
  const options = userOptions;
  return {
    resolver,
    logger: useLogger(NUXT_I18N_MODULE_ID),
    debug: debug$2,
    userOptions,
    options,
    isDev: nuxt.options.dev,
    isSSR: nuxt.options.ssr,
    isPrepare: nuxt.options._prepare,
    isSSG: nuxt.options._generate,
    isBuild: nuxt.options._build,
    isTest: nuxt.options.test,
    genTemplate: undefined,
    normalizedLocales: undefined,
    localeCodes: undefined,
    localeInfo: undefined,
    vueI18nConfigPaths: undefined
  };
}

async function resolveLocaleInfo(ctx, nuxt) {
  const { options, debug } = ctx;
  const normalizedLocales = getNormalizedLocales(options.locales);
  const localeCodes = normalizedLocales.map((locale) => locale.code);
  const localeInfo = await resolveLocales(nuxt.options.srcDir, normalizedLocales, nuxt.options.buildDir);
  debug("localeInfo", localeInfo);
  const vueI18nConfigPaths = await resolveLayerVueI18nConfigInfo(options);
  debug("VueI18nConfigPaths", vueI18nConfigPaths);
  ctx.normalizedLocales = normalizedLocales;
  ctx.localeCodes = localeCodes;
  ctx.localeInfo = localeInfo;
  ctx.vueI18nConfigPaths = vueI18nConfigPaths;
}

function generateTemplateNuxtI18nOptions(options) {
  return `
// @ts-nocheck
${options.importStrings.length > 0 ? options.importStrings.join("\n") + "\n" : ""}

export const localeCodes =  ${JSON.stringify(options.localeCodes, null, 2)}

export const localeLoaders = {
${options.localeLoaders.map(([key, val]) => {
    return `  "${key}": [${val.map((entry) => `{ key: ${entry.key}, load: ${entry.load}, cache: ${entry.cache} }`).join(",\n")}]`;
  }).join(",\n")}
}

export const vueI18nConfigs = [
  ${options.vueI18nConfigs.length > 0 ? options.vueI18nConfigs.join(",\n  ") : ""}
]

export const nuxtI18nOptions = ${JSON.stringify(options.nuxtI18nOptions, null, 2)}

export const normalizedLocales = ${JSON.stringify(options.normalizedLocales, null, 2)}

export const NUXT_I18N_MODULE_ID = "${NUXT_I18N_MODULE_ID}"
export const parallelPlugin = ${options.parallelPlugin}
export const isSSG = ${options.isSSG}
export const hasPages = ${options.hasPages}

export const DEFAULT_DYNAMIC_PARAMS_KEY = ${JSON.stringify(DEFAULT_DYNAMIC_PARAMS_KEY)}
export const DEFAULT_COOKIE_KEY = ${JSON.stringify(DEFAULT_COOKIE_KEY)}
export const SWITCH_LOCALE_PATH_LINK_IDENTIFIER = ${JSON.stringify(SWITCH_LOCALE_PATH_LINK_IDENTIFIER)}
`;
}

const debug$1 = createDebug("@nuxtjs/i18n:dirs");
const distDir = dirname(fileURLToPath(import.meta.url));
const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
const pkgDir = resolve(distDir, "..");
debug$1("distDir", distDir);
debug$1("runtimeDir", runtimeDir);
debug$1("pkgDir", pkgDir);

export interface TypesConfig {
    RouteNamedMapI18n: RouteNamedMapI18n
  }

export type RouteMapI18n =
    TypesConfig extends Record<'RouteNamedMapI18n', infer RouteNamedMap> ? RouteNamedMap : RouteMapGeneric
    
  // Prefer named resolution for i18n
  export type RouteLocationNamedI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
      | Name
      | Omit<RouteLocationAsRelativeI18n, 'path'> & { path?: string }
      /**
       * Note: disabled route path string autocompletion, this can break depending on \`strategy\`
       * this can be enabled again after route resolve has been improved.
      */
      // | RouteLocationAsStringI18n
      // | RouteLocationAsPathI18n

export type RouteLocationRawI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n
      ? RouteLocationAsStringI18n | RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric
      :
          | _LiteralUnion<RouteLocationAsStringTypedList<RouteMapI18n>[Name], string>
          | RouteLocationAsRelativeTypedList<RouteMapI18n>[Name]

export type RouteLocationResolvedI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n
      ? RouteLocationResolvedGeneric
      : RouteLocationResolvedTypedList<RouteMapI18n>[Name]

export interface RouteLocationNormalizedLoadedTypedI18n<
    RouteMapI18n extends RouteMapGeneric = RouteMapGeneric,
    Name extends keyof RouteMapI18n = keyof RouteMapI18n
  > extends RouteLocationNormalizedLoadedGeneric {
    name: Extract<Name, string | symbol>
    params: RouteMapI18n[Name]['params']
  }
  export type RouteLocationNormalizedLoadedTypedListI18n<RouteMapOriginal extends RouteMapGeneric = RouteMapGeneric> = {
    [N in keyof RouteMapOriginal]: RouteLocationNormalizedLoadedTypedI18n<RouteMapOriginal, N>
  }
  export type RouteLocationNormalizedLoadedI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n
      ? RouteLocationNormalizedLoadedGeneric
      : RouteLocationNormalizedLoadedTypedListI18n<RouteMapI18n>[Name]

type _LiteralUnion<LiteralType, BaseType extends string = string> = LiteralType | (BaseType & Record<never, never>)

export type RouteLocationAsStringI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n
      ? string
      : _LiteralUnion<RouteLocationAsStringTypedList<RouteMapI18n>[Name], string>

export type RouteLocationAsRelativeI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n
      ? RouteLocationAsRelativeGeneric
      : RouteLocationAsRelativeTypedList<RouteMapI18n>[Name]

export type RouteLocationAsPathI18n<Name extends keyof RouteMapI18n = keyof RouteMapI18n> =
    RouteMapGeneric extends RouteMapI18n ? RouteLocationAsPathGeneric : RouteLocationAsPathTypedList<RouteMapI18n>[Name]

/**
   * Helper to generate a type safe version of the {@link RouteLocationAsRelative} type.
   */
  export interface RouteLocationAsRelativeTypedI18n<
    RouteMapI18n extends RouteMapGeneric = RouteMapGeneric,
    Name extends keyof RouteMapI18n = keyof RouteMapI18n
  > extends RouteLocationAsRelativeGeneric {
    name?: Extract<Name, string | symbol>
    params?: RouteMapI18n[Name]['paramsRaw']
  }
}`;
function generateI18nTypes(nuxt, options) {
  const vueI18nTypes = options.types === "legacy" ? ["VueI18n"] : ["ExportedGlobalComposer", "Composer"];
  const generatedLocales = simplifyLocaleOptions(nuxt, options);
  const resolvedLocaleType = typeof generatedLocales === "string" ? "Locale[]" : "LocaleObject[]";
  const localeCodeStrings = getNormalizedLocales(options.locales).map((x) => JSON.stringify(x.code));
  const narrowedLocaleType = localeCodeStrings.join(" | ") || "string";
  const i18nType = `${vueI18nTypes.join(" & ")} & NuxtI18nRoutingCustomProperties<${resolvedLocaleType}>`;
  const globalTranslationTypes = `
declare global {
  var $t: (${i18nType})['t']
  var $rt: (${i18nType})['rt']
  var $n: (${i18nType})['n']
  var $d: (${i18nType})['d']
  var $tm: (${i18nType})['tm']
  var $te: (${i18nType})['te']
}`;
  return `// Generated by @nuxtjs/i18n
import type { ${vueI18nTypes.join(", ")} } from 'vue-i18n'
import type { NuxtI18nRoutingCustomProperties, ComposerCustomProperties } from '${relative(
    join$1(nuxt.options.buildDir, "types"),
    resolve(runtimeDir, "types.ts")
  )}'
import type { Strategies, Directions, LocaleObject } from '${relative(
    join$1(nuxt.options.buildDir, "types"),
    resolve(distDir, "types.d.ts")
  )}'

declare module 'vue-i18n' {
  interface ComposerCustom extends ComposerCustomProperties<${resolvedLocaleType}> {}
  interface ExportedGlobalComposer extends NuxtI18nRoutingCustomProperties<${resolvedLocaleType}> {}
  interface VueI18n extends NuxtI18nRoutingCustomProperties<${resolvedLocaleType}> {}
}

declare module '@intlify/core-base' {
  // generated based on configured locales
  interface GeneratedTypeConfig { 
    locale: ${narrowedLocaleType}
  }
}

declare module '#app' {
  interface NuxtApp {
    $i18n: ${i18nType}
  }
}

${typedRouterAugmentations}

${options.experimental?.autoImportTranslationFunctions && globalTranslationTypes || ""}

export {}`;
}

function prepareRuntimeConfig({ options }, nuxt) {
  nuxt.options.runtimeConfig.public.i18n = defu(nuxt.options.runtimeConfig.public.i18n, {
    baseUrl: options.baseUrl,
    defaultLocale: options.defaultLocale,
    defaultDirection: options.defaultDirection,
    strategy: options.strategy,
    lazy: options.lazy,
    rootRedirect: options.rootRedirect,
    routesNameSeparator: options.routesNameSeparator,
    defaultLocaleRouteNameSuffix: options.defaultLocaleRouteNameSuffix,
    skipSettingLocaleOnNavigate: options.skipSettingLocaleOnNavigate,
    differentDomains: options.differentDomains,
    trailingSlash: options.trailingSlash,
    locales: options.locales,
    detectBrowserLanguage: options.detectBrowserLanguage ?? DEFAULT_OPTIONS.detectBrowserLanguage,
    experimental: options.experimental,
    multiDomainLocales: options.multiDomainLocales
    // TODO: we should support more i18n module options. welcome PRs :-)
  });
}

async function prepareAutoImports({ debug }, nuxt) {
  const vueI18nPath = nuxt.options.alias[VUE_I18N_PKG];
  debug("vueI18nPath for auto-import", vueI18nPath);
  await Promise.all([
    addComponent({
      name: "NuxtLinkLocale",
      filePath: resolve(runtimeDir, "components/NuxtLinkLocale")
    }),
    addComponent({
      name: "SwitchLocalePathLink",
      filePath: resolve(runtimeDir, "components/SwitchLocalePathLink")
    })
  ]);
  addImports([
    { name: "useI18n", from: vueI18nPath },
    ...[
      "useRouteBaseName",
      "useLocalePath",
      "useLocaleRoute",
      "useSwitchLocalePath",
      "useLocaleHead",
      "useBrowserLocale",
      "useCookieLocale",
      "useSetI18nParams",
      NUXT_I18N_COMPOSABLE_DEFINE_ROUTE,
      NUXT_I18N_COMPOSABLE_DEFINE_LOCALE,
      NUXT_I18N_COMPOSABLE_DEFINE_CONFIG
    ].map((key) => ({
      name: key,
      as: key,
      from: resolve(runtimeDir, "composables/index")
    }))
  ]);
}

async function prepareLayers({ options }, nuxt) {
  applyLayerOptions(options, nuxt);
  await mergeI18nModules(options, nuxt);
  filterLocales(options, nuxt);
}

function prepareTranspile(nuxt) {
  nuxt.options.build.transpile.push("@nuxtjs/i18n");
  nuxt.options.build.transpile.push("@nuxtjs/i18n-edge");
}

function prepareVite(nuxt) {
  nuxt.options.vite.optimizeDeps = nuxt.options.vite.optimizeDeps || {};
  nuxt.options.vite.optimizeDeps.exclude = nuxt.options.vite.optimizeDeps.exclude || [];
  nuxt.options.vite.optimizeDeps.exclude.push("vue-i18n");
}

interface GeneratedLocaleMessage {
  ${generateInterface(res.messages || {}).trim()}
}

interface GeneratedDateTimeFormat {
  ${Object.keys(res.datetimeFormats || {}).map((k) => `${k}: DateTimeFormatOptions;`).join(`
  `)}
}

interface GeneratedNumberFormat {
  ${Object.entries(res.numberFormats || {}).map(([k]) => `${k}: NumberFormatOptions;`).join(`
  `)}
}

declare module 'vue-i18n' {
  export interface DefineLocaleMessage extends GeneratedLocaleMessage {}
  export interface DefineDateTimeFormat extends GeneratedDateTimeFormat {}
  export interface DefineNumberFormat extends GeneratedNumberFormat {}
}

declare module '@intlify/core' {
  export interface DefineCoreLocaleMessage extends GeneratedLocaleMessage {}
}

export {}`;
    }
  });
  if (nuxt.options.future?.compatibilityVersion === 4 || options.restructureDir === false) {
    const watcher = watch(
      localeInfo.flatMap((x) => x.files.map((f) => resolve(nuxt.options.srcDir, f.path))),
      {
        awaitWriteFinish: true,
        ignoreInitial: true,
        ignored: [isIgnored, "node_modules"]
      }
    );
    watcher.on("all", (event, path) => nuxt.callHook("builder:watch", event, normalize(path)));
    nuxt.hook("close", () => watcher?.close());
  }
  const localePaths = localeInfo.flatMap((x) => x.files.map((f) => relative(nuxt.options.srcDir, f.path)));
  nuxt.hook("builder:watch", async (_, path) => {
    path = relative(nuxt.options.srcDir, resolve(nuxt.options.srcDir, path));
    if (!localePaths.includes(path) && !vueI18nConfigPaths.some((x) => x.absolute.includes(path)))
      return;
    res = await (await fetchMergedOptions()).json();
    await updateTemplates({ filter: (template) => template.filename === "types/i18n-messages.d.ts" });
  });
}

export { module as default };

文件操作 - module.mjs

文件: /var/www/OLD/node_modules/@nuxtjs/i18n/dist/module.mjs

编辑文件内容

修改文件时间

删除文件