wexts 3.0.2 → 4.0.0

package/dist/chunk-7QKLIVRF.js

@@ -0,0 +1,94 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkXE4OXN2Wjs = require('./chunk-XE4OXN2W.js');
+
+// src/rpc/decorators.ts
+require('reflect-metadata');
+var RPC_SERVICE_KEY = "wexts:rpc:service";
+var RPC_METHODS_KEY = "wexts:rpc:methods";
+function RpcService(nameOrOptions) {
+  const options = normalizeServiceOptions(nameOrOptions);
+  return (target) => {
+    Reflect.defineMetadata(RPC_SERVICE_KEY, options, target);
+    return target;
+  };
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, RpcService, "RpcService");
+function RpcMethod(nameOrOptions) {
+  const options = normalizeMethodOptions(nameOrOptions);
+  return (target, propertyKey) => {
+    const constructor = target.constructor;
+    const methods = Reflect.getMetadata(RPC_METHODS_KEY, constructor) || [];
+    const nextMethods = methods.filter((method) => method.propertyKey !== propertyKey);
+    nextMethods.push({
+      propertyKey,
+      ...options
+    });
+    Reflect.defineMetadata(RPC_METHODS_KEY, nextMethods, constructor);
+  };
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, RpcMethod, "RpcMethod");
+function RequireAuth() {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      RpcMethod({
+        requireAuth: true
+      })(target, propertyKey, Object.getOwnPropertyDescriptor(target, propertyKey));
+      return;
+    }
+    const existing = getRuntimeRpcServiceMetadata(target);
+    Reflect.defineMetadata(RPC_SERVICE_KEY, {
+      ...existing,
+      requireAuth: true
+    }, target);
+  };
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, RequireAuth, "RequireAuth");
+function getRuntimeRpcServiceMetadata(target) {
+  return Reflect.getMetadata(RPC_SERVICE_KEY, target);
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, getRuntimeRpcServiceMetadata, "getRuntimeRpcServiceMetadata");
+function getRuntimeRpcMethodsMetadata(target) {
+  return Reflect.getMetadata(RPC_METHODS_KEY, target) || [];
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, getRuntimeRpcMethodsMetadata, "getRuntimeRpcMethodsMetadata");
+function getRpcAuthPolicy(requireAuth) {
+  return requireAuth ? "required" : "public";
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, getRpcAuthPolicy, "getRpcAuthPolicy");
+var WextsRpcService = RpcService;
+var WextsRpc = RpcMethod;
+function normalizeServiceOptions(input) {
+  if (typeof input === "string") {
+    return {
+      name: input,
+      requireAuth: false
+    };
+  }
+  return {
+    name: _optionalChain([input, 'optionalAccess', _ => _.name]),
+    requireAuth: _nullishCoalesce(_optionalChain([input, 'optionalAccess', _2 => _2.requireAuth]), () => ( true))
+  };
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, normalizeServiceOptions, "normalizeServiceOptions");
+function normalizeMethodOptions(input) {
+  if (typeof input === "string") {
+    return {
+      name: input
+    };
+  }
+  return _nullishCoalesce(input, () => ( {}));
+}
+_chunkXE4OXN2Wjs.__name.call(void 0, normalizeMethodOptions, "normalizeMethodOptions");
+
+
+
+
+
+
+
+
+
+
+exports.RpcService = RpcService; exports.RpcMethod = RpcMethod; exports.RequireAuth = RequireAuth; exports.getRuntimeRpcServiceMetadata = getRuntimeRpcServiceMetadata; exports.getRuntimeRpcMethodsMetadata = getRuntimeRpcMethodsMetadata; exports.getRpcAuthPolicy = getRpcAuthPolicy; exports.WextsRpcService = WextsRpcService; exports.WextsRpc = WextsRpc;
+//# sourceMappingURL=chunk-7QKLIVRF.js.map

