@keq-request/nestjs 5.0.0-alpha.33 → 5.0.0-alpha.35

package/.turbo/turbo-build.log

@@ -1,18 +1,36 @@
 
-> @keq-request/nestjs@5.0.0-alpha.33 build /home/runner/work/keq/keq/packages/nestjs
-> tsup
+> @keq-request/nestjs@5.0.0-alpha.35 build /home/runner/work/keq/keq/packages/nestjs
+> tsdown
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.lib.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/keq/keq/packages/nestjs/tsup.config.ts
-CLI Target: node20
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-ESM dist/index.mjs     2.27 KB
-ESM dist/index.mjs.map 3.94 KB
-ESM ⚡️ Build success in 79ms
-CJS dist/index.js     3.28 KB
-CJS dist/index.js.map 4.04 KB
-CJS ⚡️ Build success in 82ms
+ℹ tsdown v0.21.10 powered by rolldown v1.0.0-rc.17
+ℹ config file: /home/runner/work/keq/keq/packages/nestjs/tsdown.config.ts 
+(node:2732) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/keq/keq/packages/nestjs/tsdown.config.ts?no-cache=d433c752-7b69-49b8-899f-3db56eb2b711 is not specified and it doesn't parse as CommonJS.
+Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
+To eliminate this warning, add "type": "module" to /home/runner/work/keq/keq/packages/nestjs/package.json.
+(Use `node --trace-warnings ...` to show where the warning was created)
+ℹ entry: src/index.ts
+ℹ target: node20
+ℹ tsconfig: tsconfig.lib.json
+ℹ Build start
+ℹ [CJS] dist/index.js      2.35 kB │ gzip: 1.00 kB
+ℹ [CJS] dist/index.js.map  3.54 kB │ gzip: 1.35 kB
+ℹ [CJS] 2 files, total: 5.89 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `tsdown:deps`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
+ℹ [CJS] dist/index.d.ts.map  0.54 kB │ gzip: 0.30 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugins. Here is a breakdown:
+ℹ [CJS] dist/index.d.ts      2.17 kB │ gzip: 0.89 kB
+ℹ [CJS] 2 files, total: 2.71 kB
+  - rolldown-plugin-dts:generate (48%)
+  - tsdown:deps (46%)
+See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 4131ms
+ℹ [ESM] dist/index.mjs        2.17 kB │ gzip: 0.92 kB
+ℹ [ESM] dist/index.mjs.map    3.49 kB │ gzip: 1.34 kB
+ℹ [ESM] dist/index.d.mts.map  0.54 kB │ gzip: 0.30 kB
+ℹ [ESM] dist/index.d.mts      2.17 kB │ gzip: 0.89 kB
+ℹ [ESM] 4 files, total: 8.37 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `rolldown-plugin-dts:generate`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 4134ms

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @keq-request/nestjs
 
