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

package/lib/index.mjs

@@ -1,13 +1,129 @@
 import { createUnplugin } from 'unplugin';
-import { normalize, parse } from 'pathe';
 import createDebug from 'debug';
+import fs, { promises } from 'node:fs';
+import pc from 'picocolors';
+import module from 'node:module';
+import path from 'node:path';
+import { normalize, parse } from 'pathe';
+import { isArray, isString, isBoolean, assign, isNumber, isEmptyObject, generateCodeFrame } from '@intlify/shared';
 import fg from 'fast-glob';
-import { isArray, isString, isBoolean, isObject, isNumber, isEmptyObject, assign, generateCodeFrame } from '@intlify/shared';
 import { createFilter } from '@rollup/pluginutils';
-import { checkInstallPackage, generateJSON, generateYAML, generateJavaScript } from '@intlify/bundle-utils';
-import { parse as parse$1 } from '@vue/compiler-sfc';
-import { promises } from 'fs';
-import pc from 'picocolors';
+import { generateJSON, generateYAML, generateJavaScript } from '@intlify/bundle-utils';
+import { parse as parse$1 } from 'vue/compiler-sfc';
+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';
+import eslintUitls from '@eslint-community/eslint-utils';
+
+const _require = module.createRequire(import.meta.url);
+function checkInstallPackage(debug) {
+  const pkgInfo = resolvePkgPath("vue-i18n", debug) || resolvePkgPath("petite-vue-i18n", debug);
+  if (!pkgInfo) {
+    throw new Error(
+      `requires 'vue-i18n' or 'petite-vue-i18n' to be present in the dependency tree.`
+    );
+  }
+  debug("installed package info:", pkgInfo);
+  return pkgInfo;
+}
+function resolvePkgPath(id, debug) {
+  try {
+    const resolvedPath = _require.resolve(id);
+    const pkgPath = path.dirname(resolvedPath);
+    const pkgJson = JSON.parse(
+      fs.readFileSync(path.join(pkgPath, "package.json"), "utf-8")
+    );
+    const pkgName = pkgJson.name.startsWith("vue-i18n") ? "vue-i18n" : pkgJson.name.startsWith("petite-vue-i18n") ? "petite-vue-i18n" : "";
+    return pkgJson ? { alias: id, pkg: pkgName } : null;
+  } catch (e) {
+    debug(`cannot find '${id}'`, e);
+    return null;
+  }
+}
+function resolveNamespace(name) {
+  return `unplugin-vue-i18n:${name}`;
+}
+function warn(...args) {
+  console.warn(pc.yellow(pc.bold(`[unplugin-vue-i18n] `)), ...args);
+}
+function error(...args) {
+  console.error(pc.red(pc.bold(`[unplugin-vue-i18n] `)), ...args);
+}
+async function getRaw(path2) {
+  return promises.readFile(path2, { encoding: "utf-8" });
+}
+function raiseError(message) {
+  throw new Error(`[unplugin-vue-i18n] ${message}`);
+}
+function getVitePlugin(config, name) {
+  return config.plugins.find((p) => p.name === name);
+}
+function checkVuePlugin(vuePlugin) {
+  if (vuePlugin == null || !vuePlugin.api) {
+    error(
+      "`@vitejs/plugin-vue` plugin is not found or invalid version. Please install `@vitejs/plugin-vue` v4.3.4 or later version."
+    );
+    return false;
+  }
+  return true;
+}
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return path.posix.normalize(isWindows ? slash(id) : id);
+}
+
+function resolveOptions(options, installedPkgInfo) {
+  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 compositionOnly = installedPkgInfo.pkg === "vue-i18n" ? isBoolean(options.compositionOnly) ? options.compositionOnly : true : true;
+  const fullInstall = installedPkgInfo.pkg === "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 translationIdentifiers = /* @__PURE__ */ new Map();
+  return {
+    include,
+    exclude,
+    onlyLocales,
+    forceStringify,
+    defaultSFCLang,
+    globalSFCScope,
+    runtimeOnly,
+    dropMessageCompiler,
+    compositionOnly,
+    fullInstall,
+    ssrBuild,
+    allowDynamic,
+    strictMessage,
+    escapeHtml,
+    optimizeTranslationDirective,
+    translationIdentifiers
+  };
+}
 
 function parseVueRequest(id) {
   const [filename, rawQuery] = id.split(`?`, 2);
@@ -47,77 +163,66 @@ function parseVueRequest(id) {
   };
 }
 