package/dist/chunk-7QKLIVRF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Volumes/Projects/wexts/packages/dist/chunk-7QKLIVRF.js","../src/rpc/decorators.ts"],"names":["RPC_SERVICE_KEY","RPC_METHODS_KEY","RpcService","nameOrOptions","options","normalizeServiceOptions","target","Reflect","defineMetadata","RpcMethod","normalizeMethodOptions","propertyKey","constructor","methods","getMetadata","nextMethods","filter","method","push","RequireAuth","requireAuth","Object","getOwnPropertyDescriptor","existing","getRuntimeRpcServiceMetadata","getRuntimeRpcMethodsMetadata","getRpcAuthPolicy","WextsRpcService","WextsRpc","input","name"],"mappings":"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","file":"/Volumes/Projects/wexts/packages/dist/chunk-7QKLIVRF.js","sourcesContent":[null,"import 'reflect-metadata';\nimport type { RpcAuthPolicy } from './types';\n\nconst RPC_SERVICE_KEY = 'wexts:rpc:service';\nconst RPC_METHODS_KEY = 'wexts:rpc:methods';\n\nexport interface RpcServiceOptions {\n    name?: string;\n    requireAuth?: boolean;\n}\n\nexport interface RpcMethodOptions {\n    name?: string;\n    requireAuth?: boolean;\n}\n\nexport interface RuntimeRpcServiceMetadata {\n    name?: string;\n    requireAuth: boolean;\n}\n\nexport interface RuntimeRpcMethodMetadata {\n    propertyKey: string | symbol;\n    name?: string;\n    requireAuth?: boolean;\n}\n\nexport function RpcService(nameOrOptions?: string | RpcServiceOptions): ClassDecorator {\n    const options = normalizeServiceOptions(nameOrOptions);\n\n    return (target) => {\n        Reflect.defineMetadata(RPC_SERVICE_KEY, options, target);\n        return target;\n    };\n}\n\nexport function RpcMethod(nameOrOptions?: string | RpcMethodOptions): MethodDecorator {\n    const options = normalizeMethodOptions(nameOrOptions);\n\n    return (target, propertyKey) => {\n        const constructor = target.constructor;\n        const methods: RuntimeRpcMethodMetadata[] = Reflect.getMetadata(RPC_METHODS_KEY, constructor) || [];\n        const nextMethods = methods.filter((method) => method.propertyKey !== propertyKey);\n        nextMethods.push({ propertyKey, ...options });\n        Reflect.defineMetadata(RPC_METHODS_KEY, nextMethods, constructor);\n    };\n}\n\nexport function RequireAuth(): MethodDecorator & ClassDecorator {\n    return (target: object, propertyKey?: string | symbol) => {\n        if (propertyKey) {\n            RpcMethod({ requireAuth: true })(target, propertyKey, Object.getOwnPropertyDescriptor(target, propertyKey)!);\n            return;\n        }\n\n        const existing = getRuntimeRpcServiceMetadata(target as Function);\n        Reflect.defineMetadata(RPC_SERVICE_KEY, { ...existing, requireAuth: true }, target);\n    };\n}\n\nexport function getRuntimeRpcServiceMetadata(target: Function): RuntimeRpcServiceMetadata | undefined {\n    return Reflect.getMetadata(RPC_SERVICE_KEY, target);\n}\n\nexport function getRuntimeRpcMethodsMetadata(target: Function): RuntimeRpcMethodMetadata[] {\n    return Reflect.getMetadata(RPC_METHODS_KEY, target) || [];\n}\n\nexport function getRpcAuthPolicy(requireAuth?: boolean): RpcAuthPolicy {\n    return requireAuth ? 'required' : 'public';\n}\n\nexport const WextsRpcService = RpcService;\nexport const WextsRpc = RpcMethod;\n\nfunction normalizeServiceOptions(input?: string | RpcServiceOptions): RuntimeRpcServiceMetadata {\n    if (typeof input === 'string') {\n        return { name: input, requireAuth: false };\n    }\n\n    return {\n        name: input?.name,\n    requireAuth: input?.requireAuth ?? true,\n    };\n}\n\nfunction normalizeMethodOptions(input?: string | RpcMethodOptions): RpcMethodOptions {\n    if (typeof input === 'string') {\n        return { name: input };\n    }\n\n    return input ?? {};\n}\n"]}