+## 5.0.0-alpha.35
+
+### Patch Changes
+
+- Updated dependencies [0a04864]
+  - keq@5.0.0-alpha.35
+
+## 5.0.0-alpha.34
+
+### Patch Changes
+
+- Updated dependencies [a7a83da]
+- Updated dependencies [f8abc63]
+  - keq@5.0.0-alpha.34
+
 ## 5.0.0-alpha.33
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,62 @@
+import { KeqMiddleware } from "keq";
+import * as _$_nestjs_common0 from "@nestjs/common";
+import { DynamicModule } from "@nestjs/common";
+
+//#region src/types/keq-module-options.d.ts
+interface KeqModuleOptions {
+  middlewares?: KeqMiddleware[];
+}
+//#endregion
+//#region src/keq.module-definition.d.ts
+declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: _$_nestjs_common0.ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
+//#endregion
+//#region src/keq.module.d.ts
+/**
+ * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
+ *
+ * This module is global, so KeqRequest can be injected anywhere in your application
+ * without needing to import the module in every feature module.
+ *
+ * @example
+ * ```typescript
+ * // Synchronous registration
+ * KeqModule.register({
+ *   middlewares: [...]
+ * })
+ *
+ * // Asynchronous registration
+ * KeqModule.registerAsync({
+ *   imports: [ConfigModule],
+ *   useFactory: (config: ConfigService) => ({
+ *     middlewares: [...]
+ *   }),
+ *   inject: [ConfigService]
+ * })
+ *
+ * // Inject in service
+ * class UserService {
+ *   constructor(private readonly keqRequest: KeqRequest) {}
+ *   async getUser(id: string) {
+ *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
+ *   }
+ * }
+ * ```
+ */
+declare class KeqModule extends ConfigurableModuleClass {
+  /**
+   * Register the module with synchronous options
+   * @param options - Configuration options including middlewares
+   * @returns DynamicModule with KeqRequest provider
+   */
+  static register(options: typeof OPTIONS_TYPE): DynamicModule;
+  /**
+   * Register the module with asynchronous options
+   * Useful when you need to inject dependencies like ConfigService
+   * @param options - Async configuration options
+   * @returns DynamicModule with KeqRequest provider
+   */
+  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+}
+//#endregion
+export { KeqModule, KeqModuleOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/keq-module-options.ts","../src/keq.module-definition.ts","../src/keq.module.ts"],"mappings":";;;;;UAGiB,gBAAA;EACf,WAAA,GAAc,aAAA;AAAA;;;cCEd,uBAAA,EAAuB,iBAAA,CAAA,qBAAA,CAAA,gBAAA,6BAAA,oBAAA,mBAAA,YAAA,EAEX,gBAAA,GAAA,OAAA,MAAA,kBAAA,EACM,iBAAA,CAAA,8BAAA,CAAA,gBAAA,cAAA,OAAA;;;;;;ADNpB;;;;;;;;ACEA;;;;;;;;;;;;;;;;;;;;cCsDa,SAAA,SAAkB,uBAAA;EDnD7B;;;;;EAAA,OCyDO,QAAA,CAAS,OAAA,SAAgB,YAAA,GAAe,aAAA;EAN1B;;;;;;EAAA,OAoBd,aAAA,CAAc,OAAA,SAAgB,kBAAA,GAAqB,aAAA;AAAA"}

package/dist/index.d.ts

@@ -1,3 +1,62 @@
-export * from './keq.module.js';
-export * from './types/index.js';
+import * as _$_nestjs_common0 from "@nestjs/common";
+import { DynamicModule } from "@nestjs/common";
+import { KeqMiddleware } from "keq";
+
+//#region src/types/keq-module-options.d.ts
+interface KeqModuleOptions {
+  middlewares?: KeqMiddleware[];
+}
+//#endregion
+//#region src/keq.module-definition.d.ts
+declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: _$_nestjs_common0.ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
+//#endregion
+//#region src/keq.module.d.ts
+/**
+ * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
+ *
+ * This module is global, so KeqRequest can be injected anywhere in your application
+ * without needing to import the module in every feature module.
+ *
+ * @example
+ * ```typescript
+ * // Synchronous registration
+ * KeqModule.register({
+ *   middlewares: [...]
+ * })
+ *
+ * // Asynchronous registration
+ * KeqModule.registerAsync({
+ *   imports: [ConfigModule],
+ *   useFactory: (config: ConfigService) => ({
+ *     middlewares: [...]
+ *   }),
+ *   inject: [ConfigService]
+ * })
+ *
+ * // Inject in service
+ * class UserService {
+ *   constructor(private readonly keqRequest: KeqRequest) {}
+ *   async getUser(id: string) {
+ *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
+ *   }
+ * }
+ * ```
+ */
+declare class KeqModule extends ConfigurableModuleClass {
+  /**
+   * Register the module with synchronous options
+   * @param options - Configuration options including middlewares
+   * @returns DynamicModule with KeqRequest provider
+   */
+  static register(options: typeof OPTIONS_TYPE): DynamicModule;
+  /**
+   * Register the module with asynchronous options
+   * Useful when you need to inject dependencies like ConfigService
+   * @param options - Async configuration options
+   * @returns DynamicModule with KeqRequest provider
+   */
+  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+}
+//#endregion
+export { KeqModule, KeqModuleOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types/keq-module-options.ts","../src/keq.module-definition.ts","../src/keq.module.ts"],"mappings":";;;;;UAGiB,gBAAA;EACf,WAAA,GAAc,aAAA;AAAA;;;cCEd,uBAAA,EAAuB,iBAAA,CAAA,qBAAA,CAAA,gBAAA,6BAAA,oBAAA,mBAAA,YAAA,EAEX,gBAAA,GAAA,OAAA,MAAA,kBAAA,EACM,iBAAA,CAAA,8BAAA,CAAA,gBAAA,cAAA,OAAA;;;;;;ADNpB;;;;;;;;ACEA;;;;;;;;;;;;;;;;;;;;cCsDa,SAAA,SAAkB,uBAAA;EDnD7B;;;;;EAAA,OCyDO,QAAA,CAAS,OAAA,SAAgB,YAAA,GAAe,aAAA;EAN1B;;;;;;EAAA,OAoBd,aAAA,CAAc,OAAA,SAAgB,kBAAA,GAAqB,aAAA;AAAA"}

package/dist/index.js

@@ -1,94 +1,63 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  KeqModule: () => KeqModule
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/keq.module.ts
-var import_keq = require("keq");
-var import_common2 = require("@nestjs/common");
-
-// src/keq.module-definition.ts
-var import_common = require("@nestjs/common");
-var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new import_common.ConfigurableModuleBuilder().build();
-
-// src/keq.module.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let keq = require("keq");
+let _nestjs_common = require("@nestjs/common");
+//#region src/keq.module-definition.ts
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new _nestjs_common.ConfigurableModuleBuilder().build();
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate, "_ts_decorate");
-var requestProvider = {
-  provide: import_keq.KeqRequest,
-  useFactory: /* @__PURE__ */ __name((config) => {
-    const request = new import_keq.KeqRequest();
-    if (config.middlewares) {
-      for (const middleware of config.middlewares) {
-        request.use(middleware);
-      }
-    }
-    return request;
-  }, "useFactory"),
-  inject: [
-    MODULE_OPTIONS_TOKEN
-  ]
+//#endregion
+//#region src/keq.module.ts
+/**
+* Provider that creates and configures a KeqRequest instance
+* Applies any middlewares defined in the module options
+*/
+const requestProvider = {
+	provide: keq.KeqRequest,
+	useFactory: (config) => {
+		const request = new keq.KeqRequest();
+		if (config.middlewares) for (const middleware of config.middlewares) request.use(middleware);
+		return request;
+	},
+	inject: [MODULE_OPTIONS_TOKEN]
 };
-var KeqModule = class extends ConfigurableModuleClass {
-  static {
-    __name(this, "KeqModule");
-  }
-  /**
-  * Register the module with synchronous options
-  * @param options - Configuration options including middlewares
-  * @returns DynamicModule with KeqRequest provider
-  */
-  static register(options) {
-    const mo = super.register(options);
-    mo.providers.push(requestProvider);
-    mo.global = true;
-    return mo;
-  }
-  /**
-  * Register the module with asynchronous options
-  * Useful when you need to inject dependencies like ConfigService
-  * @param options - Async configuration options
-  * @returns DynamicModule with KeqRequest provider
-  */
-  static registerAsync(options) {
-    const mo = super.registerAsync(options);
-    mo.providers.push(requestProvider);
-    mo.global = true;
-    return mo;
-  }
+let KeqModule = class KeqModule extends ConfigurableModuleClass {
+	/**
+	* Register the module with synchronous options
+	* @param options - Configuration options including middlewares
+	* @returns DynamicModule with KeqRequest provider
+	*/
+	static register(options) {
+		const mo = super.register(options);
+		mo.providers.push(requestProvider);
+		mo.global = true;
+		return mo;
+	}
+	/**
+	* Register the module with asynchronous options
+	* Useful when you need to inject dependencies like ConfigService
+	* @param options - Async configuration options
+	* @returns DynamicModule with KeqRequest provider
+	*/
+	static registerAsync(options) {
+		const mo = super.registerAsync(options);
+		mo.providers.push(requestProvider);
+		mo.global = true;
+		return mo;
+	}
 };
-KeqModule = _ts_decorate([
-  (0, import_common2.Global)()
-], KeqModule);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  KeqModule
+KeqModule = __decorate([(0, _nestjs_common.Global)()], KeqModule);
+//#endregion
+Object.defineProperty(exports, "KeqModule", {
+	enumerable: true,
+	get: function() {
+		return KeqModule;
+	}
 });
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["export * from './keq.module.js'\nexport * from './types/index.js'\n","\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n","\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;ACCA,iBAA2B;AAC3B,IAAAA,iBAAgD;;;ACDhD,oBAA0C;AAInC,IAAM,EACXC,yBACAC,sBACAC,cACAC,mBAAkB,IAChB,IAAIC,wCAAAA,EAA8CC,MAAK;;;;;;;;;;ADC3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,sBAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAkCO,IAAMC,YAAN,cAAwBC,wBAAAA;SAAAA;;;;;;;;EAM7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;;;;;;;EAQA,OAAOI,cAAcL,SAAmD;AACtE,UAAMC,KAAK,MAAMI,cAAcL,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;AACF;AA3BaJ,YAAAA,aAAAA;MADZS,uBAAAA;GACYT,SAAAA;","names":["import_common","ConfigurableModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","ConfigurableModuleBuilder","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","ConfigurableModuleClass","register","options","mo","providers","push","global","registerAsync","Global"]}
+{"version":3,"file":"index.js","names":["ConfigurableModuleBuilder","KeqRequest"],"sources":["../src/keq.module-definition.ts","../src/keq.module.ts"],"sourcesContent":["\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n","\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n"],"mappings":";;;;AAKA,MAAa,EACX,yBACA,sBACA,cACA,uBACE,IAAIA,eAAAA,2BAA6C,CAAC,OAAO;;;;;;;;;;;;;;;ACC7D,MAAM,kBAA4B;CAChC,SAASC,IAAAA;CACT,aAAa,WAA6B;EACxC,MAAM,UAAU,IAAIA,IAAAA,YAAY;AAEhC,MAAI,OAAO,YACT,MAAK,MAAM,cAAc,OAAO,YAC9B,SAAQ,IAAI,WAAW;AAI3B,SAAO;;CAET,QAAQ,CAAC,qBAAqB;CAC/B;AAkCM,IAAA,YAAA,MAAM,kBAAkB,wBAAwB;;;;;;CAMrD,OAAO,SAAS,SAA6C;EAC3D,MAAM,KAAK,MAAM,SAAS,QAAQ;AAClC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;;;;;;CAST,OAAO,cAAc,SAAmD;EACtE,MAAM,KAAK,MAAM,cAAc,QAAQ;AACvC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;oDA1BF,CAAA,EAAA,UAAA"}

package/dist/index.mjs

@@ -1,69 +1,57 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/keq.module.ts
 import { KeqRequest } from "keq";
-import { Global } from "@nestjs/common";
-
-// src/keq.module-definition.ts
-import { ConfigurableModuleBuilder } from "@nestjs/common";
-var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder().build();
-
-// src/keq.module.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+import { ConfigurableModuleBuilder, Global } from "@nestjs/common";
+//#region src/keq.module-definition.ts
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder().build();
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate, "_ts_decorate");
-var requestProvider = {
-  provide: KeqRequest,
-  useFactory: /* @__PURE__ */ __name((config) => {
-    const request = new KeqRequest();
-    if (config.middlewares) {
-      for (const middleware of config.middlewares) {
-        request.use(middleware);
-      }
-    }
-    return request;
-  }, "useFactory"),
-  inject: [
-    MODULE_OPTIONS_TOKEN
-  ]
+//#endregion
+//#region src/keq.module.ts
+/**
+* Provider that creates and configures a KeqRequest instance
+* Applies any middlewares defined in the module options
+*/
+const requestProvider = {
+	provide: KeqRequest,
+	useFactory: (config) => {
+		const request = new KeqRequest();
+		if (config.middlewares) for (const middleware of config.middlewares) request.use(middleware);
+		return request;
+	},
+	inject: [MODULE_OPTIONS_TOKEN]
 };
-var KeqModule = class extends ConfigurableModuleClass {
-  static {
-    __name(this, "KeqModule");
-  }
-  /**
-  * Register the module with synchronous options
-  * @param options - Configuration options including middlewares
-  * @returns DynamicModule with KeqRequest provider
-  */
-  static register(options) {
-    const mo = super.register(options);
-    mo.providers.push(requestProvider);
-    mo.global = true;
-    return mo;
-  }
-  /**
-  * Register the module with asynchronous options
-  * Useful when you need to inject dependencies like ConfigService
-  * @param options - Async configuration options
-  * @returns DynamicModule with KeqRequest provider
-  */
-  static registerAsync(options) {
-    const mo = super.registerAsync(options);
-    mo.providers.push(requestProvider);
-    mo.global = true;
-    return mo;
-  }
-};
-KeqModule = _ts_decorate([
-  Global()
-], KeqModule);
-export {
-  KeqModule
+let KeqModule = class KeqModule extends ConfigurableModuleClass {
+	/**
+	* Register the module with synchronous options
+	* @param options - Configuration options including middlewares
+	* @returns DynamicModule with KeqRequest provider
+	*/
+	static register(options) {
+		const mo = super.register(options);
+		mo.providers.push(requestProvider);
+		mo.global = true;
+		return mo;
+	}
+	/**
+	* Register the module with asynchronous options
+	* Useful when you need to inject dependencies like ConfigService
+	* @param options - Async configuration options
+	* @returns DynamicModule with KeqRequest provider
+	*/
+	static registerAsync(options) {
+		const mo = super.registerAsync(options);
+		mo.providers.push(requestProvider);
+		mo.global = true;
+		return mo;
+	}
 };
+KeqModule = __decorate([Global()], KeqModule);
+//#endregion
+export { KeqModule };
+
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n","\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n"],"mappings":";;;;AACA,SAASA,kBAAkB;AAC3B,SAAwBC,cAAwB;;;ACDhD,SAASC,iCAAiC;AAInC,IAAM,EACXC,yBACAC,sBACAC,cACAC,mBAAkB,IAChB,IAAIJ,0BAAAA,EAA8CK,MAAK;;;;;;;;;;ADC3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,WAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAkCO,IAAMC,YAAN,cAAwBC,wBAAAA;SAAAA;;;;;;;;EAM7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;;;;;;;EAQA,OAAOI,cAAcL,SAAmD;AACtE,UAAMC,KAAK,MAAMI,cAAcL,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;AACF;AA3BaJ,YAAAA,aAAAA;EADZS,OAAAA;GACYT,SAAAA;","names":["KeqRequest","Global","ConfigurableModuleBuilder","ConfigurableModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","ConfigurableModuleClass","register","options","mo","providers","push","global","registerAsync","Global"]}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/keq.module-definition.ts","../src/keq.module.ts"],"sourcesContent":["\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n","\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n"],"mappings":";;;AAKA,MAAa,EACX,yBACA,sBACA,cACA,uBACE,IAAI,2BAA6C,CAAC,OAAO;;;;;;;;;;;;;;;ACC7D,MAAM,kBAA4B;CAChC,SAAS;CACT,aAAa,WAA6B;EACxC,MAAM,UAAU,IAAI,YAAY;AAEhC,MAAI,OAAO,YACT,MAAK,MAAM,cAAc,OAAO,YAC9B,SAAQ,IAAI,WAAW;AAI3B,SAAO;;CAET,QAAQ,CAAC,qBAAqB;CAC/B;AAkCM,IAAA,YAAA,MAAM,kBAAkB,wBAAwB;;;;;;CAMrD,OAAO,SAAS,SAA6C;EAC3D,MAAM,KAAK,MAAM,SAAS,QAAQ;AAClC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;;;;;;CAST,OAAO,cAAc,SAAmD;EACtE,MAAM,KAAK,MAAM,cAAc,QAAQ;AACvC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;wBA1BV,QAAQ,CAAA,EAAA,UAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keq-request/nestjs",
-  "version": "5.0.0-alpha.33",
+  "version": "5.0.0-alpha.35",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",
@@ -33,22 +33,21 @@
     "type": "git",
     "url": "git+https://github.com/keq-request/keq.git"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@types/node": "^20.19.25",
-    "@nestjs/common": "^11.0.0",
-    "keq": "5.0.0-alpha.33"
+    "@nestjs/common": "^11.1.19",
+    "@types/node": "^20.19.39",
+    "keq": "5.0.0-alpha.35"
   },
   "peerDependencies": {
-    "keq": "^5.0.0-alpha.33",
-    "@nestjs/common": "^11.0.0"
+    "@nestjs/common": "^11.0.0",
+    "keq": "^5.0.0-alpha.35"
   },
   "engines": {
     "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "test": "jest",
     "test:update": "jest -u"
   }

package/tsconfig.json

@@ -1,13 +1,14 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "baseUrl": "./src",
+    "rootDir": "..",
+    "outDir": "./dist",
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "paths": {
-      "~/*": ["./*"],
-      "~~/*": ["../*"],
-      "@keq-request/test": ["../../test/src/index.ts"]
+      "~/*": ["./src/*"],
+      "~~/*": ["./*"],
+      "@keq-request/test": ["../test/src/index.ts"]
     }
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  target: ['node20'],
+  platform: 'neutral',
+  tsconfig: 'tsconfig.lib.json',
+  dts: { sourcemap: true },
+  sourcemap: true,
+  clean: true,
+})