-function warn(...args) {
-  console.warn(pc.yellow(pc.bold(`[unplugin-vue-i18n] `)), ...args);
+function getVueCompiler(vuePlugin) {
+  return vuePlugin?.api?.options.compiler;
 }
-function error(...args) {
-  console.error(pc.red(pc.bold(`[unplugin-vue-i18n] `)), ...args);
+function getVuePluginOptions(vuePlugin) {
+  return {
+    isProduction: vuePlugin?.api?.options.isProduction,
+    root: vuePlugin?.api?.options.root,
+    template: vuePlugin?.api?.options.template,
+    compiler: vuePlugin?.api?.options.compiler
+  };
 }
-async function getRaw(path) {
-  return promises.readFile(path, { encoding: "utf-8" });
+
+function createDescriptor(filename, source, { template, compiler }) {
+  const { descriptor, errors } = compiler.parse(source, {
+    filename,
+    templateParseOptions: template?.compilerOptions
+  });
+  return { descriptor, errors };
 }
-function raiseError(message) {
-  throw new Error(`[unplugin-vue-i18n] ${message}`);
+function getDescriptor(filename, code, options) {
+  const { descriptor, errors } = createDescriptor(filename, code, options);
+  if (errors.length) {
+    throw errors[0];
+  }
+  return descriptor;
 }
 
 const INTLIFY_BUNDLE_IMPORT_ID = "@intlify/unplugin-vue-i18n/messages";
 const VIRTUAL_PREFIX = "\0";
-const debug = createDebug("unplugin-vue-i18n");
-const installedPkg = checkInstallPackage("@intlify/unplugin-vue-i18n", debug);
-const unplugin = createUnplugin((options = {}, meta) => {
-  debug("plugin options:", options, meta.framework);
-  if (!["vite", "webpack"].includes(meta.framework)) {
-    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
-  }
-  let onlyLocales = [];
-  if (options.onlyLocales) {
-    onlyLocales = Array.isArray(options.onlyLocales) ? options.onlyLocales : [options.onlyLocales];
-  }
-  let include = options.include;
-  let exclude = null;
-  if (include) {
-    if (isArray(include)) {
-      include = include.map((item) => normalize(item));
-    } else if (isString(include)) {
-      include = normalize(include);
-    }
-  } else {
-    exclude = "**/**";
-  }
+const debug$2 = createDebug(resolveNamespace("resource"));
+function resourcePlugin({
+  onlyLocales,
+  include,
+  exclude,
+  forceStringify,
+  defaultSFCLang,
+  globalSFCScope,
+  runtimeOnly,
+  dropMessageCompiler,
+  compositionOnly,
+  fullInstall,
+  ssrBuild,
+  strictMessage,
+  allowDynamic,
+  escapeHtml
+}, meta, installedPkgInfo) {
   const filter = createFilter(include, 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;
-  debug("runtimeOnly", runtimeOnly);
-  const dropMessageCompiler = !!options.dropMessageCompiler;
-  debug("dropMessageCompiler", dropMessageCompiler);
-  const compositionOnly = installedPkg === "vue-i18n" ? isBoolean(options.compositionOnly) ? options.compositionOnly : true : true;
-  debug("compositionOnly", compositionOnly);
-  const fullInstall = installedPkg === "vue-i18n" ? isBoolean(options.fullInstall) ? options.fullInstall : true : false;
-  debug("fullInstall", fullInstall);
-  const ssrBuild = !!options.ssr;
-  debug("ssr", ssrBuild);
-  const useVueI18nImportName = options.useVueI18nImportName;
-  if (useVueI18nImportName != null) {
-    warn(`'useVueI18nImportName' option is experimental`);
-  }
-  debug("useVueI18nImportName", useVueI18nImportName);
-  const getVueI18nAliasName = () => installedPkg === "petite-vue-i18n" && isBoolean(useVueI18nImportName) && useVueI18nImportName ? "vue-i18n" : installedPkg;
   const getVueI18nAliasPath = ({ ssr = false, runtimeOnly: runtimeOnly2 = false }) => {
-    return `${installedPkg}/dist/${installedPkg}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.mjs"}`;
+    return `${installedPkgInfo.alias}/dist/${installedPkgInfo.pkg}${runtimeOnly2 ? ".runtime" : ""}.${!ssr ? "esm-bundler.js" : "node.mjs"}`;
   };
-  const allowDynamic = !!options.allowDynamic;
-  debug("allowDynamic", allowDynamic);
-  const strictMessage = isBoolean(options.strictMessage) ? options.strictMessage : true;
-  debug("strictMessage", strictMessage);
-  const escapeHtml = !!options.escapeHtml;
-  debug("escapeHtml", escapeHtml);
   let isProduction = false;
   let sourceMap = false;
-  const vueI18nAliasName = getVueI18nAliasName();
+  const vueI18nAliasName = installedPkgInfo.alias;
+  debug$2(`vue-i18n alias name: ${vueI18nAliasName}`);
+  let vuePlugin = null;
+  const getSfcParser = () => {
+    return vuePlugin ? getVueCompiler(vuePlugin).parse : parse$1;
+  };
   return {
-    name: "unplugin-vue-i18n",
+    name: resolveNamespace("resource"),
     /**
      * NOTE:
      *
@@ -128,70 +233,40 @@ const unplugin = createUnplugin((options = {}, meta) => {
      */
     enforce: meta.framework === "vite" ? "pre" : "post",
     vite: {
-      config(config, { command }) {
-        config.resolve = normalizeConfigResolveAlias(
-          config.resolve,
-          meta.framework
-        );
-        if (command === "build") {
-          debug(`vue-i18n alias name: ${vueI18nAliasName}`);
-          if (isArray(config.resolve.alias)) {
-            config.resolve.alias.push({
-              find: vueI18nAliasName,
-              replacement: getVueI18nAliasPath({
+      config() {
+        const defineConfig = {
+          define: {
+            __VUE_I18N_LEGACY_API__: !compositionOnly,
+            __VUE_I18N_FULL_INSTALL__: fullInstall,
+            __INTLIFY_DROP_MESSAGE_COMPILER__: dropMessageCompiler,
+            __VUE_I18N_PROD_DEVTOOLS__: false
+          }
+        };
+        debug$2("define Config:", defineConfig);
+        const aliasConfig = {
+          resolve: {
+            alias: {
+              [vueI18nAliasName]: getVueI18nAliasPath({
                 ssr: ssrBuild,
                 runtimeOnly
               })
-            });
-          } else if (isObject(config.resolve.alias)) {
-            config.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath({
-              ssr: ssrBuild,
-              runtimeOnly
-            });
-          }
-          debug(
-            `set ${vueI18nAliasName} runtime only: ${getVueI18nAliasPath({
-              ssr: ssrBuild,
-              runtimeOnly
-            })}`
-          );
-        } else if (command === "serve" && installedPkg === "petite-vue-i18n" && useVueI18nImportName) {
-          config.resolve = normalizeConfigResolveAlias(
-            config.resolve,
-            meta.framework
-          );
-          if (isArray(config.resolve.alias)) {
-            config.resolve.alias.push({
-              find: vueI18nAliasName,
-              replacement: `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`
-            });
-          } else {
-            config.resolve.alias[vueI18nAliasName] = `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`;
+            }
           }
-          debug(`petite-vue-i18n alias name: ${vueI18nAliasName}`);
-        }
-        config.define = config.define || {};
-        config.define["__VUE_I18N_LEGACY_API__"] = !compositionOnly;
-        debug(
-          `set __VUE_I18N_LEGACY_API__ is '${config.define["__VUE_I18N_LEGACY_API__"]}'`
-        );
-        config.define["__VUE_I18N_FULL_INSTALL__"] = fullInstall;
-        debug(
-          `set __VUE_I18N_FULL_INSTALL__ is '${config.define["__VUE_I18N_FULL_INSTALL__"]}'`
-        );
-        config.define["__INTLIFY_DROP_MESSAGE_COMPILER__"] = dropMessageCompiler;
-        debug(
-          `set __INTLIFY_DROP_MESSAGE_COMPILER__ is '${config.define["__INTLIFY_DROP_MESSAGE_COMPILER__"]}'`
-        );
-        config.define["__VUE_I18N_PROD_DEVTOOLS__"] = false;
+        };
+        debug$2("alias Config:", aliasConfig);
+        return assign(defineConfig, aliasConfig);
       },
       configResolved(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
         isProduction = config.isProduction;
         sourceMap = config.command === "build" ? !!config.build.sourcemap : false;
-        debug(
+        debug$2(
           `configResolved: isProduction = ${isProduction}, sourceMap = ${sourceMap}`
         );
-        const jsonPlugin = config.plugins.find((p) => p.name === "vite:json");
+        const jsonPlugin = getVitePlugin(config, "vite:json");
         if (jsonPlugin) {
           const orgTransform = jsonPlugin.transform;
           jsonPlugin.transform = async function(code, id) {
@@ -202,13 +277,11 @@ const unplugin = createUnplugin((options = {}, meta) => {
             if (query.vue) {
               return;
             }
-            debug("org json plugin");
+            debug$2("org json plugin");
             return orgTransform.apply(this, [code, id]);
           };
         }
-        const esbuildPlugin = config.plugins.find(
-          (p) => p.name === "vite:esbuild"
-        );
+        const esbuildPlugin = getVitePlugin(config, "vite:esbuild");
         if (esbuildPlugin) {
           const orgTransform = esbuildPlugin.transform;
           esbuildPlugin.transform = async function(code, id) {
@@ -241,10 +314,10 @@ const unplugin = createUnplugin((options = {}, meta) => {
                   forceStringify
                 }
               );
-              debug("parseOptions", parseOptions);
+              debug$2("parseOptions", parseOptions);
               const { code: generatedCode, map } = generate(_code, parseOptions);
-              debug("generated code", generatedCode);
-              debug("sourcemap", map, sourceMap);
+              debug$2("generated code", generatedCode);
+              debug$2("sourcemap", map, sourceMap);
               if (_code === generatedCode)
                 return;
               return {
@@ -272,26 +345,21 @@ const unplugin = createUnplugin((options = {}, meta) => {
     webpack(compiler) {
       isProduction = compiler.options.mode !== "development";
       sourceMap = !!compiler.options.devtool;
-      debug(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
+      debug$2(`webpack: isProduction = ${isProduction}, sourceMap = ${sourceMap}`);
       compiler.options.resolve = normalizeConfigResolveAlias(
         compiler.options.resolve,
         meta.framework
       );
-      if (isProduction) {
-        compiler.options.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath({
+      compiler.options.resolve.alias[vueI18nAliasName] = getVueI18nAliasPath({
+        ssr: ssrBuild,
+        runtimeOnly
+      });
+      debug$2(
+        `set ${vueI18nAliasName}: ${getVueI18nAliasPath({
           ssr: ssrBuild,
           runtimeOnly
-        });
-        debug(
-          `set ${vueI18nAliasName}: ${getVueI18nAliasPath({
-            ssr: ssrBuild,
-            runtimeOnly
-          })}`
-        );
-      } else if (!isProduction && installedPkg === "petite-vue-i18n" && useVueI18nImportName) {
-        compiler.options.resolve.alias[vueI18nAliasName] = `petite-vue-i18n/dist/petite-vue-i18n.esm-bundler.js`;
-        debug(`petite-vue-i18n alias name: ${vueI18nAliasName}`);
-      }
+        })}`
+      );
       loadWebpack().then((webpack) => {
         if (webpack) {
           compiler.options.plugins.push(
@@ -301,10 +369,10 @@ const unplugin = createUnplugin((options = {}, meta) => {
               __INTLIFY_PROD_DEVTOOLS__: "false"
             })
           );
-          debug(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);
-          debug(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
+          debug$2(`set __VUE_I18N_LEGACY_API__ is '${compositionOnly}'`);
+          debug$2(`set __VUE_I18N_FULL_INSTALL__ is '${fullInstall}'`);
         } else {
-          debug("ignore vue-i18n feature flags with webpack.DefinePlugin");
+          debug$2("ignore vue-i18n feature flags with webpack.DefinePlugin");
         }
       });
       if (compiler.options.module) {
@@ -318,15 +386,14 @@ const unplugin = createUnplugin((options = {}, meta) => {
       }
     },
     resolveId(id, importer) {
-      debug("resolveId", id, importer);
+      debug$2("resolveId", id, importer);
       if (id === INTLIFY_BUNDLE_IMPORT_ID) {
         return asVirtualId(id, meta.framework);
       }
     },
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async load(id) {
-      debug("load", id);
-      const { query } = parseVueRequest(id);
+      debug$2("load", id);
       if (INTLIFY_BUNDLE_IMPORT_ID === getVirtualId(id, meta.framework) && include) {
         let resourcePaths = [];
         const includePaths = isArray(include) ? include : [include];
@@ -338,7 +405,6 @@ const unplugin = createUnplugin((options = {}, meta) => {
         );
         const code = await generateBundleResources(
           resourcePaths,
-          query,
           isProduction,
           {
             forceStringify,
@@ -353,7 +419,7 @@ const unplugin = createUnplugin((options = {}, meta) => {
       }
     },
     transformInclude(id) {
-      debug("transformInclude", id);
+      debug$2("transformInclude", id);
       if (meta.framework === "vite") {
         return true;
       } else {
@@ -363,7 +429,7 @@ const unplugin = createUnplugin((options = {}, meta) => {
     },
     async transform(code, id) {
       const { filename, query } = parseVueRequest(id);
-      debug("transform", id, JSON.stringify(query), filename);
+      debug$2("transform", id, JSON.stringify(query), filename);
       let langInfo = defaultSFCLang;
       let inSourceMap;
       if (!query.vue) {
@@ -386,10 +452,10 @@ const unplugin = createUnplugin((options = {}, meta) => {
               forceStringify
             }
           );
-          debug("parseOptions", parseOptions);
+          debug$2("parseOptions", parseOptions);
           const { code: generatedCode, map } = generate(code, parseOptions);
-          debug("generated code", generatedCode);
-          debug("sourcemap", map, sourceMap);
+          debug$2("generated code", generatedCode);
+          debug$2("sourcemap", map, sourceMap);
           if (code === generatedCode)
             return;
           return {
@@ -405,7 +471,7 @@ const unplugin = createUnplugin((options = {}, meta) => {
           } else if (defaultSFCLang) {
             langInfo = defaultSFCLang;
           }
-          debug("langInfo", langInfo);
+          debug$2("langInfo", langInfo);
           const generate = /\.?json5?/.test(langInfo) ? generateJSON : generateYAML;
           const parseOptions = getOptions(
             filename,
@@ -422,17 +488,18 @@ const unplugin = createUnplugin((options = {}, meta) => {
               forceStringify
             }
           );
-          debug("parseOptions", parseOptions);
+          debug$2("parseOptions", parseOptions);
           const source = await getCode(
             code,
             filename,
             sourceMap,
             query,
+            getSfcParser(),
             meta.framework
           );
           const { code: generatedCode, map } = generate(source, parseOptions);
-          debug("generated code", generatedCode);
-          debug("sourcemap", map, sourceMap);
+          debug$2("generated code", generatedCode);
+          debug$2("sourcemap", map, sourceMap);
           if (code === generatedCode)
             return;
           return {
@@ -444,7 +511,7 @@ const unplugin = createUnplugin((options = {}, meta) => {
       }
     }
   };
-});
+}
 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;
 }
@@ -477,7 +544,7 @@ async function loadWebpack() {
   }
   return webpack;
 }
-async function generateBundleResources(resources, query, isProduction, {
+async function generateBundleResources(resources, isProduction, {
   forceStringify = false,
   isGlobal = false,
   onlyLocales = [],
@@ -487,7 +554,7 @@ async function generateBundleResources(resources, query, isProduction, {
 }) {
   const codes = [];
   for (const res of resources) {
-    debug(`${res} bundle loading ...`);
+    debug$2(`${res} bundle loading ...`);
     if (/\.(json5?|ya?ml)$/.test(res)) {
       const { ext, name } = parse(res);
       const source = await getRaw(res);
@@ -502,7 +569,7 @@ async function generateBundleResources(resources, query, isProduction, {
       });
       parseOptions.type = "bare";
       const { code } = generate(source, parseOptions);
-      debug("generated code", code);
+      debug$2("generated code", code);
       codes.push(`${JSON.stringify(name)}: ${code}`);
     }
   }
@@ -530,24 +597,24 @@ export default mergeDeep({},
   ${codes.map((code) => `{${code}}`).join(",\n")}
 );`;
 }
-async function getCode(source, filename, sourceMap, query, framework = "vite") {
+async function getCode(source, filename, sourceMap, query, parser, framework = "vite") {
   const { index, issuerPath } = query;
   if (!isNumber(index)) {
     raiseError(`unexpected index: ${index}`);
   }
   if (framework === "webpack") {
     if (issuerPath) {
-      debug(`getCode (webpack) ${index} via issuerPath`, issuerPath);
+      debug$2(`getCode (webpack) ${index} via issuerPath`, issuerPath);
       return await getRaw(filename);
     } else {
-      const result = parse$1(await getRaw(filename), {
+      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(`getCode (webpack) ${index} from SFC`, code);
+        debug$2(`getCode (webpack) ${index} from SFC`, code);
         return code;
       } else {
         return source;
@@ -623,4 +690,294 @@ function asVirtualId(id, framework = "vite") {
   return framework === "vite" ? VIRTUAL_PREFIX + id : id;
 }
 
+const debug$1 = createDebug(resolveNamespace("directive"));
+function directivePlugin({
+  optimizeTranslationDirective,
+  translationIdentifiers
+}) {
+  let vuePlugin = null;
+  let vuePluginOptions = null;
+  return {
+    name: resolveNamespace("directive"),
+    enforce: "pre",
+    vite: {
+      config(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
+        if (optimizeTranslationDirective) {
+          vuePlugin.api.options = resolveVueOptions(
+            vuePlugin,
+            optimizeTranslationDirective,
+            translationIdentifiers
+          );
+          debug$1(`vite:vue options['template']:`, vuePlugin.api.options);
+        }
+      },
+      configResolved(config) {
+        vuePlugin = getVitePlugin(config, "vite:vue");
+        if (!checkVuePlugin(vuePlugin)) {
+          return;
+        }
+      }
+    },
+    async transform(code, id) {
+      const { filename } = parseVueRequest(id);
+      if (vuePluginOptions == null) {
+        vuePluginOptions = getVuePluginOptions(vuePlugin);
+      }
+      if (id.endsWith(".vue")) {
+        analyzeIdentifiers(
+          getDescriptor(filename, code, vuePluginOptions),
+          vuePluginOptions,
+          translationIdentifiers
+        );
+      }
+      return code;
+    }
+  };
+}
+function resolveVueOptions(vuePlugin, optimizeTranslationDirective, translationIdentifiers) {
+  var _a, _b;
+  const vueOptions = vuePlugin.api.options;
+  vueOptions.template || (vueOptions.template = {});
+  (_a = vueOptions.template).compilerOptions || (_a.compilerOptions = {});
+  (_b = vueOptions.template.compilerOptions).directiveTransforms || (_b.directiveTransforms = {});
+  const translationSignatureResolver = (context, baseResolver) => {
+    const { filename } = context;
+    const vuePluginOptions = getVuePluginOptions(vuePlugin);
+    const normalizedFilename = normalizePath(
+      path.relative(vuePluginOptions.root, filename)
+    );
+    const resolveIdentifier2 = translationIdentifiers.get(normalizedFilename);
+    debug$1("resolved vue-i18n Identifier", resolveIdentifier2);
+    if (resolveIdentifier2 == null) {
+      return void 0;
+    }
+    if (resolveIdentifier2.type === "identifier") {
+      return baseResolver(context, resolveIdentifier2.key);
+    } else {
+      const resolvedSignature = baseResolver(context, resolveIdentifier2.key);
+      return resolveIdentifier2?.style === "script-setup" ? `${resolvedSignature}.t` : resolvedSignature;
+    }
+  };
+  vueOptions.template.compilerOptions.directiveTransforms.t = transformVTDirective({
+    translationSignatures: isBoolean(optimizeTranslationDirective) ? translationSignatureResolver : optimizeTranslationDirective
+  });
+  return vueOptions;
+}
+function analyzeIdentifiers(descriptor, { root }, translationIdentifiers) {
+  const source = descriptor.scriptSetup?.content || descriptor.script?.content;
+  debug$1("getDescriptor content", source);
+  if (!source) {
+    return;
+  }
+  const ast = parse$2(source, { range: true });
+  simpleTraverse(ast, {
+    enter(node, parent) {
+      if (parent) {
+        node.parent = parent;
+      }
+    }
+  });
+  const scopeManager = analyze(ast, { sourceType: "module" });
+  const scope = getScope(scopeManager, ast);
+  const importLocalName = getImportLocalName(scope, "vue-i18n", "useI18n");
+  if (importLocalName == null) {
+    return;
+  }
+  debug$1("importLocalName", importLocalName);
+  const resolvedIdentifier = getVueI18nIdentifier(scope, importLocalName);
+  if (resolvedIdentifier) {
+    const normalizedFilename = normalizePath(
+      path.relative(root, descriptor.filename)
+    );
+    debug$1("set vue-i18n resolved identifier: ", resolvedIdentifier);
+    translationIdentifiers.set(normalizedFilename, resolvedIdentifier);
+  }
+}
+function getScope(manager, node) {
+  const scope = manager.acquire(node, true);
+  if (scope) {
+    if (scope.type === "function-expression-name") {
+      return scope.childScopes[0];
+    }
+    return scope;
+  }
+  return manager.scopes[0];
+}
+function getImportLocalName(scope, source, imported) {
+  const importDecl = getImportDeclaration(scope, source);
+  if (importDecl) {
+    const specifierNode = importDecl.specifiers.find(
+      (specifierNode2) => isImportedIdentifierInImportClause(specifierNode2) && specifierNode2.imported.name === imported
+    );
+    return specifierNode ? specifierNode.local.name : null;
+  }
+  return null;
+}
+function getImportDeclaration(scope, source) {
+  const tracker = new eslintUitls.ReferenceTracker(scope);
+  const traceMap = {
+    [source]: {
+      [eslintUitls.ReferenceTracker.ESM]: true,
+      [eslintUitls.ReferenceTracker.READ]: true
+    }
+  };
+  const refs = Array.from(tracker.iterateEsmReferences(traceMap));
+  return refs.length ? refs[0].node : null;
+}
+function isImportedIdentifierInImportClause(node) {
+  return "imported" in node;
+}
+function getVueI18nIdentifier(scope, local) {
+  const { callExpression, returnStatement } = getCallExpressionAndReturnStatement(scope, local);
+  if (callExpression == null) {
+    return null;
+  }
+  const id = getVariableDeclarationIdFrom(callExpression);
+  if (id == null) {
+    return null;
+  }
+  const variableIdPairs = parseVariableId(id);
+  debug$1("variableIdPairs:", variableIdPairs);
+  const returnVariableIdPairs = parseReturnStatement(returnStatement);
+  debug$1("returnVariableIdPairs:", returnVariableIdPairs);
+  return resolveIdentifier(variableIdPairs, returnVariableIdPairs);
+}
+const EMPTY_NODE_RETURN = {
+  callExpression: null,
+  returnStatement: null
+};
+function getCallExpressionAndReturnStatement(scope, local) {
+  const variable = eslintUitls.findVariable(scope, local);
+  if (variable == null) {
+    return EMPTY_NODE_RETURN;
+  }
+  const callExpressionRef = variable.references.find((ref) => {
+    return ref.identifier.parent?.type === AST_NODE_TYPES.CallExpression;
+  });
+  if (callExpressionRef == null) {
+    return EMPTY_NODE_RETURN;
+  }
+  let returnStatement = null;
+  if (callExpressionRef.from.type === "function" && callExpressionRef.from.block.type === AST_NODE_TYPES.FunctionExpression && callExpressionRef.from.block.parent.type === AST_NODE_TYPES.Property && callExpressionRef.from.block.parent.key.type === AST_NODE_TYPES.Identifier && callExpressionRef.from.block.parent.key.name === "setup") {
+    returnStatement = callExpressionRef.from.block.body.body.find(
+      (statement) => {
+        return statement.type === AST_NODE_TYPES.ReturnStatement;
+      }
+    );
+  }
+  return {
+    callExpression: callExpressionRef.identifier.parent,
+    returnStatement
+  };
+}
+function getVariableDeclarationIdFrom(node) {
+  if (node.parent?.type !== AST_NODE_TYPES.VariableDeclarator) {
+    return null;
+  }
+  return node.parent.id;
+}
+function parseVariableId(node) {
+  if (node.type === AST_NODE_TYPES.Identifier) {
+    return [{ key: node.name, value: null }];
+  } else {
+    const props = node.properties.filter(
+      // ignore RestElement
+      (prop) => prop.type === AST_NODE_TYPES.Property
+    );
+    const pairs = [];
+    for (const prop of props) {
+      if (prop?.key.type === AST_NODE_TYPES.Identifier && prop?.value.type === AST_NODE_TYPES.Identifier) {
+        pairs.push({ key: prop.key.name, value: prop.value.name });
+      }
+    }
+    return pairs;
+  }
+}
+function parseReturnStatement(node) {
+  const pairs = [];
+  if (node == null || node.argument == null) {
+    return pairs;
+  }
+  if (node.argument.type === AST_NODE_TYPES.ObjectExpression) {
+    for (const prop of node.argument.properties) {
+      if (prop.type === AST_NODE_TYPES.Property) {
+        if (prop.key.type === AST_NODE_TYPES.Identifier && prop.value.type === AST_NODE_TYPES.Identifier) {
+          pairs.push({ key: prop.key.name, value: prop.value.name });
+        } else if (prop.key.type === AST_NODE_TYPES.Identifier && prop.value.type === AST_NODE_TYPES.MemberExpression && prop.value.object.type === AST_NODE_TYPES.Identifier && prop.value.property.type === AST_NODE_TYPES.Identifier) {
+          pairs.push({
+            key: prop.key.name,
+            value: `${prop.value.object.name}.${prop.value.property.name}`
+          });
+        }
+      }
+    }
+    return pairs;
+  } else if (node.argument.type === AST_NODE_TYPES.Identifier) {
+    return pairs;
+  } else {
+    return pairs;
+  }
+}
+function resolveIdentifier(localVariables, returnVariable) {
+  if (returnVariable.length === 0) {
+    const variable = localVariables.find((pair) => pair.key === "t");
+    if (variable && variable.value) {
+      return { type: "identifier", key: variable.value };
+    }
+    const identifierOnly = localVariables.find((pair) => pair.value === null);
+    if (identifierOnly && identifierOnly.key) {
+      return { type: "object", key: identifierOnly.key, style: "script-setup" };
+    }
+    return null;
+  } else {
+    const variable = localVariables.find((pair) => pair.key === "t");
+    if (variable && variable.value) {
+      const returnVar = returnVariable.find(
+        (pair) => pair.value === variable.value
+      );
+      if (returnVar && returnVar.key) {
+        return { type: "identifier", key: returnVar.key };
+      }
+    }
+    const identifierOnly = localVariables.find((pair) => pair.value === null);
+    if (identifierOnly && identifierOnly.key) {
+      const targetKey = identifierOnly.key;
+      const returnVar = returnVariable.find(
+        (pair) => pair.value?.startsWith(targetKey)
+      );
+      if (returnVar && returnVar.key) {
+        return { type: "object", key: returnVar.key, style: "setup-hook" };
+      }
+    }
+    return null;
+  }
+}
+
+const debug = createDebug(resolveNamespace("root"));
+const installedPkgInfo = checkInstallPackage(debug);
+const unplugin = createUnplugin((options = {}, meta) => {
+  debug("meta framework", meta.framework);
+  if (!["vite", "webpack"].includes(meta.framework)) {
+    raiseError(`This plugin is supported 'vite' and 'webpack' only`);
+  }
+  debug("plugin options (resolving):", options);
+  const resolvedOptions = resolveOptions(options, installedPkgInfo);
+  debug("plugin options (resolved):", resolvedOptions);
+  const plugins = [resourcePlugin(resolvedOptions, meta, installedPkgInfo)];
+  if (resolvedOptions.optimizeTranslationDirective) {
+    if (meta.framework === "webpack") {
+      raiseError(
+        `The 'optimizeTranslationDirective' option still is not supported for webpack.
+We are waiting for your Pull Request \u{1F642}.`
+      );
+    }
+    plugins.push(directivePlugin(resolvedOptions));
+  }
+  return plugins;
+});
+
 export { unplugin as default, unplugin };