package/dist/{chunk-FCEZDH42.mjs → chunk-7WULUGLH.mjs}

@@ -5,16 +5,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+// ../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.32_jiti@1.21.7_postcss@8.5.12_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename = /* @__PURE__ */ __name(() => fileURLToPath(import.meta.url), "getFilename");
 var getDirname = /* @__PURE__ */ __name(() => path.dirname(getFilename()), "getDirname");
 var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
 
 export {
   __name,
   __export,
-  __dirname
+  __dirname,
+  __filename
 };
-//# sourceMappingURL=chunk-FCEZDH42.mjs.map
+//# sourceMappingURL=chunk-7WULUGLH.mjs.map

package/dist/chunk-7WULUGLH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.32_jiti@1.21.7_postcss@8.5.12_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n"],"mappings":";;;;;;;;AACA,OAAOA,UAAU;AACjB,SAASC,qBAAqB;AAE9B,IAAMC,cAAc,6BAAMC,cAAc,YAAYC,GAAG,GAAnC;AACpB,IAAMC,aAAa,6BAAMC,KAAKC,QAAQL,YAAAA,CAAAA,GAAnB;AAEZ,IAAMM,YAA4BH,2BAAAA;AAClC,IAAMI,aAA6BP,4BAAAA;","names":["path","fileURLToPath","getFilename","fileURLToPath","url","getDirname","path","dirname","__dirname","__filename"]}

package/dist/{chunk-WF65EDRZ.js → chunk-BG56B4DE.js}

@@ -1,6 +1,16 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
+
+
+
+
+
+
+var _chunk7QKLIVRFjs = require('./chunk-7QKLIVRF.js');
+
+
+
 var _chunkXE4OXN2Wjs = require('./chunk-XE4OXN2W.js');
 
 // src/nest/index.ts
@@ -12,7 +22,15 @@ _chunkXE4OXN2Wjs.__export.call(void 0, nest_exports, {
   FusionPost: () => FusionPost,
   FusionPut: () => FusionPut,
   FusionRoute: () => FusionRoute,
-  getFusionMetadata: () => getFusionMetadata
+  RequireAuth: () => _chunk7QKLIVRFjs.RequireAuth,
+  RpcMethod: () => _chunk7QKLIVRFjs.RpcMethod,
+  RpcService: () => _chunk7QKLIVRFjs.RpcService,
+  WextsRpc: () => _chunk7QKLIVRFjs.WextsRpc,
+  WextsRpcService: () => _chunk7QKLIVRFjs.WextsRpcService,
+  getFusionMetadata: () => getFusionMetadata,
+  getRpcAuthPolicy: () => _chunk7QKLIVRFjs.getRpcAuthPolicy,
+  getRuntimeRpcMethodsMetadata: () => _chunk7QKLIVRFjs.getRuntimeRpcMethodsMetadata,
+  getRuntimeRpcServiceMetadata: () => _chunk7QKLIVRFjs.getRuntimeRpcServiceMetadata
 });
 
 // src/nest/decorators.ts
@@ -85,4 +103,4 @@ _chunkXE4OXN2Wjs.__name.call(void 0, getFusionMetadata, "getFusionMetadata");
 
 
 exports.FusionController = FusionController; exports.FusionRoute = FusionRoute; exports.FusionGet = FusionGet; exports.FusionPost = FusionPost; exports.FusionPut = FusionPut; exports.FusionDelete = FusionDelete; exports.getFusionMetadata = getFusionMetadata; exports.nest_exports = nest_exports;