package/dist/keq.module-definition.d.ts

@@ -1,3 +0,0 @@
-import { KeqModuleOptions } from './types/keq-module-options';
-export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
-//# sourceMappingURL=keq.module-definition.d.ts.map

package/dist/keq.module-definition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keq.module-definition.d.ts","sourceRoot":"","sources":["../src/keq.module-definition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAG7D,eAAO,MACL,uBAAuB,8FACvB,oBAAoB,mBACpB,YAAY,kCACZ,kBAAkB,mGACyC,CAAA"}

package/dist/keq.module.d.ts

@@ -1,49 +0,0 @@
-import { DynamicModule } from '@nestjs/common';
-import { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, OPTIONS_TYPE } from './keq.module-definition.js';
-/**
- * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
- *
- * This module is global, so KeqRequest can be injected anywhere in your application
- * without needing to import the module in every feature module.
- *
- * @example
- * ```typescript
- * // Synchronous registration
- * KeqModule.register({
- *   middlewares: [...]
- * })
- *
- * // Asynchronous registration
- * KeqModule.registerAsync({
- *   imports: [ConfigModule],
- *   useFactory: (config: ConfigService) => ({
- *     middlewares: [...]
- *   }),
- *   inject: [ConfigService]
- * })
- *
- * // Inject in service
- * class UserService {
- *   constructor(private readonly keqRequest: KeqRequest) {}
- *   async getUser(id: string) {
- *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
- *   }
- * }
- * ```
- */
-export declare class KeqModule extends ConfigurableModuleClass {
-    /**
-     * Register the module with synchronous options
-     * @param options - Configuration options including middlewares
-     * @returns DynamicModule with KeqRequest provider
-     */
-    static register(options: typeof OPTIONS_TYPE): DynamicModule;
-    /**
-     * Register the module with asynchronous options
-     * Useful when you need to inject dependencies like ConfigService
-     * @param options - Async configuration options
-     * @returns DynamicModule with KeqRequest provider
-     */
-    static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
-}
-//# sourceMappingURL=keq.module.d.ts.map

package/dist/keq.module.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keq.module.d.ts","sourceRoot":"","sources":["../src/keq.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAoB,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAwB,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAwB5H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,SAAU,SAAQ,uBAAuB;IACpD;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,YAAY,GAAG,aAAa;IAQ5D;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,kBAAkB,GAAG,aAAa;CAOxE"}

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './keq-module-options.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA"}

package/dist/types/keq-module-options.d.ts

@@ -1,5 +0,0 @@
-import { KeqMiddleware } from 'keq';
-export interface KeqModuleOptions {
-    middlewares?: KeqMiddleware[];
-}
-//# sourceMappingURL=keq-module-options.d.ts.map

package/dist/types/keq-module-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keq-module-options.d.ts","sourceRoot":"","sources":["../../src/types/keq-module-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAA;AAGnC,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,aAAa,EAAE,CAAA;CAC9B"}

package/tsup.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  target: ['node20'],
-  platform: 'node',
-  tsconfig: 'tsconfig.lib.json',
-  dts: false,
-  splitting: false,
-  sourcemap: true,
-  clean: true,
-  onSuccess: 'tsc --emitDeclarationOnly -d --declarationMap -p ./tsconfig.lib.json && tsc-alias -p ./tsconfig.lib.json',
-})