iframe-bridge-kit 1.0.1

package/dist/vite.js

@@ -0,0 +1,719 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => vitePluginIframeBridge
+});
+module.exports = __toCommonJS(vite_exports);
+var ts = __toESM(require("typescript"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+
+// package.json
+var package_default = {
+  name: "iframe-bridge-kit",
+  version: "1.0.0",
+  description: "A type-safe communication bridge for iframes. Define strongly typed RPC APIs for cross-window messaging with ease.",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  scripts: {
+    build: "tsup && tsup --config core.tsup.config.ts && tsup --config core.full.tsup.config.ts",
+    dev: "tsup --watch"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./vite": {
+      types: "./dist/vite.d.ts",
+      import: "./dist/vite.mjs",
+      require: "./dist/vite.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  keywords: [
+    "iframe",
+    "postMessage",
+    "rpc",
+    "bridge",
+    "typescript",
+    "type-safe",
+    "cross-origin",
+    "penpal",
+    "window-messaging",
+    "api-definition"
+  ],
+  author: "ZhangSan <2306860505@qq.com>",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/mchao123/iframe-bridge-kit.git"
+  },
+  homepage: "https://github.com/mchao123/iframe-bridge-kit#readme",
+  bugs: {
+    url: "https://github.com/mchao123/iframe-bridge-kit/issues"
+  },
+  devDependencies: {
+    "@types/node": "^24.10.1",
+    tsup: "^8.5.1",
+    vite: "^7.2.6",
+    typescript: "^5.9.3"
+  },
+  peerDependencies: {
+    penpal: "^7.0.4"
+  }
+};
+
+// src/vite.ts
+var packageName = package_default.name;
+function extractScriptFromVue(code) {
+  const scriptRegex = /<script(?:\s+setup)?(?:\s+lang\s*=\s*["']?(ts|typescript)["']?)?[^>]*>([\s\S]*?)<\/script>/i;
+  const match = code.match(scriptRegex);
+  if (match) {
+    const lang = match[1] || "js";
+    const script = match[2] || "";
+    const beforeScript = code.substring(0, match.index + match[0].indexOf(">") + 1);
+    const startLine = beforeScript.split("\n").length;
+    return { script, lang, startLine };
+  }
+  return null;
+}
+function createTypeCheckerProgram(code, filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const isVueFile = normalizedPath.endsWith(".vue");
+  const tempFileName = isVueFile ? normalizedPath.replace(".vue", ".__bridge_temp__.ts") : normalizedPath + ".__bridge_temp__.ts";
+  let needsCleanup = false;
+  if (isVueFile) {
+    try {
+      fs.writeFileSync(tempFileName, code, "utf-8");
+      needsCleanup = true;
+    } catch (err) {
+      console.error(`[iframe-bridge] Failed to write temp file: ${tempFileName}`, err);
+    }
+  }
+  const cleanup = () => {
+    if (needsCleanup && fs.existsSync(tempFileName)) {
+      try {
+        fs.unlinkSync(tempFileName);
+      } catch (err) {
+      }
+    }
+  };
+  const configPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists, "tsconfig.json");
+  let compilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    noEmit: true
+  };
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.config) {
+      const parsed = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        path.dirname(configPath)
+      );
+      compilerOptions = { ...compilerOptions, ...parsed.options };
+    }
+  }
+  const targetFile = isVueFile ? tempFileName : normalizedPath;
+  const program = ts.createProgram([targetFile], compilerOptions);
+  const sourceFile = program.getSourceFile(targetFile);
+  return { program, sourceFile, cleanup };
+}
+function getTypeString(checker, type, inTypeAlias) {
+  return inTypeAlias ? checker.typeToString(
+    type,
+    void 0,
+    ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.InTypeAlias | // 强制展开类型别名
+    ts.TypeFormatFlags.UseFullyQualifiedType | ts.TypeFormatFlags.WriteArrayAsGenericType
+  ) : checker.typeToString(
+    type,
+    void 0,
+    ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType | ts.TypeFormatFlags.WriteArrayAsGenericType
+  );
+}
+function getJsDoc(node, sourceFile) {
+  const jsDocs = ts.getJSDocCommentsAndTags(node);
+  if (jsDocs.length === 0) {
+    return void 0;
+  }
+  const fullText = sourceFile.getFullText();
+  const comments = [];
+  for (const jsDoc of jsDocs) {
+    if (ts.isJSDoc(jsDoc)) {
+      const start = jsDoc.getStart(sourceFile);
+      const end = jsDoc.getEnd();
+      const text = fullText.substring(start, end);
+      comments.push(text);
+    }
+  }
+  return comments.length > 0 ? comments.join("\n") : void 0;
+}
+function parseBridgeFromCode(code, filePath) {
+  const results = [];
+  let cleanup = () => {
+  };
+  let scriptCode = code;
+  const isVueFile = filePath.endsWith(".vue");
+  if (isVueFile) {
+    const extracted = extractScriptFromVue(code);
+    if (!extracted || extracted.lang !== "ts" && extracted.lang !== "typescript") {
+      return { results, cleanup };
+    }
+    scriptCode = extracted.script;
+  }
+  const { program, sourceFile, cleanup: programCleanup } = createTypeCheckerProgram(scriptCode, filePath);
+  cleanup = programCleanup;
+  if (!sourceFile) {
+    console.warn(`[iframe-bridge] Could not parse source file: ${filePath}`);
+    return { results, cleanup };
+  }
+  const checker = program.getTypeChecker();
+  const typeDeclarations = [];
+  const typeImports = /* @__PURE__ */ new Map();
+  const collectTypeImports = (node) => {
+    if (ts.isIdentifier(node)) {
+      const symbol = checker.getSymbolAtLocation(node);
+      if (symbol && symbol.declarations && symbol.declarations.length > 0) {
+        const decl = symbol.declarations[0];
+        if (ts.isImportSpecifier(decl)) {
+          const importDecl = decl.parent.parent.parent;
+          if (ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
+            let modulePath = importDecl.moduleSpecifier.text;
+            const moduleSymbol = checker.getSymbolAtLocation(importDecl.moduleSpecifier);
+            if (moduleSymbol) {
+              const decls = moduleSymbol.getDeclarations();
+              if (decls && decls.length > 0 && ts.isSourceFile(decls[0])) {
+                modulePath = decls[0].fileName;
+              }
+            }
+            const propertyName = decl.propertyName?.text;
+            const name = decl.name.text;
+            const importStr = propertyName ? `${propertyName} as ${name}` : name;
+            if (!typeImports.has(modulePath)) {
+              typeImports.set(modulePath, /* @__PURE__ */ new Set());
+            }
+            typeImports.get(modulePath).add(importStr);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, collectTypeImports);
+  };
+  for (const stmt of sourceFile.statements) {
+    if (ts.isTypeAliasDeclaration(stmt) || ts.isInterfaceDeclaration(stmt)) {
+      typeDeclarations.push({
+        name: stmt.name.text,
+        content: stmt.getText(sourceFile)
+      });
+      collectTypeImports(stmt);
+    }
+  }
+  const defineBridgeNames = /* @__PURE__ */ new Set();
+  for (const stmt of sourceFile.statements) {
+    if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === packageName) {
+      const namedBindings = stmt.importClause?.namedBindings;
+      if (namedBindings && ts.isNamedImports(namedBindings)) {
+        for (const element of namedBindings.elements) {
+          const originalName = element.propertyName?.text ?? element.name.text;
+          if (originalName === "defineBridge") {
+            defineBridgeNames.add(element.name.text);
+          }
+        }
+      }
+    }
+  }
+  if (defineBridgeNames.size === 0) {
+    return { results, cleanup };
+  }
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && defineBridgeNames.has(node.expression.text)) {
+      const [nameArg, methodsArg] = node.arguments;
+      if (!nameArg || !ts.isStringLiteral(nameArg)) {
+        return;
+      }
+      const bridgeName = nameArg.text;
+      if (!methodsArg || !ts.isObjectLiteralExpression(methodsArg)) {
+        return;
+      }
+      const methods = [];
+      for (const prop of methodsArg.properties) {
+        let methodName = null;
+        let params = "";
+        let returnType = "void";
+        let jsdoc = void 0;
+        if (ts.isMethodDeclaration(prop)) {
+          methodName = prop.name && ts.isIdentifier(prop.name) ? prop.name.text : null;
+          if (!methodName) continue;
+          const signature = checker.getSignatureFromDeclaration(prop);
+          if (signature) {
+            const paramStrings = prop.parameters.map((p) => {
+              const paramName = p.name.getText(sourceFile);
+              const paramSymbol = checker.getSymbolAtLocation(p.name);
+              let paramType = "unknown";
+              if (paramSymbol) {
+                const type = checker.getTypeOfSymbolAtLocation(paramSymbol, p);
+                paramType = getTypeString(checker, type);
+              } else if (p.type) {
+                paramType = p.type.getText(sourceFile);
+              }
+              const optional = p.questionToken ? "?" : "";
+              return `${paramName}${optional}: ${paramType}`;
+            });
+            params = paramStrings.join(", ");
+            const retType = signature.getReturnType();
+            returnType = getTypeString(checker, retType);
+          }
+          jsdoc = getJsDoc(prop, sourceFile);
+        } else if (ts.isPropertyAssignment(prop)) {
+          methodName = prop.name && ts.isIdentifier(prop.name) ? prop.name.text : null;
+          if (!methodName) continue;
+          const init = prop.initializer;
+          if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+            const signature = checker.getSignatureFromDeclaration(init);
+            if (signature) {
+              const paramStrings = init.parameters.map((p) => {
+                const paramName = p.name.getText(sourceFile);
+                const paramSymbol = checker.getSymbolAtLocation(p.name);
+                let paramType = "unknown";
+                if (paramSymbol) {
+                  const type = checker.getTypeOfSymbolAtLocation(paramSymbol, p);
+                  paramType = getTypeString(checker, type);
+                } else if (p.type) {
+                  paramType = p.type.getText(sourceFile);
+                }
+                const optional = p.questionToken ? "?" : "";
+                return `${paramName}${optional}: ${paramType}`;
+              });
+              params = paramStrings.join(", ");
+              const retType = signature.getReturnType();
+              returnType = getTypeString(checker, retType);
+            }
+          }
+          jsdoc = getJsDoc(prop, sourceFile);
+        } else if (ts.isShorthandPropertyAssignment(prop)) {
+          methodName = prop.name.text;
+          const symbol = checker.getSymbolAtLocation(prop.name);
+          if (symbol) {
+            const type = checker.getTypeOfSymbolAtLocation(symbol, prop);
+            const callSignatures = type.getCallSignatures();
+            if (callSignatures.length > 0) {
+              const signature = callSignatures[0];
+              const paramStrings = signature.getParameters().map((param) => {
+                const paramType = checker.getTypeOfSymbolAtLocation(param, prop);
+                const paramName = param.getName();
+                return `${paramName}: ${getTypeString(checker, paramType)}`;
+              });
+              params = paramStrings.join(", ");
+              const retType = signature.getReturnType();
+              returnType = getTypeString(checker, retType);
+            }
+          }
+          jsdoc = getJsDoc(prop, sourceFile);
+          if (!jsdoc && symbol && symbol.valueDeclaration) {
+            jsdoc = getJsDoc(symbol.valueDeclaration, sourceFile);
+          }
+        }
+        if (methodName) {
+          methods.push({
+            name: methodName,
+            params,
+            returnType,
+            jsdoc
+          });
+        }
+      }
+      const emitMap = [];
+      if (node.typeArguments && node.typeArguments.length > 0) {
+        const emitTypeNode = node.typeArguments[0];
+        const emitType = checker.getTypeFromTypeNode(emitTypeNode);
+        emitType.getProperties().forEach((prop) => {
+          const name = prop.getName();
+          let type = "any";
+          const propType = checker.getTypeOfSymbolAtLocation(prop, node);
+          type = getTypeString(checker, propType);
+          emitMap.push({ name, type });
+        });
+      }
+      const bridgeImports = /* @__PURE__ */ new Map();
+      mergeImports(bridgeImports, typeImports);
+      results.push({
+        name: bridgeName,
+        methods,
+        sourceFile: filePath,
+        typeDeclarations,
+        imports: bridgeImports,
+        emitMap
+      });
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return { results, cleanup };
+}
+function extractTypeExport(filePath, typeName) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const code = fs.readFileSync(filePath, "utf-8");
+    const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+    let result = null;
+    ts.forEachChild(sourceFile, (node) => {
+      if (result) return;
+      if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
+        if (node.name?.text === typeName) {
+          let text = node.getText(sourceFile);
+          text = text.replace(/^\s*export\s+/, "");
+          text = text.replace(/^\s*declare\s+/, "");
+          result = text;
+        }
+      }
+    });
+    return result;
+  } catch (e) {
+    return null;
+  }
+}
+function processTypeString(typeStr, outDir, registry, preserveModules = []) {
+  const imports = /* @__PURE__ */ new Map();
+  const outputDir = path.resolve(process.cwd(), outDir);
+  const importPattern = /import\("([^"]+)"\)\.(\w+)/g;
+  const processed = typeStr.replace(importPattern, (match, importPath, typeName) => {
+    let normalizedPath = importPath.replace(/\\/g, "/");
+    const nodeModulesIndex = normalizedPath.lastIndexOf("/node_modules/");
+    const isNodeModule = nodeModulesIndex !== -1;
+    if (isNodeModule) {
+      const afterNodeModules = normalizedPath.substring(nodeModulesIndex + 14);
+      const parts = afterNodeModules.split("/");
+      let moduleName = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+      let shouldPreserve = preserveModules.some((m) => moduleName === m || moduleName.startsWith(m + "/"));
+      if (preserveModules.includes("vue") && moduleName.startsWith("@vue/")) {
+        shouldPreserve = true;
+        moduleName = "vue";
+      }
+      if (shouldPreserve) {
+        if (!imports.has(moduleName)) {
+          imports.set(moduleName, /* @__PURE__ */ new Set());
+        }
+        imports.get(moduleName).add(typeName);
+        return typeName;
+      }
+    }
+    let absoluteImportPath = normalizedPath;
+    if (!fs.existsSync(absoluteImportPath) && !absoluteImportPath.endsWith(".ts")) {
+      if (fs.existsSync(absoluteImportPath + ".ts")) {
+        absoluteImportPath += ".ts";
+      } else if (fs.existsSync(absoluteImportPath + ".d.ts")) {
+        absoluteImportPath += ".d.ts";
+      }
+    }
+    const registryKey = `${absoluteImportPath}::${typeName}`;
+    if (registry.has(registryKey)) {
+      return registry.get(registryKey).uniqueName;
+    }
+    const definition = extractTypeExport(absoluteImportPath, typeName);
+    if (definition) {
+      const uniqueSuffix = Math.random().toString(36).substring(2, 8);
+      const uniqueName = `${typeName}_${uniqueSuffix}`;
+      const renameRegex = new RegExp(`\\b${typeName}\\b(?!\\s*[:(])`, "g");
+      const renamedDefinition = definition.replace(renameRegex, uniqueName);
+      registry.set(registryKey, {
+        uniqueName,
+        definition: renamedDefinition
+      });
+      return uniqueName;
+    }
+    const relativeFromOutput = path.relative(outputDir, absoluteImportPath).replace(/\\/g, "/");
+    const cleanPath = relativeFromOutput.replace(/(\.d)?\.ts$/, "").replace(/\.vue$/, "");
+    const finalPath = cleanPath.startsWith(".") ? cleanPath : "./" + cleanPath;
+    if (!imports.has(finalPath)) {
+      imports.set(finalPath, /* @__PURE__ */ new Set());
+    }
+    imports.get(finalPath).add(typeName);
+    return typeName;
+  });
+  return { processed, imports };
+}
+function mergeImports(target, source) {
+  for (const [mod, types] of source) {
+    if (!target.has(mod)) {
+      target.set(mod, /* @__PURE__ */ new Set());
+    }
+    for (const t of types) {
+      target.get(mod).add(t);
+    }
+  }
+}
+function generateDtsContent(info, outDir, preserveModules = []) {
+  const allImports = /* @__PURE__ */ new Map();
+  const registry = /* @__PURE__ */ new Map();
+  const outputDir = path.resolve(process.cwd(), outDir);
+  if (info.imports) {
+    for (const [pathKey, types] of info.imports) {
+      let normalizedPath = pathKey.replace(/\\/g, "/");
+      if (normalizedPath.includes("/node_modules/")) {
+        const index = normalizedPath.lastIndexOf("/node_modules/");
+        const after = normalizedPath.substring(index + 14);
+        const parts = after.split("/");
+        let mod = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+        if (allImports.has(mod)) {
+          types.forEach((t) => allImports.get(mod).add(t));
+        } else {
+          allImports.set(mod, new Set(types));
+        }
+      } else if (path.isAbsolute(normalizedPath)) {
+        const rel = path.relative(outputDir, normalizedPath).replace(/\\/g, "/");
+        const clean = rel.replace(/(\.d)?\.ts$/, "").replace(/\.vue$/, "");
+        const final = clean.startsWith(".") ? clean : "./" + clean;
+        if (allImports.has(final)) {
+          types.forEach((t) => allImports.get(final).add(t));
+        } else {
+          allImports.set(final, new Set(types));
+        }
+      } else {
+        if (allImports.has(normalizedPath)) {
+          types.forEach((t) => allImports.get(normalizedPath).add(t));
+        } else {
+          allImports.set(normalizedPath, new Set(types));
+        }
+      }
+    }
+  }
+  const processedMethods = info.methods.map((m) => {
+    const resultParams = processTypeString(m.params, outDir, registry, preserveModules);
+    const resultReturn = processTypeString(m.returnType, outDir, registry, preserveModules);
+    mergeImports(allImports, resultParams.imports);
+    mergeImports(allImports, resultReturn.imports);
+    return {
+      ...m,
+      params: resultParams.processed,
+      returnType: resultReturn.processed.startsWith("Promise") ? resultReturn.processed : `Promise<${resultReturn.processed}>`
+    };
+  });
+  const emitMap = info.emitMap || [];
+  const processedEmitTypes = emitMap.map((e) => {
+    const res = processTypeString(e.type, outDir, registry, preserveModules);
+    mergeImports(allImports, res.imports);
+    return { name: e.name, type: res.processed };
+  });
+  const lines = [
+    "// Auto-generated by vite-plugin-iframe-bridge",
+    "// Do not edit this file manually",
+    ""
+  ];
+  if (allImports.size > 0) {
+    for (const [mod, types] of allImports) {
+      const typeList = Array.from(types).sort().join(", ");
+      lines.push(`import type { ${typeList} } from '${mod}';`);
+    }
+    lines.push("");
+  }
+  if (registry.size > 0) {
+    lines.push("// Copied type definitions");
+    const sortedDefs = Array.from(registry.values()).sort((a, b) => a.uniqueName.localeCompare(b.uniqueName));
+    for (const { definition } of sortedDefs) {
+      lines.push(definition);
+      lines.push("");
+    }
+  }
+  if (processedEmitTypes.length > 0) {
+    lines.push("export interface EmitMap {");
+    processedEmitTypes.forEach((e) => {
+      lines.push(`    "${e.name}": ${e.type};`);
+    });
+    lines.push("}");
+    lines.push("");
+    lines.push("export declare function onMessage<K extends keyof EmitMap>(type: K, cb: (data: EmitMap[K]) => void, once?: boolean): () => void;");
+    lines.push("export declare function onMessage(type: string, cb: Function, once?: boolean): () => void;");
+    lines.push("export declare function offMessage<K extends keyof EmitMap>(type: K, fn?: (data: EmitMap[K]) => void): void;");
+    lines.push("export declare function offMessage(type: string, fn?: Function): void;");
+  } else {
+    lines.push("export declare function onMessage(type: string, cb: Function, once?: boolean): () => void;");
+    lines.push("export declare function offMessage(type: string, fn?: Function): void;");
+  }
+  lines.push("export declare function isInit(): boolean;");
+  lines.push("export declare function onInit(cb: Function): void;");
+  lines.push("");
+  lines.push(`export default {} as {`);
+  lines.push(
+    ...processedMethods.map(
+      (m) => (m.jsdoc ? `    ${m.jsdoc}
+` : "") + `    ${m.name}: (${m.params}) => ${m.returnType},`
+    )
+  );
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function writeDtsFile(info, options) {
+  const outDir = options.outDir || "bridges";
+  const absoluteOutDir = path.resolve(process.cwd(), outDir);
+  const dtsContent = generateDtsContent(info, outDir, options.preserveModules);
+  const dtsDir = path.join(absoluteOutDir, info.name);
+  if (!fs.existsSync(dtsDir)) {
+    fs.mkdirSync(dtsDir, { recursive: true });
+  }
+  fs.writeFileSync(path.join(dtsDir, "index.d.ts"), dtsContent, "utf-8");
+  fs.writeFileSync(path.join(dtsDir, "index.d.mts"), dtsContent, "utf-8");
+  console.log(`[iframe-bridge] Generated: ${dtsDir}`);
+}
+function processFile(filePath, code, options) {
+  if (!code.includes(packageName)) {
+    return [];
+  }
+  if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") && !filePath.endsWith(".vue")) {
+    return [];
+  }
+  try {
+    const { results: bridges, cleanup } = parseBridgeFromCode(code, filePath);
+    for (const bridge of bridges) {
+      writeDtsFile(bridge, options);
+      writeBridgeRuntime(bridge.name, options);
+    }
+    cleanup();
+    return bridges;
+  } catch (err) {
+    console.error(`[iframe-bridge] Error parsing ${filePath}:`, err);
+    return [];
+  }
+}
+function writeBridgeRuntime(bridgeName, options) {
+  const isFull = options.full !== false;
+  const allowedOrigins = options.allowedOrigins || ["*"];
+  const outDir = options.outDir || "bridges";
+  const variant = isFull ? "full" : "mini";
+  const basePaths = [
+    // 1. 假设我们在 dist 目录中运行
+    path.resolve(__dirname, variant),
+    // 2. 假设我们在 src 目录中运行
+    path.resolve(__dirname, "../dist", variant)
+  ];
+  let coreDir = "";
+  for (const p of basePaths) {
+    if (fs.existsSync(p)) {
+      coreDir = p;
+      break;
+    }
+  }
+  if (!coreDir) {
+    return;
+  }
+  const absoluteOutDir = path.resolve(process.cwd(), outDir, bridgeName);
+  if (!fs.existsSync(absoluteOutDir)) {
+    fs.mkdirSync(absoluteOutDir, { recursive: true });
+  }
+  const extensions = ["js", "mjs"];
+  const replaceContent = JSON.stringify(allowedOrigins).slice(1, -1);
+  for (const ext of extensions) {
+    const srcFile = path.join(coreDir, `core.${ext}`);
+    if (fs.existsSync(srcFile)) {
+      try {
+        let content = fs.readFileSync(srcFile, "utf-8");
+        content = content.replace(/["']__AllowedOrigins__["']/g, replaceContent);
+        const destPath = path.join(absoluteOutDir, `index.${ext}`);
+        fs.writeFileSync(destPath, content, "utf-8");
+      } catch (err) {
+        console.error(`[iframe-bridge] Failed to copy core.${ext}:`, err);
+      }
+    }
+  }
+}
+function vitePluginIframeBridge(options = {}) {
+  const bridgeRegistry = /* @__PURE__ */ new Map();
+  return {
+    name: "vite-plugin-iframe-bridge",
+    // 开发服务器启动时配置
+    configureServer(server) {
+      server.watcher.on("change", (filePath) => {
+        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") && !filePath.endsWith(".vue")) {
+          return;
+        }
+        try {
+          const code = fs.readFileSync(filePath, "utf-8");
+          const bridges = processFile(filePath, code, options);
+          for (const bridge of bridges) {
+            bridgeRegistry.set(bridge.name, bridge);
+          }
+        } catch (err) {
+          console.error(`[iframe-bridge] Error processing ${filePath}:`, err);
+        }
+      });
+      const scanDirectory = (dir) => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+              scanDirectory(fullPath);
+            }
+          } else if (entry.isFile()) {
+            if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".vue")) {
+              try {
+                const code = fs.readFileSync(fullPath, "utf-8");
+                const bridges = processFile(fullPath, code, options);
+                for (const bridge of bridges) {
+                  bridgeRegistry.set(bridge.name, bridge);
+                }
+              } catch (err) {
+              }
+            }
+          }
+        }
+      };
+      const srcDir = path.resolve(process.cwd(), "src");
+      if (fs.existsSync(srcDir)) {
+        console.log("[iframe-bridge] Scanning for bridge definitions...");
+        scanDirectory(srcDir);
+        console.log(`[iframe-bridge] Found ${bridgeRegistry.size} bridge(s)`);
+      }
+    },
+    buildStart() {
+      bridgeRegistry.clear();
+    },
+    transform(code, id) {
+      const bridges = processFile(id, code, options);
+      for (const bridge of bridges) {
+        bridgeRegistry.set(bridge.name, bridge);
+      }
+      return null;
+    }
+  };
+}