@electron-ipc-bridge/vite-plugin 0.0.4

package/dist/index.js

@@ -0,0 +1,1158 @@
+// src/plugin.ts
+import path5 from "path";
+import { createLogger } from "vite";
+
+// package.json
+var package_default = {
+  name: "@electron-ipc-bridge/vite-plugin",
+  version: "0.0.4",
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/metacurb/electron-ipc-bridge.git"
+  },
+  bugs: {
+    url: "https://github.com/metacurb/electron-ipc-bridge/issues"
+  },
+  homepage: "https://metacurb.github.io/electron-ipc-bridge/",
+  description: "A Vite plugin for Electron-IPC-Bridge",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "node scripts/build.mjs",
+    test: "pnpm exec jest --config jest.config.cjs"
+  },
+  peerDependencies: {
+    typescript: "^5.0.0",
+    vite: "^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  devDependencies: {
+    "@electron-ipc-bridge/shared": "workspace:*",
+    "@types/node": "^25.2.3",
+    esbuild: "^0.27.3",
+    typescript: "^5.9.3",
+    vite: "^7.3.1"
+  }
+};
+
+// src/constants.ts
+var DEFAULT_GLOBAL_TYPES_FILENAME = "ipc.d.ts";
+var DEFAULT_MAIN_ENTRY = "src/main/index.ts";
+var DEFAULT_PRELOAD_ENTRY = "src/preload/index.ts";
+var DEFAULT_RENDERER_RUNTIME_DIR = "src/renderer/src";
+var DEFAULT_RUNTIME_TYPES_FILENAME = "ipc.types.ts";
+
+// src/generate-ipc.ts
+import crypto from "crypto";
+import fs2 from "fs";
+import path4 from "path";
+
+// ../shared/dist/constants.js
+var IPC_DEFAULT_API_ROOT = "ipc";
+var IPC_DECORATOR_ON = "IpcOn";
+var IPC_DECORATOR_ONCE = "IpcOnce";
+var IPC_DECORATOR_HANDLE = "IpcHandle";
+var IPC_DECORATOR_HANDLE_ONCE = "IpcHandleOnce";
+var IPC_METHOD_DECORATOR_NAMES = [
+  IPC_DECORATOR_HANDLE,
+  IPC_DECORATOR_ON,
+  IPC_DECORATOR_HANDLE_ONCE,
+  IPC_DECORATOR_ONCE
+];
+var IPC_PARAM_INJECTION_DECORATOR_NAMES = [
+  "Channel",
+  "CorrelationId",
+  "Origin",
+  "ProcessId",
+  "RawEvent",
+  "Sender",
+  "Window"
+];
+
+// ../shared/dist/utils/to-snake-case.js
+var toSnakeCase = (str) => str.trim().replace(/[\s-]+/g, "_").replace(/(?<=[A-Z])(?=[A-Z][a-z])/g, "_").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLocaleLowerCase();
+
+// ../shared/dist/utils/to-camel-case.js
+var toCamelCase = (str) => toSnakeCase(str).replace(/_([a-z0-9])/g, (_, c) => c.toLocaleUpperCase()).replace(/_/g, "").replace(/^./, (s) => s.toLocaleLowerCase());
+
+// ../shared/dist/utils/derive-namespace.js
+var deriveNamespace = (name) => toCamelCase(name.replace(/Controller$/, ""));
+
+// src/generator/generate-global-types.ts
+var generateGlobalTypes = (namespace = IPC_DEFAULT_API_ROOT, ipcApiImportPath) => {
+  const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(namespace);
+  const windowProperty = isValidIdentifier ? `${namespace}: IpcApi;` : `[${JSON.stringify(namespace)}]: IpcApi;`;
+  return `// Auto-generated by @electron-ipc-bridge/vite-plugin
+// Do not edit manually
+
+import type { IpcApi } from "${ipcApiImportPath}";
+
+declare global {
+  interface Window {
+    ${windowProperty}
+  }
+}
+
+export {};
+`;
+};
+
+// src/generator/get-return-type.ts
+var getReturnType = (decorator, originalReturnType) => {
+  if (decorator === IPC_DECORATOR_ON || decorator === IPC_DECORATOR_ONCE) {
+    return "void";
+  }
+  if (originalReturnType.startsWith("Promise<")) {
+    return originalReturnType;
+  }
+  return `Promise<${originalReturnType}>`;
+};
+
+// src/generator/build-namespaces.ts
+var buildNamespaces = (controllers) => {
+  return controllers.map((controller) => {
+    const methods = controller.methods.map((method) => {
+      const params = method.params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ");
+      const returnType = getReturnType(method.decoratorName, method.returnType);
+      return `${method.name}(${params}): ${returnType};`;
+    });
+    return `    ${controller.namespace}: {
+      ${methods.join("\n      ")}
+    };`;
+  });
+};
+
+// src/generator/build-type-definitions.ts
+var buildTypeDefinitions = (controllers) => {
+  const referencedTypes = /* @__PURE__ */ new Map();
+  const collectTypes = (types) => {
+    types.forEach((t) => {
+      if (t.definition && !referencedTypes.has(t.name)) {
+        referencedTypes.set(t.name, t.definition);
+        collectTypes(t.referencedTypes);
+      }
+    });
+  };
+  controllers.forEach((c) => collectTypes(c.referencedTypes));
+  return Array.from(referencedTypes.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, def]) => `export ${def}`).join("\n\n");
+};
+
+// src/generator/generate-runtime-types.ts
+var generateRuntimeTypes = (controllers) => {
+  const referenceTypes = Array.from(new Set(controllers.flatMap((c) => c.requiredReferenceTypes ?? []))).sort();
+  const referenceDirectives = referenceTypes.map((refType) => `/// <reference types="${refType}" />`).join("\n");
+  const typeDefinitions = buildTypeDefinitions(controllers);
+  const namespaces = buildNamespaces(controllers);
+  const sections = ["// Auto-generated by @electron-ipc-bridge/vite-plugin", "// Do not edit manually", ""];
+  if (referenceDirectives) {
+    sections.push(referenceDirectives, "");
+  }
+  if (typeDefinitions) {
+    sections.push(typeDefinitions, "");
+  }
+  return `${sections.join("\n")}
+export interface IpcApi {
+${namespaces.join("\n")}
+}
+`;
+};
+
+// src/normalize-path.ts
+var normalizePath = (p) => p.replace(/\\/g, "/");
+
+// src/parser/find-controllers.ts
+import path2 from "path";
+import {
+  createProgram,
+  findConfigFile,
+  forEachChild as forEachChild4,
+  isCallExpression as isCallExpression8,
+  isIdentifier as isIdentifier9,
+  parseJsonConfigFileContent,
+  readConfigFile,
+  sys
+} from "typescript";
+
+// src/strategies/nest.ts
+import {
+  forEachChild as forEachChild3,
+  isCallExpression as isCallExpression6,
+  isClassDeclaration as isClassDeclaration4,
+  isIdentifier as isIdentifier5,
+  isPropertyAccessExpression
+} from "typescript";
+
+// src/parser/resolve-controllers-from-nest-root.ts
+import path from "path";
+import {
+  getDecorators as getDecorators3,
+  isArrayLiteralExpression as isArrayLiteralExpression2,
+  isArrowFunction,
+  isBlock,
+  isCallExpression as isCallExpression5,
+  isClassDeclaration as isClassDeclaration3,
+  isIdentifier as isIdentifier4,
+  isObjectLiteralExpression as isObjectLiteralExpression2,
+  isPropertyAssignment as isPropertyAssignment2,
+  isReturnStatement
+} from "typescript";
+
+// src/parser/resolve-controllers-from-module-class.ts
+import {
+  getDecorators as getDecorators2,
+  isArrayLiteralExpression,
+  isCallExpression as isCallExpression4,
+  isIdentifier as isIdentifier3,
+  isObjectLiteralExpression,
+  isPropertyAssignment
+} from "typescript";
+
+// src/parser/resolve-controller.ts
+import { isClassDeclaration as isClassDeclaration2 } from "typescript";
+
+// src/parser/collect-dependencies.ts
+var collectDependencies = (referencedTypes, processedFiles) => {
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (types) => {
+    for (const type of types) {
+      if (visited.has(type)) {
+        continue;
+      }
+      visited.add(type);
+      if (type.sourceFile) {
+        processedFiles.add(type.sourceFile);
+      }
+      visit(type.referencedTypes);
+    }
+  };
+  visit(referencedTypes);
+};
+
+// src/parser/extract-metadata.ts
+import { forEachChild as forEachChild2, isClassDeclaration } from "typescript";
+
+// src/parser/get-decorator.ts
+import { canHaveDecorators, getDecorators, isCallExpression, isIdentifier } from "typescript";
+var getDecorator = (node, name) => {
+  if (!canHaveDecorators(node)) return void 0;
+  const decorators = getDecorators(node);
+  if (!decorators) return void 0;
+  return decorators.find(
+    (m) => isCallExpression(m.expression) && isIdentifier(m.expression.expression) && m.expression.expression.text === name
+  );
+};
+
+// src/parser/parse-controller.ts
+import {
+  isCallExpression as isCallExpression3,
+  isIdentifier as isIdentifier2,
+  isMethodDeclaration,
+  isStringLiteral as isStringLiteral2
+} from "typescript";
+
+// src/parser/parse-method.ts
+import { isCallExpression as isCallExpression2, isStringLiteral } from "typescript";
+
+// src/parser/collect-external-type-references.ts
+import {
+  isEnumDeclaration,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration
+} from "typescript";
+var NODE_TYPES_PATH_RE = /[\\/]@types[\\/]node[\\/]/i;
+var pickDeclaration = (symbol) => symbol?.getDeclarations()?.find((d) => isTypeAliasDeclaration(d) || isInterfaceDeclaration(d) || isEnumDeclaration(d));
+var resolveDeclarationFromSymbol = (symbol, typeChecker) => {
+  let decl = pickDeclaration(symbol);
+  if (!decl && symbol) {
+    try {
+      const aliased = typeChecker.getAliasedSymbol(symbol);
+      const aliasedDecl = pickDeclaration(aliased);
+      if (aliasedDecl) {
+        decl = aliasedDecl;
+      }
+    } catch {
+    }
+  }
+  return decl;
+};
+var addReferenceTypeIfExternal = (symbol, typeChecker, out) => {
+  const decl = resolveDeclarationFromSymbol(symbol, typeChecker);
+  if (!decl) return;
+  const sourceFile = decl.getSourceFile();
+  if (NODE_TYPES_PATH_RE.test(sourceFile.fileName)) {
+    out.add("node");
+  }
+};
+var walkTypeForExternalRefs = (type, typeChecker, seen, out) => {
+  if (seen.has(type)) return;
+  seen.add(type);
+  addReferenceTypeIfExternal(type.getSymbol(), typeChecker, out);
+  const typeWithAlias = type;
+  addReferenceTypeIfExternal(typeWithAlias.aliasSymbol, typeChecker, out);
+  const typeWithNested = type;
+  typeWithNested.aliasTypeArguments?.forEach((arg) => walkTypeForExternalRefs(arg, typeChecker, seen, out));
+  typeWithNested.typeArguments?.forEach((arg) => walkTypeForExternalRefs(arg, typeChecker, seen, out));
+  typeWithNested.types?.forEach((nested) => walkTypeForExternalRefs(nested, typeChecker, seen, out));
+};
+var collectExternalTypeReferencesFromType = (type, typeChecker, out = /* @__PURE__ */ new Set()) => {
+  walkTypeForExternalRefs(type, typeChecker, /* @__PURE__ */ new Set(), out);
+  return out;
+};
+
+// src/parser/extract-type.ts
+import {
+  createPrinter,
+  EmitHint,
+  forEachChild,
+  isEnumDeclaration as isEnumDeclaration2,
+  isInterfaceDeclaration as isInterfaceDeclaration2,
+  isTypeAliasDeclaration as isTypeAliasDeclaration2,
+  isTypeReferenceNode
+} from "typescript";
+
+// src/parser/constants.ts
+var BUILTIN_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Promise",
+  "Array",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Function",
+  "Symbol",
+  "Error",
+  "Record",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "Parameters",
+  "InstanceType",
+  "ConstructorParameters",
+  "__type",
+  "undefined"
+]);
+
+// src/parser/extract-type.ts
+var printer = createPrinter({ removeComments: true });
+var collectTypeDefinitions = (node, typeChecker, seen = /* @__PURE__ */ new Set()) => {
+  const result = [];
+  walkForTypeRefs(node, typeChecker, seen, result);
+  return result;
+};
+var collectTypeDefinitionsFromType = (type, typeChecker, seen = /* @__PURE__ */ new Set()) => {
+  const result = [];
+  walkTypeForTypeRefs(type, typeChecker, seen, result);
+  return result;
+};
+var pickDeclaration2 = (symbol) => symbol?.getDeclarations()?.find((d) => isTypeAliasDeclaration2(d) || isInterfaceDeclaration2(d) || isEnumDeclaration2(d));
+var resolveDeclarationFromSymbol2 = (symbol, typeChecker) => {
+  let decl = pickDeclaration2(symbol);
+  if (!decl && symbol) {
+    try {
+      const aliased = typeChecker.getAliasedSymbol(symbol);
+      const aliasedDecl = pickDeclaration2(aliased);
+      if (aliasedDecl) {
+        decl = aliasedDecl;
+      }
+    } catch {
+    }
+  }
+  return decl;
+};
+var addDefinitionFromDeclaration = (decl, typeChecker, seen, out) => {
+  if (!decl || !(isTypeAliasDeclaration2(decl) || isInterfaceDeclaration2(decl) || isEnumDeclaration2(decl))) {
+    return;
+  }
+  const name = decl.name.text;
+  if (BUILTIN_TYPE_NAMES.has(name) || seen.has(name)) {
+    return;
+  }
+  seen.add(name);
+  const sourceFile = decl.getSourceFile();
+  if (sourceFile.fileName.includes("node_modules")) {
+    return;
+  }
+  const referencedTypes = [];
+  walkForTypeRefs(decl, typeChecker, seen, referencedTypes);
+  const definition = printer.printNode(EmitHint.Unspecified, decl, sourceFile).replace(/^\s*export\s+/, "").replace(/^\s*declare\s+/, "").trim();
+  if (definition) {
+    out.push({ definition, name, referencedTypes, sourceFile: sourceFile.fileName });
+  }
+};
+var walkForTypeRefs = (node, typeChecker, seen, out) => {
+  if (isTypeReferenceNode(node)) {
+    const sym = typeChecker.getSymbolAtLocation(node.typeName);
+    addDefinitionFromDeclaration(resolveDeclarationFromSymbol2(sym, typeChecker), typeChecker, seen, out);
+    if (node.typeArguments) {
+      node.typeArguments.forEach((arg) => walkForTypeRefs(arg, typeChecker, seen, out));
+    }
+    return;
+  }
+  forEachChild(node, (child) => walkForTypeRefs(child, typeChecker, seen, out));
+};
+var walkTypeForTypeRefs = (type, typeChecker, seen, out) => {
+  addDefinitionFromDeclaration(resolveDeclarationFromSymbol2(type.getSymbol(), typeChecker), typeChecker, seen, out);
+  const typeWithAlias = type;
+  addDefinitionFromDeclaration(
+    resolveDeclarationFromSymbol2(typeWithAlias.aliasSymbol, typeChecker),
+    typeChecker,
+    seen,
+    out
+  );
+  const typeWithNested = type;
+  typeWithNested.aliasTypeArguments?.forEach((arg) => walkTypeForTypeRefs(arg, typeChecker, seen, out));
+  typeWithNested.typeArguments?.forEach((arg) => walkTypeForTypeRefs(arg, typeChecker, seen, out));
+  typeWithNested.types?.forEach((nested) => walkTypeForTypeRefs(nested, typeChecker, seen, out));
+};
+
+// src/parser/resolve-return-type.ts
+import { createPrinter as createPrinter2, EmitHint as EmitHint2, TypeFormatFlags } from "typescript";
+
+// src/parser/is-truncated-type-string.ts
+var isTruncatedTypeString = (s) => /\.\.\.\s+\d+\s+more\s+\.\.\./.test(s);
+
+// src/parser/resolve-return-type.ts
+var printer2 = createPrinter2();
+var resolveReturnType = (node, signature, typeChecker) => {
+  if (node.type) {
+    return printer2.printNode(EmitHint2.Unspecified, node.type, node.getSourceFile()).trim();
+  }
+  const inferred = signature != null ? typeChecker.typeToString(
+    signature.getReturnType(),
+    void 0,
+    TypeFormatFlags.NoTruncation | TypeFormatFlags.UseFullyQualifiedType
+  ) : "unknown";
+  if (isTruncatedTypeString(inferred)) return "unknown";
+  return inferred.replace(/import\("(?:\.|\/|[a-zA-Z]:).*?"\)\./g, "");
+};
+
+// src/parser/parse-method.ts
+var parseMethod = (node, typeChecker) => {
+  let found = null;
+  let decorator = null;
+  for (const d of IPC_METHOD_DECORATOR_NAMES) {
+    const dec = getDecorator(node, d);
+    if (dec) {
+      found = d;
+      decorator = dec;
+      break;
+    }
+  }
+  if (!found || !decorator) return null;
+  let name = node.name.text;
+  if (isCallExpression2(decorator.expression)) {
+    const args = decorator.expression.arguments;
+    if (args.length > 0 && isStringLiteral(args[0])) {
+      name = args[0].text;
+    }
+  }
+  const signature = typeChecker.getSignatureFromDeclaration(node);
+  const returnType = resolveReturnType(node, signature ?? void 0, typeChecker);
+  const referencedTypes = [];
+  const requiredReferenceTypes = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const paramInfos = node.parameters.map((param) => {
+    const hasInjection = IPC_PARAM_INJECTION_DECORATOR_NAMES.some((d) => getDecorator(param, d));
+    return { hasInjection, param };
+  });
+  const params = [];
+  for (const { hasInjection, param } of paramInfos) {
+    const type = typeChecker.getTypeAtLocation(param);
+    const typeString = typeChecker.typeToString(type);
+    const extracted = !hasInjection && param.type ? collectTypeDefinitions(param.type, typeChecker, seen) : [];
+    if (!hasInjection) {
+      collectExternalTypeReferencesFromType(type, typeChecker, requiredReferenceTypes);
+    }
+    referencedTypes.push(...extracted);
+    params.push({
+      name: param.name.getText(),
+      optional: !!param.questionToken || !!param.initializer,
+      type: typeString
+    });
+  }
+  const filteredParams = params.filter((_, index) => !paramInfos[index].hasInjection);
+  if (node.type) {
+    const returnTypeRefs = collectTypeDefinitions(node.type, typeChecker, seen);
+    referencedTypes.push(...returnTypeRefs);
+  } else if (signature) {
+    const returnTypeRefs = collectTypeDefinitionsFromType(signature.getReturnType(), typeChecker, seen);
+    referencedTypes.push(...returnTypeRefs);
+  }
+  if (signature && found !== IPC_DECORATOR_ON && found !== IPC_DECORATOR_ONCE) {
+    collectExternalTypeReferencesFromType(signature.getReturnType(), typeChecker, requiredReferenceTypes);
+  }
+  return {
+    decoratorName: found,
+    name,
+    params: filteredParams,
+    referencedTypes,
+    requiredReferenceTypes: Array.from(requiredReferenceTypes).sort(),
+    returnType
+  };
+};
+
+// src/parser/parse-controller.ts
+var parseController = (node, decorator, sourceFile, typeChecker) => {
+  const className = node.name.text;
+  let namespace = deriveNamespace(className);
+  if (isCallExpression3(decorator.expression)) {
+    const args = decorator.expression.arguments;
+    if (args.length > 0 && isStringLiteral2(args[0])) {
+      namespace = args[0].text;
+    }
+  }
+  const methods = [];
+  node.members.forEach((member) => {
+    if (isMethodDeclaration(member) && member.name && isIdentifier2(member.name)) {
+      const methodMeta = parseMethod(member, typeChecker);
+      if (methodMeta) {
+        methods.push(methodMeta);
+      }
+    }
+  });
+  const referencedTypes = methods.flatMap((m) => m.referencedTypes);
+  const requiredReferenceTypes = Array.from(new Set(methods.flatMap((m) => m.requiredReferenceTypes ?? []))).sort();
+  return {
+    className,
+    filePath: sourceFile.fileName,
+    methods,
+    namespace,
+    referencedTypes,
+    requiredReferenceTypes
+  };
+};
+
+// src/parser/extract-metadata.ts
+var extractControllerMetadata = (sourceFile, typeChecker) => {
+  const controllers = [];
+  forEachChild2(sourceFile, (node) => {
+    if (isClassDeclaration(node)) {
+      const decorator = getDecorator(node, "IpcController");
+      if (decorator) {
+        const controller = parseController(node, decorator, sourceFile, typeChecker);
+        if (controller) {
+          controllers.push(controller);
+        }
+      }
+    }
+  });
+  return controllers;
+};
+
+// src/parser/resolve-controller.ts
+var resolveController = (node, typeChecker, processedFiles, controllers, fileCache) => {
+  const symbol = typeChecker.getSymbolAtLocation(node);
+  if (!symbol) return;
+  let targetSymbol = symbol;
+  try {
+    const aliasedSymbol = typeChecker.getAliasedSymbol(symbol);
+    targetSymbol = aliasedSymbol || symbol;
+  } catch {
+  }
+  if (!targetSymbol.declarations || targetSymbol.declarations.length === 0) return;
+  const targetDecl = targetSymbol.declarations[0];
+  if (!isClassDeclaration2(targetDecl)) return;
+  const sourceFile = targetDecl.getSourceFile();
+  const fileName = sourceFile.fileName;
+  const className = targetDecl.name?.text;
+  if (!className) return;
+  let fileControllers = fileCache.get(fileName);
+  if (fileControllers === void 0) {
+    fileControllers = extractControllerMetadata(sourceFile, typeChecker);
+    fileCache.set(fileName, fileControllers);
+    processedFiles.add(fileName);
+  }
+  const match = fileControllers.find((c) => c.className === className);
+  if (match) {
+    controllers.push(match);
+    collectDependencies(match.referencedTypes, processedFiles);
+  }
+};
+
+// src/parser/resolve-controllers-from-module-class.ts
+var resolveControllersFromModuleClass = (targetDecl, typeChecker, processedFiles, controllers, fileCache) => {
+  const decorators = getDecorators2(targetDecl);
+  if (!decorators) return;
+  for (const decorator of decorators) {
+    if (!isCallExpression4(decorator.expression)) continue;
+    const moduleArgs = decorator.expression.arguments;
+    const moduleOptions = moduleArgs[0];
+    if (!moduleOptions || !isObjectLiteralExpression(moduleOptions)) continue;
+    const properties = moduleOptions.properties;
+    for (const prop of properties) {
+      if (!isPropertyAssignment(prop) || !isIdentifier3(prop.name)) continue;
+      if (prop.name.text === "providers" || prop.name.text === "controllers") {
+        if (!isArrayLiteralExpression(prop.initializer)) continue;
+        const providerElements = prop.initializer.elements;
+        providerElements.forEach((element) => {
+          resolveController(element, typeChecker, processedFiles, controllers, fileCache);
+        });
+      }
+    }
+  }
+};
+
+// src/parser/resolve-controllers-from-nest-root.ts
+var normalizePathSafe = (p) => path.normalize(p).replace(/\\/g, "/");
+function resolveImportElementToClass(element, typeChecker) {
+  if (isIdentifier4(element)) {
+    const symbol = typeChecker.getSymbolAtLocation(element);
+    if (!symbol) return void 0;
+    let target = symbol;
+    try {
+      const aliased = typeChecker.getAliasedSymbol(symbol);
+      if (aliased) target = aliased;
+    } catch {
+    }
+    const decl = target.declarations?.[0];
+    return decl && isClassDeclaration3(decl) ? decl : void 0;
+  }
+  if (isCallExpression5(element)) {
+    const firstArg = element.arguments[0];
+    if (!firstArg) return void 0;
+    if (isArrowFunction(firstArg)) {
+      const body = firstArg.body;
+      if (isIdentifier4(body)) return resolveImportElementToClass(body, typeChecker);
+      if (isBlock(body)) {
+        const ret = body.statements.find((s) => isReturnStatement(s));
+        if (ret && isReturnStatement(ret) && ret.expression)
+          return resolveImportElementToClass(ret.expression, typeChecker);
+      }
+    }
+  }
+  return void 0;
+}
+var resolveControllersFromNestRoot = (targetDecl, typeChecker, processedFiles, controllers, fileCache, visitedModules) => {
+  const sourceFile = targetDecl.getSourceFile();
+  const filePath = normalizePathSafe(sourceFile.fileName);
+  if (visitedModules.has(filePath)) return;
+  visitedModules.add(filePath);
+  resolveControllersFromModuleClass(targetDecl, typeChecker, processedFiles, controllers, fileCache);
+  const decorators = getDecorators3(targetDecl);
+  if (!decorators) return;
+  for (const decorator of decorators) {
+    if (!isCallExpression5(decorator.expression)) continue;
+    const moduleArgs = decorator.expression.arguments;
+    const moduleOptions = moduleArgs[0];
+    if (!moduleOptions || !isObjectLiteralExpression2(moduleOptions)) continue;
+    const importsProp = moduleOptions.properties.find(
+      (p) => isPropertyAssignment2(p) && isIdentifier4(p.name) && p.name.text === "imports"
+    );
+    if (!importsProp || !isArrayLiteralExpression2(importsProp.initializer)) continue;
+    for (const element of importsProp.initializer.elements) {
+      const importClass = resolveImportElementToClass(element, typeChecker);
+      if (importClass) {
+        resolveControllersFromNestRoot(
+          importClass,
+          typeChecker,
+          processedFiles,
+          controllers,
+          fileCache,
+          visitedModules
+        );
+      }
+    }
+    break;
+  }
+};
+
+// src/strategies/nest.ts
+var findNestRootModule = (sourceFile, typeChecker) => {
+  let found;
+  const visit = (node) => {
+    if (found) return;
+    if (!isCallExpression6(node)) {
+      forEachChild3(node, visit);
+      return;
+    }
+    const expr = node.expression;
+    if (!isPropertyAccessExpression(expr) || expr.name.text !== "createApplicationContext") {
+      forEachChild3(node, visit);
+      return;
+    }
+    const firstArg = node.arguments[0];
+    if (!firstArg || !isIdentifier5(firstArg)) {
+      forEachChild3(node, visit);
+      return;
+    }
+    const symbol = typeChecker.getSymbolAtLocation(firstArg);
+    if (!symbol) {
+      forEachChild3(node, visit);
+      return;
+    }
+    let targetSymbol = symbol;
+    try {
+      const aliased = typeChecker.getAliasedSymbol(symbol);
+      if (aliased) targetSymbol = aliased;
+    } catch {
+    }
+    const decl = targetSymbol.declarations?.[0];
+    if (decl && isClassDeclaration4(decl)) {
+      found = decl;
+      return;
+    }
+    forEachChild3(node, visit);
+  };
+  forEachChild3(sourceFile, visit);
+  return found;
+};
+var nestResolutionStrategy = (context) => {
+  const { fileCache, processedFiles, sourceFile, typeChecker } = context;
+  const rootModule = findNestRootModule(sourceFile, typeChecker);
+  if (!rootModule) return [];
+  const controllers = [];
+  const visitedModules = /* @__PURE__ */ new Set();
+  resolveControllersFromNestRoot(rootModule, typeChecker, processedFiles, controllers, fileCache, visitedModules);
+  return controllers;
+};
+
+// src/parser/process-create-ipc-app-call.ts
+import {
+  isArrayLiteralExpression as isArrayLiteralExpression3,
+  isCallExpression as isCallExpression7,
+  isClassDeclaration as isClassDeclaration6,
+  isIdentifier as isIdentifier8,
+  isObjectLiteralExpression as isObjectLiteralExpression3,
+  isPropertyAssignment as isPropertyAssignment3
+} from "typescript";
+
+// src/parser/ast-utils.ts
+import {
+  isAsExpression,
+  isAwaitExpression,
+  isIdentifier as isIdentifier6,
+  isNonNullExpression,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  isTypeAssertionExpression,
+  isVariableDeclaration
+} from "typescript";
+var unwrapExpression = (expr) => {
+  let current = expr;
+  while (true) {
+    if (isAwaitExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isParenthesizedExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isAsExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isTypeAssertionExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isSatisfiesExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return current;
+  }
+};
+var resolveExpression = (expr, typeChecker) => {
+  let current = unwrapExpression(expr);
+  const visited = /* @__PURE__ */ new Set();
+  while (isIdentifier6(current)) {
+    if (visited.has(current)) break;
+    visited.add(current);
+    const symbol = typeChecker.getSymbolAtLocation(current);
+    if (!symbol) break;
+    let targetSymbol = symbol;
+    try {
+      const aliasedSymbol = typeChecker.getAliasedSymbol(symbol);
+      targetSymbol = aliasedSymbol || symbol;
+    } catch {
+    }
+    const decl = targetSymbol.declarations?.[0];
+    if (decl && isVariableDeclaration(decl) && decl.initializer) {
+      current = unwrapExpression(decl.initializer);
+    } else {
+      break;
+    }
+  }
+  return current;
+};
+
+// src/parser/resolve-controllers-from-array.ts
+var resolveControllersFromArray = (initializer, typeChecker, processedFiles, controllers, fileCache) => {
+  initializer.elements.forEach((element) => {
+    resolveController(element, typeChecker, processedFiles, controllers, fileCache);
+  });
+};
+
+// src/parser/resolve-controllers-from-module.ts
+import { isClassDeclaration as isClassDeclaration5, isIdentifier as isIdentifier7 } from "typescript";
+var resolveControllersFromModule = (callExpr, typeChecker, processedFiles, controllers, fileCache) => {
+  const moduleArg = callExpr.arguments[0];
+  if (moduleArg && isIdentifier7(moduleArg)) {
+    const moduleSymbol = typeChecker.getSymbolAtLocation(moduleArg);
+    if (!moduleSymbol) return;
+    let targetSymbol = moduleSymbol;
+    try {
+      const aliasedSymbol = typeChecker.getAliasedSymbol(moduleSymbol);
+      targetSymbol = aliasedSymbol || moduleSymbol;
+    } catch {
+    }
+    const targetDecl = targetSymbol.declarations?.[0];
+    if (!targetDecl || !isClassDeclaration5(targetDecl)) return;
+    resolveControllersFromModuleClass(targetDecl, typeChecker, processedFiles, controllers, fileCache);
+  }
+};
+
+// src/parser/process-create-ipc-app-call.ts
+var processCreateIpcAppCall = (node, typeChecker, processedFiles, controllers, fileCache, resolutionStrategy) => {
+  const args = node.arguments;
+  if (args.length === 0) return;
+  const optionsObj = resolveExpression(args[0], typeChecker);
+  if (!isObjectLiteralExpression3(optionsObj)) return;
+  const controllersProp = optionsObj.properties.find(
+    (p) => isPropertyAssignment3(p) && isIdentifier8(p.name) && p.name.text === "controllers"
+  );
+  if (!controllersProp) return;
+  const initializer = resolveExpression(controllersProp.initializer, typeChecker);
+  if (isArrayLiteralExpression3(initializer)) {
+    resolveControllersFromArray(initializer, typeChecker, processedFiles, controllers, fileCache);
+    return;
+  }
+  if (isCallExpression7(initializer)) {
+    resolveControllersFromModule(initializer, typeChecker, processedFiles, controllers, fileCache);
+    for (const arg of initializer.arguments) {
+      const resolvedArg = resolveExpression(arg, typeChecker);
+      if (isCallExpression7(resolvedArg)) {
+        for (const factoryArg of resolvedArg.arguments) {
+          const resolvedFactoryArg = resolveExpression(factoryArg, typeChecker);
+          if (!isIdentifier8(resolvedFactoryArg)) continue;
+          const factorySymbol = typeChecker.getSymbolAtLocation(resolvedFactoryArg);
+          if (!factorySymbol) continue;
+          let targetSymbol = factorySymbol;
+          try {
+            const aliased = typeChecker.getAliasedSymbol(factorySymbol);
+            targetSymbol = aliased || factorySymbol;
+          } catch {
+          }
+          const targetDecl = targetSymbol.declarations?.[0];
+          if (targetDecl && isClassDeclaration6(targetDecl)) {
+            resolveControllersFromModuleClass(targetDecl, typeChecker, processedFiles, controllers, fileCache);
+          }
+        }
+      }
+    }
+    if (controllers.length === 0 && resolutionStrategy) {
+      const context = {
+        fileCache,
+        processedFiles,
+        sourceFile: node.getSourceFile(),
+        typeChecker
+      };
+      const resolved = resolutionStrategy(context);
+      controllers.push(...resolved);
+    }
+  }
+};
+
+// src/parser/find-controllers.ts
+function resolveStrategy(option) {
+  if (option === "nest") return nestResolutionStrategy;
+  return void 0;
+}
+var isCreateIpcAppCall = (node, typeChecker) => {
+  if (!isIdentifier9(node.expression)) return false;
+  const sym = typeChecker.getSymbolAtLocation(node.expression);
+  if (!sym) return false;
+  let target = sym;
+  try {
+    const aliased = typeChecker.getAliasedSymbol(sym);
+    if (aliased) target = aliased;
+  } catch {
+  }
+  return target.name === "createIpcApp";
+};
+var findControllers = (entryFile, tsConfigPath, oldProgram, resolutionStrategy) => {
+  const strategy = resolveStrategy(resolutionStrategy);
+  const searchConfig = tsConfigPath || "tsconfig.node.json";
+  let configFile = findConfigFile(path2.dirname(entryFile), sys.fileExists, searchConfig);
+  if (!configFile && !tsConfigPath) {
+    configFile = findConfigFile(path2.dirname(entryFile), sys.fileExists, "tsconfig.json");
+  }
+  let compilerOptions = {};
+  if (configFile) {
+    const { config } = readConfigFile(configFile, sys.readFile);
+    const { options } = parseJsonConfigFileContent(config, sys, path2.dirname(configFile));
+    compilerOptions = options;
+  }
+  const program = createProgram([entryFile], compilerOptions, void 0, oldProgram);
+  const typeChecker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(entryFile);
+  if (!sourceFile) {
+    return { controllers: [], processedFiles: /* @__PURE__ */ new Set(), program };
+  }
+  const controllers = [];
+  const processedFiles = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
+  processedFiles.add(path2.resolve(entryFile));
+  forEachChild4(sourceFile, function visit(node) {
+    if (isCallExpression8(node) && isCreateIpcAppCall(node, typeChecker)) {
+      processCreateIpcAppCall(node, typeChecker, processedFiles, controllers, fileCache, strategy);
+    }
+    forEachChild4(node, visit);
+  });
+  return { controllers, processedFiles, program };
+};
+
+// src/preload/resolve-api-root.ts
+import fs from "fs";
+import {
+  createSourceFile,
+  forEachChild as forEachChild5,
+  isCallExpression as isCallExpression9,
+  isIdentifier as isIdentifier10,
+  isObjectLiteralExpression as isObjectLiteralExpression4,
+  isPropertyAssignment as isPropertyAssignment4,
+  isStringLiteral as isStringLiteral3,
+  ScriptTarget
+} from "typescript";
+var resolveApiRootFromPreload = (preloadPath) => {
+  const dependencies = /* @__PURE__ */ new Set();
+  dependencies.add(preloadPath);
+  let namespace = IPC_DEFAULT_API_ROOT;
+  if (!fs.existsSync(preloadPath)) {
+    return { dependencies, namespace };
+  }
+  const content = fs.readFileSync(preloadPath, "utf-8");
+  const sourceFile = createSourceFile(preloadPath, content, ScriptTarget.Latest, true);
+  const visit = (node) => {
+    if (isCallExpression9(node) && isIdentifier10(node.expression) && node.expression.text === "setupPreload") {
+      const args = node.arguments;
+      if (args.length > 0) {
+        const first = args[0];
+        if (isStringLiteral3(first)) {
+          namespace = first.text;
+        } else if (isObjectLiteralExpression4(first)) {
+          const namespaceProp = first.properties.find(
+            (p) => isPropertyAssignment4(p) && isIdentifier10(p.name) && p.name.text === "namespace"
+          );
+          if (namespaceProp && isPropertyAssignment4(namespaceProp) && isStringLiteral3(namespaceProp.initializer)) {
+            namespace = namespaceProp.initializer.text;
+          }
+        }
+      }
+    }
+    forEachChild5(node, visit);
+  };
+  forEachChild5(sourceFile, visit);
+  return { dependencies, namespace };
+};
+
+// src/resolve-type-paths.ts
+import path3 from "path";
+var resolveTypePaths = ({
+  hasRendererRuntimeDir,
+  preloadPath,
+  root,
+  types
+}) => {
+  const runtimePath = types.runtime === false ? null : types.runtime ? path3.resolve(root, types.runtime) : (() => {
+    const rendererSrc = path3.resolve(root, DEFAULT_RENDERER_RUNTIME_DIR);
+    if (hasRendererRuntimeDir(rendererSrc)) {
+      return path3.join(rendererSrc, DEFAULT_RUNTIME_TYPES_FILENAME);
+    }
+    return path3.resolve(root, path3.join("src", DEFAULT_RUNTIME_TYPES_FILENAME));
+  })();
+  const globalPath = types.global === false ? null : types.global ? path3.resolve(root, types.global) : path3.join(path3.dirname(preloadPath), DEFAULT_GLOBAL_TYPES_FILENAME);
+  return { globalPath, runtimePath };
+};
+
+// src/generate-ipc.ts
+function generateIpc(root, logger, state, options) {
+  try {
+    const { main, preload, resolutionStrategy, types } = options;
+    const preloadPath = path4.resolve(root, preload);
+    const { dependencies: preloadDependencies, namespace: resolvedApiRoot } = resolveApiRootFromPreload(preloadPath);
+    const entryPath = path4.resolve(root, main);
+    if (!fs2.existsSync(entryPath)) {
+      logger.warn(`Main entry not found at: ${entryPath}`);
+      return;
+    }
+    logger.info(`Generating IPC types from ${entryPath}...`);
+    const { controllers, processedFiles, program } = findControllers(
+      entryPath,
+      void 0,
+      state.getProgram(),
+      resolutionStrategy
+    );
+    state.setProgram(program);
+    if (controllers.length === 0) {
+      logger.warn(`No createIpcApp() call found in ${entryPath}; generated types will be empty.`);
+    }
+    state.setControllerFiles(new Set([...processedFiles, ...preloadDependencies].map(normalizePath)));
+    const { globalPath, runtimePath } = resolveTypePaths({
+      hasRendererRuntimeDir: (absPath) => fs2.existsSync(absPath),
+      preloadPath,
+      root,
+      types
+    });
+    if (!runtimePath && !globalPath) {
+      logger.warn(`Both runtime and global type outputs are disabled; nothing to generate.`);
+      return;
+    }
+    let runtimeTypesContent = null;
+    let globalTypesContent = null;
+    if (runtimePath) {
+      runtimeTypesContent = generateRuntimeTypes(controllers);
+    }
+    if (globalPath) {
+      const ipcApiImportPath = (() => {
+        if (!runtimePath) {
+          throw new Error("Global type generation requires a runtime types output path.");
+        }
+        const rel = path4.relative(path4.dirname(globalPath), runtimePath).replace(/\\/g, "/").replace(/\.tsx?$/, ".ts").replace(/(\.d)?\.ts$/, "");
+        return rel.startsWith(".") ? rel : `./${rel}`;
+      })();
+      globalTypesContent = generateGlobalTypes(resolvedApiRoot, ipcApiImportPath);
+    }
+    const combinedHash = crypto.createHash("md5").update(runtimeTypesContent ?? "").update(globalTypesContent ?? "").digest("hex");
+    if (!state.updateHash(combinedHash)) return;
+    if (runtimePath && runtimeTypesContent != null) {
+      fs2.mkdirSync(path4.dirname(runtimePath), { recursive: true });
+      fs2.writeFileSync(runtimePath, runtimeTypesContent);
+      logger.info(`Runtime types generated at ${path4.relative(root, runtimePath)}`);
+    }
+    if (globalPath && globalTypesContent != null) {
+      fs2.mkdirSync(path4.dirname(globalPath), { recursive: true });
+      fs2.writeFileSync(globalPath, globalTypesContent);
+      logger.info(`Global types generated at ${path4.relative(root, globalPath)}`);
+    }
+  } catch (err) {
+    logger.error(`Type generation failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+// src/plugin-state.ts
+var PluginState = class {
+  constructor(debounceMs = 100) {
+    this.debounceMs = debounceMs;
+    this.controllerFiles = null;
+    this.debounceTimer = null;
+    this.hasGeneratedOnce = false;
+    this.lastHash = null;
+    this.program = null;
+  }
+  claimInitialGeneration() {
+    if (!this.hasGeneratedOnce) {
+      this.hasGeneratedOnce = true;
+      return true;
+    }
+    return false;
+  }
+  getProgram() {
+    return this.program ?? void 0;
+  }
+  scheduleGenerate(callback) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      callback();
+      this.debounceTimer = null;
+    }, this.debounceMs);
+  }
+  setControllerFiles(files) {
+    this.controllerFiles = files;
+  }
+  setProgram(program) {
+    this.program = program;
+  }
+  shouldRegenerate(absId, mainEntryPath, preloadEntryPath) {
+    const isMainEntry = absId === mainEntryPath;
+    const isPreloadEntry = preloadEntryPath ? absId === preloadEntryPath : false;
+    const isControllerFile = this.controllerFiles?.has(absId);
+    return isMainEntry || isPreloadEntry || !!isControllerFile;
+  }
+  updateHash(hash) {
+    if (hash === this.lastHash) {
+      return false;
+    }
+    this.lastHash = hash;
+    return true;
+  }
+};
+
+// src/plugin.ts
+function electronIpcBridge({
+  main = DEFAULT_MAIN_ENTRY,
+  preload = DEFAULT_PRELOAD_ENTRY,
+  resolutionStrategy,
+  types = {}
+} = {}) {
+  let root = process.cwd();
+  let logger;
+  const state = new PluginState();
+  const generate = () => {
+    generateIpc(root, logger, state, { main, preload, resolutionStrategy, types });
+  };
+  return {
+    buildStart() {
+      if (state.claimInitialGeneration()) {
+        generate();
+      }
+    },
+    configResolved(config) {
+      root = config.root;
+      logger = createLogger(config.logLevel, {
+        allowClearScreen: config.clearScreen,
+        customLogger: config.customLogger,
+        prefix: `[${package_default.name}]`
+      });
+    },
+    configureServer(server) {
+      const preloadPath = path5.resolve(root, preload);
+      server.watcher.add(preloadPath);
+      server.watcher.on("change", (file) => {
+        if (normalizePath(file) === normalizePath(preloadPath)) {
+          state.scheduleGenerate(generate);
+        }
+      });
+    },
+    name: "electron-ipc-bridge",
+    transform(_code, id) {
+      if (id.includes("node_modules") || id.endsWith(".d.ts")) return null;
+      const absId = normalizePath(path5.resolve(id));
+      const mainEntryPath = normalizePath(path5.resolve(root, main));
+      const preloadEntryPath = normalizePath(path5.resolve(root, preload));
+      if (state.shouldRegenerate(absId, mainEntryPath, preloadEntryPath)) {
+        state.scheduleGenerate(generate);
+      }
+      return null;
+    }
+  };
+}
+export {
+  electronIpcBridge
+};
+//# sourceMappingURL=index.js.map