vite-gc-i18n-plugin 1.1.7 → 1.1.8

package/dist/index.cjs

@@ -1105,71 +1105,131 @@ function initLangFile() {
   initTranslateBasicFnFile();
 }
 /**
- * @description: 初始化翻译基础函数文件
- * @returns {void}
+ * Normalize a language key for runtime storage aliases.
+ * Examples: zh-cn -> zhcn, en -> en.
  */
-async function initTranslateBasicFnFile() {
-  // 从配置选项中获取必要的配置信息
-  const {
-    targetLangList
-  } = exports.option;
-  // 生成语言映射列表
-  let languages = [];
-  let langList = targetLangList.map(item => {
-    const parts = item.split('-');
-    const lang = parts[0] + '-' + parts[1].toUpperCase();
-    return _.find(allLanguage, {
-      code: lang
-    });
-  });
-  langList
-  // 构建语言映射项
-  .map(item => {
-    languages.push(`{
-                code: "${item.code}",
-                name: "${item.name}"
-            }`);
+function normalizeRuntimeLangKey(langKey) {
+  return String(langKey || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function resolveLanguageMeta(langKey) {
+  const [lang, region] = langKey.split('-');
+  const normalizedCode = region ? `${lang}-${region.toUpperCase()}` : langKey;
+  const matched = _.find(allLanguage, {
+    code: normalizedCode
   });
-  // 用逗号和换行符连接所有映射项
-  const translateBasicFnText = `
-import gc_i18n from 'gc_i18n'
-export const languages = [${languages.toString()}]
-const gcI18nInstance = new gc_i18n({
-    appCode: 'TEST',
-    env: 'dev', // local 本地部署 dev 多语言测试环境 prod 多语言生产环境
-    orgCode: 'GREENCLOUD',
-    messages: {} // 如果你需要自己引入语言包
-})
-export default {
-    install(app, router) {
-        gcI18nInstance.setRouter(router)
+  return {
+    code: matched?.code || normalizedCode,
+    name: matched?.name || langKey
+  };
+}
+function getRuntimeLangKeys() {
+  return Array.from(new Set([exports.option.originLang, ...exports.option.targetLangList].filter(Boolean)));
+}
+
+/**
+ * Create the self-contained browser runtime written to lang/index.js.
+ *
+ * The runtime intentionally avoids importing an external gc_i18n package so generated
+ * examples/apps can translate transformed calls immediately after importing ./lang.
+ */
+function createRuntimeIndexCode() {
+  const namespace = exports.option.namespace || 'lang';
+  const commonTranslateKey = exports.option.commonTranslateKey || '';
+  const originRuntimeKey = normalizeRuntimeLangKey(exports.option.originLang);
+  const languages = exports.option.targetLangList.map(resolveLanguageMeta);
+  const langEntries = getRuntimeLangKeys().map(langKey => {
+    const runtimeKey = normalizeRuntimeLangKey(langKey);
+    return `    '${runtimeKey}': getJSONKey('${langKey}', langJSON)`;
+  }).join(',\n');
+  return `import langJSON from './index.json'
+
+export const languages = ${JSON.stringify(languages, null, 4)}
+
+const DEFAULT_NAMESPACE = '${namespace}'
+const COMMON_TRANSLATE_KEY = '${commonTranslateKey}'
+const ORIGIN_LANG = '${originRuntimeKey}'
+const root = typeof globalThis !== 'undefined' ? globalThis : window
+
+function normalizeLangKey(lang) {
+    return String(lang || '').toLowerCase().replace(/[^a-z0-9]/g, '')
+}
+
+function getJSONKey(key, insertJSONObj = langJSON) {
+    const langObj = {}
+    Object.keys(insertJSONObj || {}).forEach(value => {
+        langObj[value] = insertJSONObj[value] && insertJSONObj[value][key]
+    })
+    return langObj
+}
+
+function createTranslate(defaultNamespace) {
+    const translate = function (key, val, nameSpace = defaultNamespace) {
+        const langPackage = translate[nameSpace] || {}
+        return langPackage[key] || val
     }
-}`;
-  // 构建翻译基础函数文件的路径
-  const indexPath = path.join(exports.option.globalPath, 'index.js');
+    translate.locale = function (locale, nameSpace = defaultNamespace) {
+        translate[nameSpace] = locale || {}
+    }
+    return translate
+}
 
-  // 文件已存在 同时 不重写配置，那么这里就结束
-  if (fs.existsSync(indexPath) && !exports.option.rewriteConfig) return;
+root.$t = root.$t || createTranslate(DEFAULT_NAMESPACE)
+root.$$t = root.$$t || function (val) {
+    return val
+}
+root.$deepScan = root.$deepScan || function (val) {
+    return val
+}
+root._getJSONKey = root._getJSONKey || getJSONKey
 
-  // 新增哈希比对逻辑
+const runtimeLangMap = {
+${langEntries}
+}
+const existingLangMap = root.langMap || {}
+const langMap = { ...runtimeLangMap, ...existingLangMap }
+root.langMap = langMap
 
-  // 标记是否需要更新文件
-  let needUpdate = true;
-  if (fs.existsSync(indexPath)) {
-    // 检查文件是否已存在
-    // 读取现有文件内容
-    const existingContent = fs.readFileSync(indexPath, 'utf-8');
-    // 生成现有内容的哈希值
-    const existingHash = generateId(existingContent);
-    // 判断是否需要更新文件
-    // needUpdate = currentHash !== existingHash
-    needUpdate = !existingHash;
-  }
+function readStorageLang(key) {
+    if (!key || !root.localStorage || typeof root.localStorage.getItem !== 'function') {
+        return ''
+    }
+    return root.localStorage.getItem(key) || ''
+}
 
-  // 如果需要更新文件，则写入新内容
-  if (needUpdate) {
-    fs.writeFileSync(indexPath, translateBasicFnText);
-  }
+function applyLanguage(lang, nameSpace = DEFAULT_NAMESPACE) {
+    const runtimeKey = normalizeLangKey(lang) || ORIGIN_LANG
+    const locale = langMap[runtimeKey] || langMap[ORIGIN_LANG] || {}
+    root.$t.locale(locale, nameSpace)
+    return locale
+}
+
+const storedCommonLang = readStorageLang(COMMON_TRANSLATE_KEY)
+const storedLang = readStorageLang('lang')
+applyLanguage(storedCommonLang || storedLang || ORIGIN_LANG)
+
+root.$changeLang = function (lang, nameSpace = DEFAULT_NAMESPACE) {
+    return applyLanguage(lang, nameSpace)
+}
+
+export default {
+    install() {
+        applyLanguage(readStorageLang(COMMON_TRANSLATE_KEY) || readStorageLang('lang') || ORIGIN_LANG)
+    }
+}
+`;
+}
+
+/**
+ * @description: 初始化翻译基础函数文件
+ * @returns {void}
+ */
+async function initTranslateBasicFnFile() {
+  const indexPath = path.join(exports.option.globalPath, 'index.js');
+
+  // 项目已有 lang/index.js 时保留项目自定义运行时，不再由插件覆盖。
+  if (fs.existsSync(indexPath)) return;
+  const translateBasicFnText = createRuntimeIndexCode();
+  fs.writeFileSync(indexPath, translateBasicFnText);
 }
 /**
  * @description: 生成国际化JSON文件
@@ -1294,11 +1354,13 @@ function uploadFile() {
 
 var file = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    createRuntimeIndexCode: createRuntimeIndexCode,
     getLangObjByJSONFileWithLangKey: getLangObjByJSONFileWithLangKey,
     getLangTranslateJSONFile: getLangTranslateJSONFile,
     initLangFile: initLangFile,
     initLangTranslateJSONFile: initLangTranslateJSONFile,
     initTranslateBasicFnFile: initTranslateBasicFnFile,
+    normalizeRuntimeLangKey: normalizeRuntimeLangKey,
     setLangTranslateJSONFile: setLangTranslateJSONFile,
     uploadFile: uploadFile
 });
@@ -1839,6 +1901,13 @@ function createI18nTranslator(createOption) {
     uncodeValue: valStr,
     namespace: nameSpace
   };
+  insertOption?.collector?.record?.({
+    key: exports.option.useValueAsKey ? trimmedValue : generatedKey,
+    value: trimmedValue,
+    namespace: nameSpace,
+    resourcePath: insertOption?.resourcePath,
+    root: insertOption?.root
+  });
   if (exports.option.translateExtends) {
     const {
       handleCodeCall,
@@ -2470,9 +2539,13 @@ function getExpressionPlaceholder(expression) {
     return getExpressionPlaceholder(expression.expression);
   }
   const generateCode = generate__namespace.default?.default || generate__namespace.default || generate__namespace;
-  return generateCode(expression, {
+  return normalizeExpressionPlaceholder(generateCode(expression, {
     comments: false
-  }).code;
+  }).code);
+}
+function normalizeExpressionPlaceholder(placeholder) {
+  if (placeholder === null) return null;
+  return placeholder.replace(/(^|[^\w$])(?:_vm|\$data)\s*\./g, '$1').replace(/(^|[^\w$])(?:_vm|\$data)\s*\[/g, '$1[');
 }
 function optimizeConditionalExpression(expression) {
   if (!types.isConditionalExpression(expression)) return null;
@@ -2718,11 +2791,11 @@ function CallExpressionFn (insertOption) {
             isExpression: true
           });
           path.replaceWith(replaceNode);
-          translateSetLang(replaceNode);
+          translateSetLang(replaceNode, insertOption);
         }
       } else if (exports.option.translateType === TranslateTypeEnum.FULL_AUTO) {
         // 全自动模式下还是只收集 单独 $t 调用
-        if (callee.name === exports.option.translateKey || callee.property && callee.property.name === exports.option.translateKey) translateSetLang(node);
+        if (callee.name === exports.option.translateKey || callee.property && callee.property.name === exports.option.translateKey) translateSetLang(node, insertOption);
       }
     }
   };
@@ -2733,7 +2806,7 @@ function CallExpressionFn (insertOption) {
  * @param node - 调用表达式节点
  * @return
  */
-function translateSetLang(node) {
+function translateSetLang(node, insertOption) {
   // 获取调用表达式的参数
   let arg = node.arguments || [];
   // 提取参数作为值
@@ -2754,6 +2827,13 @@ function translateSetLang(node) {
     }
     // 调用翻译工具的 setLangObj 方法设置语言对象属性
     setLangObj(resolvedId, value);
+    insertOption?.collector?.record?.({
+      key: exports.option.useValueAsKey ? value : resolvedId,
+      value,
+      namespace: exports.option.namespace,
+      resourcePath: insertOption?.resourcePath,
+      root: insertOption?.root
+    });
   }
 }
 
@@ -2895,10 +2975,310 @@ var index$1 = /*#__PURE__*/Object.freeze({
     default: index
 });
 
+const RUNTIME_MANIFEST_VERSION = 1;
+const RUNTIME_MANIFEST_GLOBAL = '__GC_I18N_RUNTIME_MANIFEST__';
+const VITE_RUNTIME_MANIFEST_ID = 'virtual:gc-i18n-runtime-manifest';
+const VITE_RUNTIME_BOOTSTRAP_ID = 'virtual:gc-i18n-runtime-bootstrap';
+const RESOLVED_VITE_RUNTIME_MANIFEST_ID = `\0${VITE_RUNTIME_MANIFEST_ID}`;
+const RESOLVED_VITE_RUNTIME_BOOTSTRAP_ID = `\0${VITE_RUNTIME_BOOTSTRAP_ID}`;
+function normalizeResourcePath(resourcePath, root) {
+  if (!resourcePath) return undefined;
+  if (!root) return resourcePath;
+  const relativePath = path.relative(root, resourcePath);
+  return relativePath && !relativePath.startsWith('..') ? relativePath : resourcePath;
+}
+function createI18nManifestCollector() {
+  let root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : process.cwd();
+  const records = new Map();
+  return {
+    record(input) {
+      if (!input.key || !input.value) return;
+      const resourcePath = normalizeResourcePath(input.resourcePath, input.root || root);
+      const namespace = input.namespace || 'lang';
+      const dedupeKey = [namespace, resourcePath || '', input.key].join('\u0000');
+      records.set(dedupeKey, {
+        key: input.key,
+        value: input.value,
+        namespace,
+        ...(resourcePath ? {
+          resourcePath
+        } : {})
+      });
+    },
+    toJSON() {
+      let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      const recordList = Array.from(records.values()).sort((left, right) => {
+        const leftPath = left.resourcePath || '';
+        const rightPath = right.resourcePath || '';
+        return leftPath.localeCompare(rightPath) || left.key.localeCompare(right.key);
+      });
+      const resourceMap = new Map();
+      const allKeys = new Set();
+      recordList.forEach(record => {
+        const resourcePath = record.resourcePath || '<unknown>';
+        const keys = resourceMap.get(resourcePath) || new Set();
+        keys.add(record.key);
+        allKeys.add(record.key);
+        resourceMap.set(resourcePath, keys);
+      });
+      const byFile = Object.fromEntries(Array.from(resourceMap.entries()).map(_ref => {
+        let [resourcePath, keys] = _ref;
+        return [resourcePath, Array.from(keys).sort()];
+      }));
+      return {
+        version: RUNTIME_MANIFEST_VERSION,
+        namespace: option.namespace || 'lang',
+        translateKey: option.translateKey || '$t',
+        originLang: option.originLang || 'zh-cn',
+        targetLangList: option.targetLangList || [],
+        resources: Object.entries(byFile).map(_ref2 => {
+          let [resourcePath, keys] = _ref2;
+          return {
+            path: resourcePath,
+            keys
+          };
+        }),
+        byFile,
+        allKeys: Array.from(allKeys).sort(),
+        records: recordList
+      };
+    },
+    clear() {
+      records.clear();
+    }
+  };
+}
+function serializeRuntimeManifest(manifest) {
+  return `const manifest = ${JSON.stringify(manifest, null, 2)};\nexport { manifest };\nexport default manifest;\n`;
+}
+function createRuntimeBootstrapCode() {
+  let manifestModuleId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : VITE_RUNTIME_MANIFEST_ID;
+  return `import manifest from ${JSON.stringify(manifestModuleId)};\nconst target = typeof globalThis !== 'undefined' ? globalThis : window;\ntarget[${JSON.stringify(RUNTIME_MANIFEST_GLOBAL)}] = manifest;\nexport { manifest };\nexport default manifest;\n`;
+}
+function writeWebpackRuntimeBootstrap(root, manifestAssetName) {
+  const outputDir = path.join(root, 'node_modules', '.cache', 'gc-i18n-plugin');
+  fs.mkdirSync(outputDir, {
+    recursive: true
+  });
+  const bootstrapPath = path.join(outputDir, 'runtime-bootstrap.js');
+  const source = `if (typeof globalThis !== 'undefined') {\n  globalThis[${JSON.stringify(RUNTIME_MANIFEST_GLOBAL)}] = globalThis[${JSON.stringify(RUNTIME_MANIFEST_GLOBAL)}] || { version: ${RUNTIME_MANIFEST_VERSION}, resources: [], records: [] };\n  globalThis[${JSON.stringify(RUNTIME_MANIFEST_GLOBAL)}].asset = ${JSON.stringify(manifestAssetName)};\n}\n`;
+  fs.writeFileSync(bootstrapPath, source);
+  return bootstrapPath;
+}
+function prependWebpackEntry(entry, bootstrapPath) {
+  if (!entry) return entry;
+  if (typeof entry === 'string') return [bootstrapPath, entry];
+  if (Array.isArray(entry)) return [bootstrapPath, ...entry];
+  if (typeof entry === 'function') {
+    return async () => prependWebpackEntry(await entry(), bootstrapPath);
+  }
+  if (typeof entry === 'object') {
+    return Object.fromEntries(Object.entries(entry).map(_ref3 => {
+      let [name, value] = _ref3;
+      if (typeof value === 'string' || Array.isArray(value)) {
+        return [name, prependWebpackEntry(value, bootstrapPath)];
+      }
+      if (value && typeof value === 'object' && 'import' in value) {
+        return [name, {
+          ...value,
+          import: prependWebpackEntry(value.import, bootstrapPath)
+        }];
+      }
+      return [name, value];
+    }));
+  }
+  return entry;
+}
+
+const RTL_LANGUAGES = new Set(['ar', 'fa', 'he', 'iw', 'ps', 'ur']);
+const DEFAULT_NAMESPACE = 'lang';
+const DEFAULT_HOTKEY = 'Alt+KeyI';
+function normalizeLocale(locale) {
+  let fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return String(locale || fallback).toLowerCase().replace(/_/g, '-');
+}
+function normalizeStorageKey(locale) {
+  let fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return normalizeLocale(locale, fallback).replace(/[^a-z0-9]/g, '');
+}
+function cloneMessages(messages) {
+  return Object.keys(messages || {}).reduce((result, locale) => {
+    result[normalizeStorageKey(locale)] = {
+      ...(messages?.[locale] || {})
+    };
+    return result;
+  }, {});
+}
+function mergeMessageLayers() {
+  for (var _len = arguments.length, layers = new Array(_len), _key = 0; _key < _len; _key++) {
+    layers[_key] = arguments[_key];
+  }
+  return layers.reduce((result, layer) => {
+    Object.keys(layer || {}).forEach(locale => {
+      const runtimeLocale = normalizeStorageKey(locale);
+      result[runtimeLocale] = {
+        ...(result[runtimeLocale] || {}),
+        ...(layer?.[locale] || {})
+      };
+    });
+    return result;
+  }, {});
+}
+function getMessagesForLocale(messages, runtimeLocale) {
+  const baseLocale = runtimeLocale.slice(0, 2);
+  return {
+    ...(messages[runtimeLocale] || {}),
+    ...(baseLocale === runtimeLocale ? {} : messages[baseLocale] || {})
+  };
+}
+function interpolate(template, params) {
+  if (!params) return template;
+  return template.replace(/\{\{?\s*([\w.]+)\s*\}?\}/g, (match, path) => {
+    const value = String(path).split('.').reduce((current, key) => {
+      if (current && typeof current === 'object' && key in current) {
+        return current[key];
+      }
+      return undefined;
+    }, params);
+    return value === undefined || value === null ? match : String(value);
+  });
+}
+function parseHotkey(event, hotkey) {
+  const parts = hotkey.split('+');
+  const code = parts.pop();
+  const modifiers = new Set(parts.map(part => part.toLowerCase()));
+  return (!modifiers.has('alt') || !!event.altKey) && (!modifiers.has('ctrl') || !!event.ctrlKey) && (!modifiers.has('meta') || !!event.metaKey) && (!modifiers.has('shift') || !!event.shiftKey) && (!code || event.code === code || event.key === code);
+}
+function createI18nRuntime() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const namespace = options.namespace || DEFAULT_NAMESPACE;
+  const fallbackLocale = normalizeStorageKey(options.fallbackLocale || options.initialLocale || 'zh-cn');
+  let locale = normalizeStorageKey(options.initialLocale, fallbackLocale);
+  let commonMessages = cloneMessages(options.commonMessages);
+  let localMessages = cloneMessages(options.localMessages);
+  let remoteMessages = cloneMessages(options.remoteMessages);
+  const delta = new Map();
+  const runtime = {
+    namespace,
+    getLocale() {
+      return locale;
+    },
+    setRemoteMessages(messages) {
+      remoteMessages = cloneMessages(messages);
+    },
+    mergeMessages(messages) {
+      let layer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'local';
+      if (layer === 'common') commonMessages = mergeMessageLayers(commonMessages, cloneMessages(messages));
+      if (layer === 'local') localMessages = mergeMessageLayers(localMessages, cloneMessages(messages));
+      if (layer === 'remote') remoteMessages = mergeMessageLayers(remoteMessages, cloneMessages(messages));
+    },
+    t(key) {
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let params = arguments.length > 2 ? arguments[2] : undefined;
+      let callNamespace = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : namespace;
+      const interpolationParams = typeof value === 'object' ? value : params;
+      const fallbackValue = typeof value === 'string' ? value : key;
+      const messages = runtime.getMergedMessages();
+      const localeMessages = {
+        ...getMessagesForLocale(messages, fallbackLocale),
+        ...getMessagesForLocale(messages, locale)
+      };
+      const translated = localeMessages[key];
+      if (translated === undefined) {
+        const deltaKey = `${callNamespace}:${locale}:${key}`;
+        if (!delta.has(deltaKey)) {
+          delta.set(deltaKey, {
+            key,
+            value: fallbackValue,
+            locale,
+            namespace: callNamespace
+          });
+        }
+      }
+      return interpolate(translated || fallbackValue || key, interpolationParams);
+    },
+    changeLocale(nextLocale) {
+      locale = normalizeStorageKey(nextLocale, fallbackLocale);
+      return locale;
+    },
+    clearI18n() {
+      remoteMessages = {};
+      delta.clear();
+    },
+    isRTL() {
+      let targetLocale = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : locale;
+      const lang = normalizeLocale(targetLocale).split('-')[0];
+      return RTL_LANGUAGES.has(lang);
+    },
+    getDelta() {
+      return Array.from(delta.values());
+    },
+    getMergedMessages() {
+      return mergeMessageLayers(commonMessages, localMessages, remoteMessages);
+    },
+    requestConfig() {
+      const payload = {
+        locale,
+        namespace,
+        delta: runtime.getDelta(),
+        messages: runtime.getMergedMessages()
+      };
+      options.onConfigRequest?.(payload);
+      return payload;
+    },
+    install() {
+      let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : options.target || (typeof globalThis !== 'undefined' ? globalThis : undefined);
+      if (!target) return runtime;
+      target.$t = runtime.t;
+      target.$changeLocale = runtime.changeLocale;
+      target.$clearI18n = runtime.clearI18n;
+      target.$isRTL = runtime.isRTL;
+      target.__GC_I18N_RUNTIME__ = runtime;
+      return runtime;
+    }
+  };
+  return runtime;
+}
+function installI18nRuntime(app) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const runtime = createI18nRuntime({
+    ...options,
+    localMessages: mergeMessageLayers(options.localMessages, options.messages)
+  });
+  runtime.install(options.target);
+  if (app && typeof app.config === 'object') {
+    app.config.globalProperties = app.config.globalProperties || {};
+    app.config.globalProperties.$t = runtime.t;
+    app.config.globalProperties.$changeLocale = runtime.changeLocale;
+    app.config.globalProperties.$clearI18n = runtime.clearI18n;
+    app.config.globalProperties.$isRTL = runtime.isRTL;
+  }
+  const target = options.target || (typeof globalThis !== 'undefined' ? globalThis : undefined);
+  const hotkey = options.hotkey === false ? false : options.hotkey || DEFAULT_HOTKEY;
+  if (target && hotkey && typeof target.addEventListener === 'function') {
+    target.addEventListener('keydown', event => {
+      if (!parseHotkey(event, hotkey)) return;
+      const payload = runtime.requestConfig();
+      if (typeof target.dispatchEvent === 'function' && typeof target.CustomEvent === 'function') {
+        target.dispatchEvent(new target.CustomEvent('gc-i18n-config-request', {
+          detail: payload
+        }));
+      }
+    });
+  }
+  return runtime;
+}
+const runtimeUtils = {
+  normalizeLocale,
+  normalizeStorageKey,
+  mergeMessageLayers
+};
+
 var allowedExtensions = ['.vue', '.ts', '.js', '.tsx', '.jsx'];
 function vitePluginsAutoI18n(optionInfo) {
   var name = 'vite-gc-i18n-plugin';
   var config;
+  var collector = createI18nManifestCollector();
   initOption(__assign({
     deepScan: true,
     globalPath: './lang',
@@ -2923,6 +3303,27 @@ function vitePluginsAutoI18n(optionInfo) {
       // 存储最终解析的配置
       config = resolvedConfig;
     },
+    resolveId: function (id) {
+      if (id === VITE_RUNTIME_MANIFEST_ID) return RESOLVED_VITE_RUNTIME_MANIFEST_ID;
+      if (id === VITE_RUNTIME_BOOTSTRAP_ID) return RESOLVED_VITE_RUNTIME_BOOTSTRAP_ID;
+    },
+    load: function (id) {
+      if (id === RESOLVED_VITE_RUNTIME_MANIFEST_ID) {
+        return serializeRuntimeManifest(collector.toJSON({
+          namespace: exports.option.namespace,
+          translateKey: exports.option.translateKey,
+          originLang: exports.option.originLang,
+          targetLangList: exports.option.targetLangList
+        }));
+      }
+      if (id === RESOLVED_VITE_RUNTIME_BOOTSTRAP_ID) {
+        return createRuntimeBootstrapCode();
+      }
+    },
+    transformIndexHtml: function (html) {
+      var bootstrap = "<script type=\"module\">import ".concat(JSON.stringify(VITE_RUNTIME_BOOTSTRAP_ID), ";</script>");
+      return html.includes(VITE_RUNTIME_BOOTSTRAP_ID) ? html : html.replace('</head>', "".concat(bootstrap, "\n</head>"));
+    },
     transform: function (code, path) {
       return __awaiter(this, void 0, void 0, function () {
         var sourceObj;
@@ -2950,7 +3351,11 @@ function vitePluginsAutoI18n(optionInfo) {
             case 3:
               return [2 /*return*/, babel__namespace.transformAsync(sourceObj.source, {
                 configFile: false,
-                plugins: [index()]
+                plugins: [index(__assign(__assign({}, sourceObj), {
+                  resourcePath: path,
+                  root: config === null || config === void 0 ? void 0 : config.root,
+                  collector: collector
+                }))]
               }).then(function (result) {
                 if ((config === null || config === void 0 ? void 0 : config.command) === 'serve') {
                   autoTranslate(); // 执行前需要确保transformAsync已经完成
@@ -3011,19 +3416,33 @@ exports.FunctionFactoryOption = FunctionFactoryOption;
 exports.GoogleTranslator = GoogleTranslator;
 exports.LanguageEnum = LanguageEnum;
 exports.OriginLangKeyEnum = OriginLangKeyEnum;
+exports.RESOLVED_VITE_RUNTIME_BOOTSTRAP_ID = RESOLVED_VITE_RUNTIME_BOOTSTRAP_ID;
+exports.RESOLVED_VITE_RUNTIME_MANIFEST_ID = RESOLVED_VITE_RUNTIME_MANIFEST_ID;
+exports.RUNTIME_MANIFEST_GLOBAL = RUNTIME_MANIFEST_GLOBAL;
+exports.RUNTIME_MANIFEST_VERSION = RUNTIME_MANIFEST_VERSION;
 exports.ScanTranslator = ScanTranslator;
 exports.TranslateApiEnum = TranslateApiEnum;
 exports.TranslateTypeEnum = TranslateTypeEnum;
 exports.Translator = Translator;
+exports.VITE_RUNTIME_BOOTSTRAP_ID = VITE_RUNTIME_BOOTSTRAP_ID;
+exports.VITE_RUNTIME_MANIFEST_ID = VITE_RUNTIME_MANIFEST_ID;
 exports.VolcengineTranslator = VolcengineTranslator;
 exports.Vue2Extends = Vue2Extends;
 exports.YoudaoTranslator = YoudaoTranslator;
 exports.baseUtils = base;
 exports.checkOption = checkOption;
+exports.createI18nManifestCollector = createI18nManifestCollector;
+exports.createI18nRuntime = createI18nRuntime;
+exports.createRuntimeBootstrapCode = createRuntimeBootstrapCode;
 exports.default = vitePluginsAutoI18n;
 exports.fileUtils = file;
 exports.filter = index$1;
 exports.initOption = initOption;
+exports.installI18nRuntime = installI18nRuntime;
+exports.prependWebpackEntry = prependWebpackEntry;
+exports.runtimeUtils = runtimeUtils;
+exports.serializeRuntimeManifest = serializeRuntimeManifest;
 exports.translateUtils = translate;
 exports.uploadUtils = upload$1;
+exports.writeWebpackRuntimeBootstrap = writeWebpackRuntimeBootstrap;
 //# sourceMappingURL=index.cjs.map