-//# sourceMappingURL=chunk-WF65EDRZ.js.map
+//# sourceMappingURL=chunk-BG56B4DE.js.map

package/dist/chunk-BG56B4DE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Volumes/Projects/wexts/packages/dist/chunk-BG56B4DE.js","../src/nest/index.ts","../src/nest/decorators.ts"],"names":["FUSION_METADATA_KEY","FusionController","prefix","target","Reflect","defineMetadata","FusionRoute","metadata","propertyKey","descriptor","routes","getMetadata","push","handler","FusionGet","path","method","FusionPost","FusionPut","FusionDelete","getFusionMetadata","controller"],"mappings":"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","file":"/Volumes/Projects/wexts/packages/dist/chunk-BG56B4DE.js","sourcesContent":[null,"export * from './decorators';\nexport * from '../rpc/decorators';\n","// NestJS Integration - Decorators for wexts\n// These decorators add metadata for auto API client generation\n\nimport 'reflect-metadata';\n\nexport interface FusionRouteMetadata {\n    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';\n    path: string;\n    responseType?: string;\n    requestType?: string;\n}\n\nconst FUSION_METADATA_KEY = 'fusion:routes';\n\n/**\n * Mark a NestJS controller for Fusion codegen\n * Usage: @FusionController('users')\n */\nexport function FusionController(prefix: string = ''): ClassDecorator {\n    return function (target: any) {\n        Reflect.defineMetadata('fusion:controller', { prefix }, target);\n        return target;\n    };\n}\n\n/**\n * Mark a route for API client generation\n * Usage: @FusionRoute({ method: 'GET', path: '/:id' })\n */\nexport function FusionRoute(metadata: FusionRouteMetadata): MethodDecorator {\n    return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {\n        const routes = Reflect.getMetadata(FUSION_METADATA_KEY, target.constructor) || [];\n        routes.push({\n            ...metadata,\n            handler: propertyKey,\n        });\n        Reflect.defineMetadata(FUSION_METADATA_KEY, routes, target.constructor);\n        return descriptor;\n    };\n}\n\n/**\n * Helper decorators for common HTTP methods\n */\nexport function FusionGet(path: string = ''): MethodDecorator {\n    return FusionRoute({ method: 'GET', path });\n}\n\nexport function FusionPost(path: string = ''): MethodDecorator {\n    return FusionRoute({ method: 'POST', path });\n}\n\nexport function FusionPut(path: string = ''): MethodDecorator {\n    return FusionRoute({ method: 'PUT', path });\n}\n\nexport function FusionDelete(path: string = ''): MethodDecorator {\n    return FusionRoute({ method: 'DELETE', path });\n}\n\n/**\n * Get Fusion metadata from a controller\n */\nexport function getFusionMetadata(controller: any): {\n    controller: any;\n    routes: any[];\n} {\n    return {\n        controller: Reflect.getMetadata('fusion:controller', controller),\n        routes: Reflect.getMetadata(FUSION_METADATA_KEY, controller) || [],\n    };\n}\n"]}

package/dist/chunk-CLM5PNSG.mjs

