@intlify/unplugin-vue-i18n 7.0.0-beta.0 → 7.0.0-beta.2

package/lib/index.mjs

@@ -2,13 +2,17 @@ import { createUnplugin } from 'unplugin';
 import createDebug from 'debug';
 import pc from 'picocolors';
 import path from 'node:path';
-import { normalize, parse } from 'pathe';
-import { isArray, isString, isBoolean, assign, isNumber, isEmptyObject, generateCodeFrame } from '@intlify/shared';
-import { generateJSON, generateYAML, generateJavaScript } from '@intlify/bundle-utils';
+import defu from 'defu';
+import { normalize, resolve, dirname, parse } from 'pathe';
+import { DynamicResourceError, generateJSON, generateYAML, generateJavaScript } from '@intlify/bundle-utils';
+import { assign, isEmptyObject, generateCodeFrame, isBoolean } from '@intlify/shared';
 import { createFilter } from '@rollup/pluginutils';
 import fg from 'fast-glob';
-import { promises } from 'node:fs';
+import fs from 'node:fs';
 import { parse as parse$1 } from 'vue/compiler-sfc';
+import { genSafeVariableName, genImport } from 'knitwork';
+import { findStaticImports } from 'mlly';
+import { createHash } from 'node:crypto';
 import { transformVTDirective } from '@intlify/vue-i18n-extensions';
 import { analyze } from '@typescript-eslint/scope-manager';
 import { parse as parse$2, simpleTraverse, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
@@ -50,54 +54,53 @@ function normalizePath(id) {
   return path.posix.normalize(isWindows ? slash(id) : id);
 }
 
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+const getVueI18nAliasPath = (opts) => {
+  const filename = [
+    opts.module,
+    opts.runtimeOnly ? "runtime" : "",
+    !opts.ssr ? "esm-bundler" : "node",
+    "js"
+  ].filter(Boolean).join(".");
+  return `${opts.module}/dist/${filename}`;
+};
 function resolveOptions(options) {
-  const moduleType = options.module || "vue-i18n";
-  let onlyLocales = [];
-  if (options.onlyLocales) {
-    onlyLocales = isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
-  }
-  let include = options.include;
-  let exclude = void 0;
-  if (include) {
-    if (isArray(include)) {
-      include = include.map((item) => normalize(item));
-    } else if (isString(include)) {
-      include = normalize(include);
-    }
-  } else {
-    exclude = "**/**";
-  }
-  const forceStringify = !!options.forceStringify;
-  const defaultSFCLang = isString(options.defaultSFCLang) ? options.defaultSFCLang : "json";
-  const globalSFCScope = !!options.globalSFCScope;
-  const runtimeOnly = isBoolean(options.runtimeOnly) ? options.runtimeOnly : true;
-  const dropMessageCompiler = !!options.dropMessageCompiler;
-  const fullInstall = moduleType === "vue-i18n" ? isBoolean(options.fullInstall) ? options.fullInstall : true : false;
-  const ssrBuild = !!options.ssr;
-  const allowDynamic = !!options.allowDynamic;
-  const strictMessage = isBoolean(options.strictMessage) ? options.strictMessage : true;
-  const escapeHtml = !!options.escapeHtml;
-  const optimizeTranslationDirective = isString(options.optimizeTranslationDirective) || isArray(options.optimizeTranslationDirective) ? options.optimizeTranslationDirective : !!options.optimizeTranslationDirective;
+  const res = defu(options, {
+    ssr: false,
+    module: "vue-i18n",
+    escapeHtml: false,
+    onlyLocales: [],
+    fullInstall: true,
+    runtimeOnly: true,
+    strictMessage: true,
+    allowDynamic: false,
+    globalSFCScope: false,
+    forceStringify: false,
+    defaultSFCLang: "json",
+    dropMessageCompiler: false,
+    transformI18nBlock: void 0,
+    optimizeTranslationDirective: false
+  });
+  const include = res.include ? toArray(res.include).map((item) => normalize(item)) : void 0;
+  const _exclude = res.exclude ? toArray(res.exclude).map((item) => normalize(item)) : void 0;
+  const exclude = res.include ? _exclude : ["**/**"];
+  const onlyLocales = toArray(res.onlyLocales);
+  const fullInstall = res.module !== "vue-i18n" ? false : res.fullInstall;
+  const optimizeTranslationDirective = typeof res.optimizeTranslationDirective === "boolean" ? res.optimizeTranslationDirective : toArray(res.optimizeTranslationDirective);
   const translationIdentifiers = /* @__PURE__ */ new Map();
-  const transformI18nBlock = typeof options.transformI18nBlock === "function" ? options.transformI18nBlock : null;
+  const vueI18nAliasPath = getVueI18nAliasPath(res);
   return {
+    ...res,
     include,
     exclude,
-    module: moduleType,
-    onlyLocales,
-    forceStringify,
-    defaultSFCLang,
-    globalSFCScope,
-    runtimeOnly,
-    dropMessageCompiler,
     fullInstall,
-    ssrBuild,
-    allowDynamic,
-    strictMessage,
-    escapeHtml,
-    optimizeTranslationDirective,
+    onlyLocales,
+    vueI18nAliasPath,
     translationIdentifiers,
-    transformI18nBlock
+    optimizeTranslationDirective
   };
 }
 
@@ -169,52 +172,84 @@ function getDescriptor(filename, code, options) {
 const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
 const VIRTUAL_PREFIX = "\0";
 const debug$2 = createDebug(resolveNamespace("resource"));
-function resourcePlugin({
-  onlyLocales,
-  include,
-  exclude,
-  module,
-  forceStringify,
-  defaultSFCLang,
-  globalSFCScope,
-  runtimeOnly,
-  dropMessageCompiler,
-  fullInstall,
-  ssrBuild,
-  strictMessage,
-  allowDynamic,
-  escapeHtml,
-  transformI18nBlock
-}, meta) {
-  const filter = createFilter(include, exclude);
-  const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
-    return `${module}/dist/${module}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.js"}`;
+function resourcePlugin(opts, meta) {
+  const _filter = createFilter(opts.include, opts.exclude);
+  const importedResources = /* @__PURE__ */ new Set();
+  const filter = (val) => _filter(val) || importedResources.has(val);
+  debug$2(`vue-i18n alias name: ${opts.module}`);
+  const ctx = {
+    prod: false,
+    sourceMap: false
   };
-  let isProduction = false;
-  let sourceMap = false;
-  const vueI18nAliasName = module;
-  debug$2(`vue-i18n alias name: ${vueI18nAliasName}`);
   let vuePlugin = null;
-  const getSfcParser = () => {
-    return vuePlugin ? getVueCompiler(vuePlugin).parse : parse$1;
-  };
+  const getSfcParser = () => vuePlugin ? getVueCompiler(vuePlugin).parse : parse$1;
+  const resourcePaths = /* @__PURE__ */ new Set();
+  for (const inc of opts.include || []) {
+    for (const resourcePath of fg.sync(inc, { ignore: opts.exclude })) {
+      resourcePaths.add(resourcePath);
+    }
+  }
+  function result(code) {
+    if (meta.framework === "vite") {
+      return { code, map: { mappings: "" } };
+    }
+    return { code };
+  }
+  function sharedWebpackLikePlugin(compiler) {
+    ctx.prod = compiler.options.mode !== "development";
+    ctx.sourceMap = !!compiler.options.devtool;
+    debug$2(
+      `${meta.framework}: isProduction = ${ctx.prod}, sourceMap = ${ctx.sourceMap}`
+    );
+    compiler.options.resolve.alias = {
+      ...compiler.options.resolve.alias,
+      [opts.module]: opts.vueI18nAliasPath
+    };
+    debug$2(`set ${opts.module}: ${opts.vueI18nAliasPath}`);
+    const loader = meta.framework === "webpack" ? loadWebpack : loadRspack;
+    loader().then((mod) => {
+      if (mod) {
+        compiler.options.plugins.push(
+          // @ts-expect-error type issue
+          new mod.DefinePlugin({
+            __VUE_I18N_FULL_INSTALL__: JSON.stringify(opts.fullInstall),
+            __INTLIFY_PROD_DEVTOOLS__: "false"
+          })
+        );
+        debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${opts.fullInstall}'`);
+      } else {
+        debug$2(
+          `ignore vue-i18n feature flags with ${meta.framework}.DefinePlugin`
+        );
+      }
+    }).catch((_e) => {
+      warn(`${meta.framework} not found, please install ${meta.framework}.`);
+    });
+    compiler.options.module.rules.push({
+      test: /\.(json5?|ya?ml)$/,
+      type: "javascript/auto",
+      include: (resource) => filter(resource)
+    });
+  }
+  const supportedFileExtensionsRE = /\.(json5?|ya?ml|[c|m]?[j|t]s)$/;
   return {
     name: resolveNamespace("resource"),
     /**
      * NOTE:
+     * vite: early ('pre') transform for json and SFC's custom blocks
+     * because these are transformed into javascript code by `vite:json` plugin.
      *
-     * For vite, If we have json (including SFC's custom block),
-     * transform it first because it will be transformed into javascript code by `vite:json` plugin.
-     *
-     * For webpack, This plugin will handle with ‘post’, because vue-loader generate the request query.
+     * webpack/rspack: late ('post') transform because we rely on vue-loader to generate the request queries.
      */
     enforce: meta.framework === "vite" ? "pre" : "post",
+    rspack: sharedWebpackLikePlugin,
+    webpack: sharedWebpackLikePlugin,
     vite: {
       config() {
         const defineConfig = {
           define: {
-            __VUE_I18N_FULL_INSTALL__: fullInstall,
-            __INTLIFY_DROP_MESSAGE_COMPILER__: dropMessageCompiler,
+            __VUE_I18N_FULL_INSTALL__: opts.fullInstall,
+            __INTLIFY_DROP_MESSAGE_COMPILER__: opts.dropMessageCompiler,
             __VUE_I18N_PROD_DEVTOOLS__: false
           }
         };
@@ -222,10 +257,7 @@ function resourcePlugin({
         const aliasConfig = {
           resolve: {
             alias: {
-              [vueI18nAliasName]: getVueI18nAliasPath({
-                ssr: ssrBuild,
-                runtimeOnly
-              })
+              [opts.module]: opts.vueI18nAliasPath
             }
           }
         };
@@ -237,10 +269,10 @@ function resourcePlugin({
         if (!checkVuePlugin(vuePlugin)) {
           return;
         }
-        isProduction = config.isProduction;
-        sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
+        ctx.prod = config.isProduction;
+        ctx.sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
         debug$2(
-          `configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`
+          `configResolved: isProduction = ${ctx.prod}, sourceMap = ${ctx.sourceMap}`
         );
         const jsonPlugin = getVitePlugin(config, "vite:json");
         if (jsonPlugin) {
@@ -257,106 +289,6 @@ function resourcePlugin({
             return orgTransform.apply(this, [code, id]);
           };
         }
-        const esbuildPlugin = getVitePlugin(config, "vite:esbuild");
-        if (esbuildPlugin) {
-          const orgTransform = esbuildPlugin.transform;
-          esbuildPlugin.transform = async function(code, id) {
-            const result = await orgTransform.apply(this, [
-              code,
-              id
-            ]);
-            if (result == null) {
-              return result;
-            }
-            const { filename, query } = parseVueRequest(id);
-            if (!query.vue && filter(id) && /\.[c|m]?ts$/.test(id)) {
-              const [_code, inSourceMap] = isString(result) ? [result, void 0] : [result.code, result.map];
-              let langInfo = defaultSFCLang;
-              langInfo = parse(filename).ext;
-              const generate = getGenerator(langInfo);
-              const parseOptions = getOptions(
-                filename,
-                isProduction,
-                query,
-                sourceMap,
-                {
-                  inSourceMap,
-                  isGlobal: globalSFCScope,
-                  allowDynamic,
-                  strictMessage,
-                  escapeHtml,
-                  jit: true,
-                  onlyLocales,
-                  forceStringify
-                }
-              );
-              debug$2("parseOptions", parseOptions);
-              const { code: generatedCode, map } = generate(_code, parseOptions);
-              debug$2("generated code", generatedCode);
-              debug$2("sourcemap", map, sourceMap);
-              if (_code === generatedCode)
-                return;
-              return {
-                code: generatedCode,
-                map: { mappings: "" }
-              };
-            } else {
-              return result;
-            }
-          };
-        }
-      },
-      async handleHotUpdate({ file, server }) {
-        if (/\.(json5?|ya?ml)$/.test(file)) {
-          const module2 = server.moduleGraph.getModuleById(
-            asVirtualId(INTLIFY_BUNDLE_IMPORT_ID, meta.framework)
-          );
-          if (module2) {
-            server.moduleGraph.invalidateModule(module2);
-            return [module2];
-          }
-        }
-      }
-    },
-    webpack(compiler) {
-      isProduction = compiler.options.mode !== "development";
-      sourceMap = !!compiler.options.devtool;
-      debug$2(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
-      compiler.options.resolve = normalizeConfigResolveAlias(
-        compiler.options.resolve,
-        meta.framework
-      );
-      compiler.options.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath({
-        ssr: ssrBuild,
-        runtimeOnly
-      });
-      debug$2(
-        `set ${vueI18nAliasName}: ${getVueI18nAliasPath({
-          ssr: ssrBuild,
-          runtimeOnly
-        })}`
-      );
-      loadWebpack().then((webpack) => {
-        if (webpack) {
-          compiler.options.plugins.push(
-            new webpack.DefinePlugin({
-              __VUE_I18N_FULL_INSTALL__: JSON.stringify(fullInstall),
-              __INTLIFY_PROD_DEVTOOLS__: "false"
-            })
-          );
-          debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
-        } else {
-          debug$2("ignore vue-i18n feature flags with webpack.DefinePlugin");
-        }
-      });
-      if (compiler.options.module) {
-        compiler.options.module.rules.push({
-          test: /\.(json5?|ya?ml)$/,
-          type: "javascript/auto",
-          include(resource) {
-            return filter(resource);
-          }
-        });
       }
     },
     resolveId(id, importer) {
@@ -365,198 +297,152 @@ function resourcePlugin({
         return asVirtualId(id, meta.framework);
       }
     },
-    async load(id) {
+    loadInclude(id) {
+      return INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework);
+    },
+    load(id) {
       debug$2("load", id);
-      if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && include) {
-        let resourcePaths = [];
-        const includePaths = isArray(include) ? include : [include];
-        for (const inc of includePaths) {
-          resourcePaths = [...resourcePaths, ...await fg(inc)];
+      if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && resourcePaths.size > 0) {
+        const code = generateBundleResources(resourcePaths);
+        for (const p of resourcePaths) {
+          this.addWatchFile(p);
         }
-        resourcePaths = resourcePaths.filter(
-          (el, pos) => resourcePaths.indexOf(el) === pos
-        );
-        const code = await generateBundleResources(
-          resourcePaths,
-          isProduction,
-          {
-            forceStringify,
-            strictMessage,
-            escapeHtml
-          }
-        );
-        return {
-          code,
-          map: { mappings: "" }
-        };
+        return result(code);
       }
     },
     transformInclude(id) {
       debug$2("transformInclude", id);
       if (meta.framework === "vite") {
         return true;
-      } else {
-        const { filename } = parseVueRequest(id);
-        return filename.endsWith("vue") || filename.endsWith(INTLIFY_BUNDLE_IMPORT_ID) || /\.(json5?|ya?ml)$/.test(filename) && filter(filename);
       }
+      const { filename, query } = parseVueRequest(id);
+      if (filename.endsWith("vue") || filename.endsWith(INTLIFY_BUNDLE_IMPORT_ID)) {
+        return true;
+      }
+      let isResourcePath = resourcePaths.has(id);
+      if (!isResourcePath && "issuerPath" in query) {
+        isResourcePath = resourcePaths.has(query.issuerPath);
+      }
+      return supportedFileExtensionsRE.test(filename) && filter(filename) && isResourcePath;
     },
     async transform(code, id) {
       const { filename, query } = parseVueRequest(id);
       debug$2("transform", id, JSON.stringify(query), filename);
-      let langInfo = defaultSFCLang;
-      let inSourceMap;
-      if (!query.vue) {
-        if (/\.(json5?|ya?ml|[c|m]?js)$/.test(id) && filter(id)) {
-          langInfo = parse(filename).ext;
-          const generate = getGenerator(langInfo);
-          const parseOptions = getOptions(
-            filename,
-            isProduction,
-            query,
-            sourceMap,
-            {
-              inSourceMap,
-              isGlobal: globalSFCScope,
-              allowDynamic,
-              strictMessage,
-              escapeHtml,
-              jit: true,
-              onlyLocales,
-              forceStringify
-            }
-          );
-          debug$2("parseOptions", parseOptions);
+      let langInfo = opts.defaultSFCLang;
+      if (filter(id)) {
+        const imports = findStaticImports(code);
+        for (const p of imports) {
+          const res = resolve(dirname(id), p.specifier);
+          importedResources.add(res);
+        }
+      }
+      if (!query.vue && supportedFileExtensionsRE.test(id) && filter(id)) {
+        langInfo = parse(filename).ext;
+        const generate = getGenerator(langInfo);
+        const parseOptions = getOptions(filename, ctx, query, {
+          ...opts,
+          transformI18nBlock: void 0
+        });
+        debug$2("parseOptions", parseOptions);
+        try {
           const { code: generatedCode, map } = generate(code, parseOptions);
           debug$2("generated code", generatedCode);
-          debug$2("sourcemap", map, sourceMap);
+          debug$2("sourcemap", map, ctx.sourceMap);
           if (code === generatedCode)
             return;
-          return {
-            code: generatedCode,
-            // prettier-ignore
-            map: { mappings: "" }
-          };
-        }
-      } else {
-        if (isCustomBlock(query)) {
-          if (isString(query.lang)) {
-            langInfo = query.src ? query.lang === "i18n" ? defaultSFCLang : query.lang : query.lang;
-          } else if (defaultSFCLang) {
-            langInfo = defaultSFCLang;
+          return result(generatedCode);
+        } catch (err) {
+          if (err instanceof DynamicResourceError) {
+            error(
+              `Unable to precompile or optimize \`${filename}\` - excluding from virtual bundle \`${INTLIFY_BUNDLE_IMPORT_ID}\`.
+`,
+              err
+            );
+            return `export default {}`;
+          } else {
+            throw err;
           }
-          debug$2("langInfo", langInfo);
-          const generate = /\.?json5?/.test(langInfo) ? generateJSON : generateYAML;
-          const parseOptions = getOptions(
-            filename,
-            isProduction,
-            query,
-            sourceMap,
-            {
-              inSourceMap,
-              isGlobal: globalSFCScope,
-              jit: true,
-              strictMessage,
-              escapeHtml,
-              onlyLocales,
-              forceStringify
-            }
-          );
-          debug$2("parseOptions", parseOptions);
-          let source = await getCode(
-            code,
-            filename,
-            sourceMap,
-            query,
-            getSfcParser(),
-            meta.framework
-          );
-          if (typeof transformI18nBlock === "function") {
-            const modifiedSource = transformI18nBlock(source);
-            if (modifiedSource && typeof modifiedSource === "string") {
-              source = modifiedSource;
-            } else {
-              warn("transformI18nBlock should return a string");
-            }
+        }
+      }
+      if (isCustomBlock(query)) {
+        langInfo = opts.defaultSFCLang;
+        if (query.lang && query.lang !== "i18n") {
+          langInfo = query.lang;
+        }
+        debug$2("langInfo", langInfo);
+        const parseOptions = getOptions(filename, ctx, query, {
+          ...opts,
+          allowDynamic: false,
+          transformI18nBlock: void 0
+        });
+        debug$2("parseOptions", parseOptions);
+        let source = getCode(
+          code,
+          filename,
+          ctx.sourceMap,
+          query,
+          getSfcParser(),
+          meta
+        );
+        if (typeof opts.transformI18nBlock === "function") {
+          const modifiedSource = opts.transformI18nBlock(source);
+          if (modifiedSource && typeof modifiedSource === "string") {
+            source = modifiedSource;
+          } else {
+            warn("transformI18nBlock should return a string");
           }
-          const { code: generatedCode, map } = generate(source, parseOptions);
-          debug$2("generated code", generatedCode);
-          debug$2("sourcemap", map, sourceMap);
-          if (code === generatedCode)
-            return;
-          return {
-            code: generatedCode,
-            // prettier-ignore
-            map: { mappings: "" }
-          };
+        }
+        const generate = getGenerator(langInfo, generateYAML);
+        const { code: generatedCode, map } = generate(source, parseOptions);
+        debug$2("generated code", generatedCode);
+        debug$2("sourcemap", map, ctx.sourceMap);
+        if (code !== generatedCode) {
+          return result(generatedCode);
         }
       }
     }
   };
 }
-function getGenerator(ext, defaultGen = generateJSON) {
-  return /\.?json5?$/.test(ext) ? generateJSON : /\.ya?ml$/.test(ext) ? generateYAML : /\.([c|m]?js|[c|m]?ts)$/.test(ext) ? generateJavaScript : defaultGen;
-}
-function normalizeConfigResolveAlias(resolve, framework) {
-  if (resolve && resolve.alias) {
-    return resolve;
+function getGenerator(ext, fallback = generateJSON) {
+  if (/\.?json5?$/.test(ext)) {
+    return generateJSON;
   }
-  if (!resolve) {
-    if (framework === "vite") {
-      return { alias: [] };
-    } else if (framework === "webpack") {
-      return { alias: {} };
-    }
-  } else if (!resolve.alias) {
-    if (framework === "vite") {
-      resolve.alias = [];
-      return resolve;
-    } else if (framework === "webpack") {
-      resolve.alias = {};
-      return resolve;
-    }
+  if (/\.ya?ml$/.test(ext)) {
+    return generateYAML;
+  }
+  if (/\.[c|m]?[j|t]s$/.test(ext)) {
+    return generateJavaScript;
   }
+  return fallback;
 }
 async function loadWebpack() {
-  let webpack = null;
-  try {
-    webpack = await import('webpack').then((m) => m.default || m);
-  } catch (_e) {
-    warn(`webpack not found, please install webpack.`);
-  }
-  return webpack;
-}
-async function generateBundleResources(resources, isProduction, {
-  forceStringify = false,
-  isGlobal = false,
-  onlyLocales = [],
-  strictMessage = true,
-  escapeHtml = false,
-  jit = true,
-  transformI18nBlock = void 0
-}) {
+  const mod = await import('webpack');
+  return mod.default || mod;
+}
+async function loadRspack() {
+  const { rspack } = await import('@rspack/core');
+  return rspack;
+}
+function generateBundleResources(resources) {
   const codes = [];
-  for (const res of resources) {
-    debug$2(`${res} bundle loading ...`);
-    if (/\.(json5?|ya?ml)$/.test(res)) {
-      const { ext, name } = parse(res);
-      const source = await getRaw(res);
-      const generate = /json5?/.test(ext) ? generateJSON : generateYAML;
-      const parseOptions = getOptions(res, isProduction, {}, false, {
-        isGlobal,
-        jit,
-        onlyLocales,
-        strictMessage,
-        escapeHtml,
-        forceStringify,
-        transformI18nBlock
-      });
-      parseOptions.type = "bare";
-      const { code } = generate(source, parseOptions);
-      debug$2("generated code", code);
-      codes.push(`${JSON.stringify(name)}: ${code}`);
-    }
+  const imports = [];
+  for (const filename of resources) {
+    debug$2(`${filename} bundle loading ...`);
+    const { name } = parse(filename);
+    const varName = genSafeVariableName(
+      [
+        name,
+        createHash("sha256").update(filename).digest("hex").substring(0, 8)
+      ].join("_")
+    );
+    imports.push({ statement: genImport(filename, varName), varName });
+    codes.push(`${JSON.stringify(name)}: ${varName}`);
   }
-  return `const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
+  const importStatements = imports.map((x) => x.statement).join("\n");
+  return `
+${importStatements}
+
+const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
 
 const mergeDeep = (target, ...sources) => {
   if (!sources.length) return target;
@@ -577,96 +463,73 @@ const mergeDeep = (target, ...sources) => {
 }
 
 export default mergeDeep({},
-  ${codes.map((code) => `{${code}}`).join(",\n")}
+  ${codes.map((code) => `{ ${code} }`).join(",\n  ")}
 );`;
 }
-async function getCode(source, filename, sourceMap, query, parser, framework = "vite") {
-  const { index, issuerPath } = query;
-  if (!isNumber(index)) {
-    raiseError(`unexpected index: ${index}`);
+function getCode(source, filename, sourceMap, query, parser, meta) {
+  if (query.index == null) {
+    raiseError(`unexpected index: ${query.index}`);
   }
-  if (framework === "webpack") {
-    if (issuerPath) {
-      debug$2(`getCode (webpack) ${index} via issuerPath`, issuerPath);
-      return await getRaw(filename);
-    } else {
-      const result = parser(await getRaw(filename), {
-        sourceMap,
-        filename
-      });
-      const block = result.descriptor.customBlocks[index];
-      if (block) {
-        const code = block.src ? await getRaw(block.src) : block.content;
-        debug$2(`getCode (webpack) ${index} from SFC`, code);
-        return code;
-      } else {
-        return source;
-      }
-    }
-  } else {
+  if (meta.framework === "vite") {
     return source;
   }
+  if (query.issuerPath) {
+    debug$2(
+      `getCode (${meta.framework}) ${query.index} via issuerPath`,
+      query.issuerPath
+    );
+    return readFile(filename);
+  }
+  const result = parser(readFile(filename), { sourceMap, filename });
+  const block = result.descriptor.customBlocks[query.index];
+  if (block) {
+    const code = block.src ? readFile(block.src) : block.content;
+    debug$2(`getCode (${meta.framework}) ${query.index} from SFC`, code);
+    return code;
+  }
+  return source;
 }
 function isCustomBlock(query) {
   return !isEmptyObject(query) && "vue" in query && (query["type"] === "custom" || // for vite (@vite-plugin-vue)
   query["type"] === "i18n" || // for webpack (vue-loader)
   query["blockType"] === "i18n");
 }
-function getOptions(filename, isProduction, query, sourceMap, {
-  inSourceMap = void 0,
-  forceStringify = false,
-  isGlobal = false,
-  onlyLocales = [],
-  allowDynamic = false,
-  strictMessage = true,
-  escapeHtml = false,
-  jit = true,
-  transformI18nBlock = null
-}) {
-  const mode = isProduction ? "production" : "development";
+function getOptions(filename, ctx, query, opts) {
   const baseOptions = {
+    ...opts,
     filename,
-    sourceMap,
-    inSourceMap,
-    forceStringify,
-    allowDynamic,
-    strictMessage,
-    escapeHtml,
-    jit,
-    onlyLocales,
-    env: mode,
-    transformI18nBlock,
-    onWarn: (msg) => {
-      warn(`${filename} ${msg}`);
-    },
+    jit: true,
+    // allow overriding ctx.sourceMap with opts
+    sourceMap: opts.sourceMap ?? ctx.sourceMap,
+    env: ctx.prod ? "production" : "development",
+    onWarn: (msg) => warn(`${filename} ${msg}`),
     onError: (msg, extra) => {
       const codeFrame = generateCodeFrame(
         extra?.source || extra?.location?.source || "",
         extra?.location?.start.column,
         extra?.location?.end.column
       );
-      const errMssage = `${msg} (error code: ${extra?.code}) in ${filename}
+      const errMessage = `${msg} (error code: ${extra?.code}) in ${filename}
   target message: ${extra?.source}
   target message path: ${extra?.path}
 
   ${codeFrame}
 `;
-      error(errMssage);
-      throw new Error(errMssage);
+      error(errMessage);
+      throw new Error(errMessage);
     }
   };
   if (isCustomBlock(query)) {
     return assign(baseOptions, {
       type: "sfc",
-      locale: isString(query.locale) ? query.locale : "",
-      isGlobal: isGlobal || !!query.global
-    });
-  } else {
-    return assign(baseOptions, {
-      type: "plain",
-      isGlobal: false
+      locale: query.locale ?? "",
+      isGlobal: opts.globalSFCScope || !!query.global
     });
   }
+  return assign(baseOptions, {
+    type: "plain",
+    isGlobal: false
+  });
 }
 function getVirtualId(id, framework = "vite") {
   return framework === "vite" ? id.startsWith(VIRTUAL_PREFIX) ? id.slice(VIRTUAL_PREFIX.length) : "" : id;
@@ -674,8 +537,8 @@ function getVirtualId(id, framework = "vite") {
 function asVirtualId(id, framework = "vite") {
   return framework === "vite" ? VIRTUAL_PREFIX + id : id;
 }
-async function getRaw(path) {
-  return promises.readFile(path, { encoding: "utf-8" });
+function readFile(path) {
+  return fs.readFileSync(path, "utf-8");
 }
 
 const debug$1 = createDebug(resolveNamespace("directive"));
@@ -956,17 +819,17 @@ function resolveIdentifier(localVariables, returnVariable) {
 const debug = createDebug(resolveNamespace("root"));
 const unpluginFactory = (options = {}, meta) => {
   debug("meta framework", meta.framework);
-  if (!["vite", "webpack"].includes(meta.framework)) {
-    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
+  if (!["vite", "webpack", "rspack"].includes(meta.framework)) {
+    raiseError(`This plugin is supported 'vite', 'webpack' and 'rspack' only`);
   }
   debug("plugin options (resolving):", options);
   const resolvedOptions = resolveOptions(options);
   debug("plugin options (resolved):", resolvedOptions);
   const plugins = [resourcePlugin(resolvedOptions, meta)];
   if (resolvedOptions.optimizeTranslationDirective) {
-    if (meta.framework === "webpack") {
+    if (meta.framework === "webpack" || meta.framework === "rspack") {
       raiseError(
-        `The 'optimizeTranslationDirective' option still is not supported for webpack.
+        `The 'optimizeTranslationDirective' option still is not supported for ${meta.framework}.
 We are waiting for your Pull Request \u{1F642}.`
       );
     }