@@ -0,0 +1,496 @@
+import {
+  logger
+} from "./chunk-JHOVXH3X.mjs";
+import {
+  __export,
+  __name
+} from "./chunk-7WULUGLH.mjs";
+
+// src/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  ClientGenerator: () => ClientGenerator,
+  CodegenWatcher: () => CodegenWatcher,
+  NestJSParser: () => NestJSParser,
+  generateRpcClient: () => generateRpcClient
+});
+
+// src/codegen/parser.ts
+import * as path from "path";
+import * as ts from "typescript";
+var RPC_SERVICE_DECORATORS = /* @__PURE__ */ new Set([
+  "RpcService",
+  "WextsRpcService"
+]);
+var RPC_METHOD_DECORATORS = /* @__PURE__ */ new Set([
+  "RpcMethod",
+  "WextsRpc"
+]);
+var REQUIRE_AUTH_DECORATORS = /* @__PURE__ */ new Set([
+  "RequireAuth"
+]);
+var NestJSParser = class {
+  static {
+    __name(this, "NestJSParser");
+  }
+  projectPath;
+  program;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, "tsconfig.json");
+    if (!configPath) {
+      throw new Error("tsconfig.json not found");
+    }
+    const config = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsedConfig = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
+    this.program = ts.createProgram(parsedConfig.fileNames, parsedConfig.options);
+  }
+  /**
+   * Find all controllers with @FusionController decorator
+   */
+  findFusionControllers() {
+    const controllers = [];
+    const sourceFiles = this.program.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+      if (sourceFile.fileName.includes("node_modules")) continue;
+      if (!sourceFile.fileName.includes(".controller.ts")) continue;
+      const fileControllers = this.parseSourceFile(sourceFile);
+      controllers.push(...fileControllers);
+    }
+    return controllers;
+  }
+  findRpcManifest() {
+    const services = [];
+    for (const sourceFile of this.program.getSourceFiles()) {
+      if (sourceFile.fileName.includes("node_modules")) continue;
+      if (!sourceFile.fileName.endsWith(".ts")) continue;
+      if (sourceFile.fileName.endsWith(".d.ts")) continue;
+      services.push(...this.parseRpcServices(sourceFile));
+    }
+    services.sort((a, b) => a.name.localeCompare(b.name));
+    for (const service of services) {
+      service.methods.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    if (services.length === 0) {
+      return {
+        schemaVersion: 1,
+        services
+      };
+    }
+    return {
+      schemaVersion: 1,
+      services
+    };
+  }
+  parseSourceFile(sourceFile) {
+    const controllers = [];
+    ts.forEachChild(sourceFile, (node) => {
+      if (ts.isClassDeclaration(node) && node.name) {
+        const controllerInfo = this.parseController(node);
+        if (controllerInfo) {
+          controllers.push(controllerInfo);
+        }
+      }
+    });
+    return controllers;
+  }
+  parseController(classNode) {
+    const decorators = ts.getDecorators(classNode);
+    if (!decorators) return null;
+    let controllerPrefix = "";
+    let isFusionController = false;
+    for (const decorator of decorators) {
+      const expr = decorator.expression;
+      if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+        const decoratorName = expr.expression.text;
+        if (decoratorName === "FusionController") {
+          isFusionController = true;
+          if (expr.arguments.length > 0) {
+            const arg = expr.arguments[0];
+            if (ts.isStringLiteral(arg)) {
+              controllerPrefix = arg.text;
+            }
+          }
+        }
+      }
+    }
+    if (!isFusionController) return null;
+    const routes = this.parseRoutes(classNode);
+    const className = classNode.name?.text || "Unknown";
+    return {
+      name: className,
+      prefix: controllerPrefix,
+      routes: routes.map((r) => ({
+        ...r,
+        controllerName: className
+      }))
+    };
+  }
+  parseRoutes(classNode) {
+    const routes = [];
+    classNode.members.forEach((member) => {
+      if (ts.isMethodDeclaration(member)) {
+        const decorators = ts.getDecorators(member);
+        if (!decorators) return;
+        for (const decorator of decorators) {
+          const expr = decorator.expression;
+          if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+            const decoratorName = expr.expression.text;
+            let method = null;
+            let routePath = "";
+            if (decoratorName === "FusionGet") method = "GET";
+            else if (decoratorName === "FusionPost") method = "POST";
+            else if (decoratorName === "FusionPut") method = "PUT";
+            else if (decoratorName === "FusionDelete") method = "DELETE";
+            if (method) {
+              if (expr.arguments.length > 0) {
+                const arg = expr.arguments[0];
+                if (ts.isStringLiteral(arg)) {
+                  routePath = arg.text;
+                }
+              }
+              const handlerName = member.name.text;
+              routes.push({
+                method,
+                path: routePath,
+                handler: handlerName,
+                controllerName: ""
+              });
+            }
+          }
+        }
+      }
+    });
+    return routes;
+  }
+  parseRpcServices(sourceFile) {
+    const services = [];
+    const rootDir = path.resolve(this.projectPath);
+    ts.forEachChild(sourceFile, (node) => {
+      if (!ts.isClassDeclaration(node) || !node.name) return;
+      const serviceDecorator = this.findDecorator(node, RPC_SERVICE_DECORATORS);
+      if (!serviceDecorator) return;
+      const className = node.name.text;
+      const serviceOptions = this.readDecoratorOptions(serviceDecorator);
+      const classRequiresAuth = serviceOptions.requireAuth || this.hasDecorator(node, REQUIRE_AUTH_DECORATORS);
+      const serviceName = serviceOptions.name || toStableServiceName(className);
+      const methods = this.parseRpcMethods(node, classRequiresAuth, sourceFile);
+      if (methods.length === 0) return;
+      services.push({
+        name: serviceName,
+        className,
+        importPath: toPosixPath(path.relative(rootDir, sourceFile.fileName).replace(/\.ts$/, "")),
+        requireAuth: classRequiresAuth,
+        methods
+      });
+    });
+    return services;
+  }
+  parseRpcMethods(classNode, classRequiresAuth, sourceFile) {
+    const methods = [];
+    for (const member of classNode.members) {
+      if (!ts.isMethodDeclaration(member)) continue;
+      if (!ts.isIdentifier(member.name)) continue;
+      const methodDecorator = this.findDecorator(member, RPC_METHOD_DECORATORS);
+      if (!methodDecorator) continue;
+      const handlerName = member.name.text;
+      const methodOptions = this.readDecoratorOptions(methodDecorator);
+      const requireAuth = classRequiresAuth || methodOptions.requireAuth || this.hasDecorator(member, REQUIRE_AUTH_DECORATORS);
+      methods.push({
+        name: methodOptions.name || handlerName,
+        handlerName,
+        requireAuth,
+        parameters: member.parameters.map((parameter) => this.parseParameter(parameter, sourceFile)),
+        returnType: member.type ? getNodeText(member.type, sourceFile) : "unknown"
+      });
+    }
+    return methods;
+  }
+  parseParameter(parameter, sourceFile) {
+    return {
+      name: ts.isIdentifier(parameter.name) ? parameter.name.text : parameter.name.getText(),
+      type: parameter.type ? getNodeText(parameter.type, sourceFile) : "unknown",
+      optional: Boolean(parameter.questionToken || parameter.initializer)
+    };
+  }
+  findDecorator(node, names) {
+    const decorators = ts.getDecorators(node);
+    if (!decorators) return void 0;
+    return decorators.find((decorator) => {
+      const name = getDecoratorName(decorator);
+      return Boolean(name && names.has(name));
+    });
+  }
+  hasDecorator(node, names) {
+    return Boolean(this.findDecorator(node, names));
+  }
+  readDecoratorOptions(decorator) {
+    const expression = decorator.expression;
+    if (!ts.isCallExpression(expression)) return {};
+    const firstArg = expression.arguments[0];
+    if (!firstArg) return {};
+    if (ts.isStringLiteral(firstArg)) {
+      return {
+        name: firstArg.text
+      };
+    }
+    if (!ts.isObjectLiteralExpression(firstArg)) return {};
+    const result = {};
+    for (const property of firstArg.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) continue;
+      if (property.name.text === "name" && ts.isStringLiteral(property.initializer)) {
+        result.name = property.initializer.text;
+      }
+      if (property.name.text === "requireAuth") {
+        if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+          result.requireAuth = true;
+        } else if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+          result.requireAuth = false;
+        }
+      }
+    }
+    return result;
+  }
+};
+function getDecoratorName(decorator) {
+  const expression = decorator.expression;
+  if (ts.isIdentifier(expression)) return expression.text;
+  if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression)) {
+    return expression.expression.text;
+  }
+  return void 0;
+}
+__name(getDecoratorName, "getDecoratorName");
+function toStableServiceName(className) {
+  const withoutSuffix = className.replace(/(Service|Controller)$/, "");
+  return withoutSuffix.charAt(0).toLowerCase() + withoutSuffix.slice(1);
+}
+__name(toStableServiceName, "toStableServiceName");
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join(path.posix.sep);
+}
+__name(toPosixPath, "toPosixPath");
+function getNodeText(node, sourceFile) {
+  return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+}
+__name(getNodeText, "getNodeText");
+
+// src/core/filesystem.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import { promisify } from "util";
+var readFile2 = promisify(fs.readFile);
+var writeFile2 = promisify(fs.writeFile);
+var mkdir2 = promisify(fs.mkdir);
+var access2 = promisify(fs.access);
+var FileSystem = class {
+  static {
+    __name(this, "FileSystem");
+  }
+  /**
+   * Read file as string
+   */
+  async readFile(filePath, encoding = "utf-8") {
+    return readFile2(filePath, encoding);
+  }
+  /**
+   * Write file
+   */
+  async writeFile(filePath, content) {
+    await this.ensureDir(path2.dirname(filePath));
+    return writeFile2(filePath, content, "utf-8");
+  }
+  /**
+   * Read JSON file
+   */
+  async readJSON(filePath) {
+    const content = await this.readFile(filePath);
+    return JSON.parse(content);
+  }
+  /**
+   * Write JSON file
+   */
+  async writeJSON(filePath, data, pretty = true) {
+    const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    return this.writeFile(filePath, content);
+  }
+  /**
+   * Check if file/directory exists
+   */
+  async exists(filePath) {
+    try {
+      await access2(filePath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Ensure directory exists (create if not)
+   */
+  async ensureDir(dirPath) {
+    if (!await this.exists(dirPath)) {
+      await mkdir2(dirPath, {
+        recursive: true
+      });
+    }
+  }
+  /**
+   * Copy file
+   */
+  async copyFile(src, dest) {
+    const content = await this.readFile(src);
+    await this.writeFile(dest, content);
+  }
+  /**
+   * Read directory
+   */
+  readDir(dirPath) {
+    return promisify(fs.readdir)(dirPath);
+  }
+};
+var filesystem = new FileSystem();
+
+// src/codegen/generator.ts
+import * as path3 from "path";
+var ClientGenerator = class {
+  static {
+    __name(this, "ClientGenerator");
+  }
+  async generate(options) {
+    const { manifest, outputPath, manifestFileName = "wexts.rpc.manifest.json", clientFileName = "client.ts" } = options;
+    if (manifest.services.length === 0) {
+      throw new Error("No Wexts RPC services found. Add @RpcService() to a Nest provider and @RpcMethod() to at least one method.");
+    }
+    const sortedManifest = sortManifest(manifest);
+    const clientCode = this.generateRpcClientCode(sortedManifest);
+    await filesystem.writeJSON(path3.join(outputPath, manifestFileName), sortedManifest, true);
+    await filesystem.writeFile(path3.join(outputPath, clientFileName), clientCode);
+    const indexCode = `export * from './client';
+`;
+    await filesystem.writeFile(path3.join(outputPath, "index.ts"), indexCode);
+  }
+  generateRpcClientCode(manifest) {
+    const manifestJson = JSON.stringify(manifest, null, 2);
+    return `import { createWextsRpcClient, type WextsRpcClientOptions } from 'wexts/client';
+import type { RpcManifest } from 'wexts/rpc';
+
+const manifest = ${manifestJson} satisfies RpcManifest;
+
+${this.generateClientInterface(manifest)}
+
+export function createWextsClient(options?: WextsRpcClientOptions): WextsClient {
+  return createWextsRpcClient(manifest, options) as unknown as WextsClient;
+}
+
+export const wexts = createWextsClient();
+`;
+  }
+  generateClientInterface(manifest) {
+    const services = manifest.services.map((service) => this.generateServiceInterface(service)).join("\n");
+    return `export interface WextsClient {
+${services}}
+`;
+  }
+  generateServiceInterface(service) {
+    const methods = service.methods.map((method) => `    ${method.name}: (${this.parametersToSignature(method)}) => Promise<${normalizeReturnType(method.returnType)}>;`).join("\n");
+    return `  ${service.name}: {
+${methods}
+  };
+`;
+  }
+  parametersToSignature(method) {
+    return method.parameters.map((parameter) => `${parameter.name}${parameter.optional ? "?" : ""}: ${parameter.type}`).join(", ");
+  }
+};
+async function generateRpcClient(options) {
+  const parser = new NestJSParser(options.projectPath);
+  const manifest = parser.findRpcManifest();
+  const generator = new ClientGenerator();
+  await generator.generate({
+    manifest,
+    outputPath: options.outputPath,
+    manifestFileName: options.manifestFileName,
+    clientFileName: options.clientFileName
+  });
+  return sortManifest(manifest);
+}
+__name(generateRpcClient, "generateRpcClient");
+function sortManifest(manifest) {
+  return {
+    schemaVersion: 1,
+    services: [
+      ...manifest.services
+    ].sort((a, b) => a.name.localeCompare(b.name)).map((service) => ({
+      ...service,
+      methods: [
+        ...service.methods
+      ].sort((a, b) => a.name.localeCompare(b.name))
+    }))
+  };
+}
+__name(sortManifest, "sortManifest");
+function normalizeReturnType(returnType) {
+  const match = returnType.match(/^Promise<(.+)>$/);
+  return match?.[1] ?? returnType;
+}
+__name(normalizeReturnType, "normalizeReturnType");
+
+// src/codegen/watcher.ts
+import * as chokidar from "chokidar";
+var CodegenWatcher = class {
+  static {
+    __name(this, "CodegenWatcher");
+  }
+  watcher = null;
+  async watch(options) {
+    const { projectPath, outputPath, pattern = "**/*.controller.ts" } = options;
+    logger.info("\u{1F440} Watching for controller changes...");
+    await this.generateClient(projectPath, outputPath);
+    this.watcher = chokidar.watch(pattern, {
+      cwd: projectPath,
+      ignored: /node_modules/,
+      persistent: true
+    });
+    this.watcher.on("change", async (path4) => {
+      logger.info(`\u{1F4DD} Controller changed: ${path4}`);
+      await this.generateClient(projectPath, outputPath);
+    });
+    this.watcher.on("add", async (path4) => {
+      logger.info(`\u2795 New controller: ${path4}`);
+      await this.generateClient(projectPath, outputPath);
+    });
+    this.watcher.on("unlink", async (path4) => {
+      logger.info(`\u2796 Controller removed: ${path4}`);
+      await this.generateClient(projectPath, outputPath);
+    });
+  }
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  async generateClient(projectPath, outputPath) {
+    try {
+      const manifest = await generateRpcClient({
+        projectPath,
+        outputPath
+      });
+      logger.success(`Generated client for ${manifest.services.length} RPC service(s)`);
+    } catch (error) {
+      logger.error("Failed to generate client:", error.message);
+    }
+  }
+};
+
+export {
+  FileSystem,
+  filesystem,
+  NestJSParser,
+  ClientGenerator,
+  generateRpcClient,
+  CodegenWatcher,
+  codegen_exports
+};
+//# sourceMappingURL=chunk-CLM5PNSG.mjs.map