jimpex 10.0.2 → 11.0.0

package/dist/utils/wrappers.js

@@ -1,58 +1,30 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var wrappers_exports = {};
-__export(wrappers_exports, {
-  controller: () => controller,
-  controllerCreator: () => controllerCreator,
-  controllerProvider: () => controllerProvider,
-  controllerProviderCreator: () => controllerProviderCreator,
-  middleware: () => middleware,
-  middlewareCreator: () => middlewareCreator,
-  middlewareProvider: () => middlewareProvider,
-  middlewareProviderCreator: () => middlewareProviderCreator,
-  provider: () => provider,
-  providerCreator: () => providerCreator,
-  providers: () => providers
-});
-module.exports = __toCommonJS(wrappers_exports);
-var import_jimple = require("@homer0/jimple");
-const provider = (0, import_jimple.createProvider)();
-const providerCreator = (0, import_jimple.createProviderCreator)();
-const providers = (0, import_jimple.createProviders)();
-const controllerFactory = (0, import_jimple.resourceFactory)();
+import {
+  createProvider,
+  createProviderCreator,
+  createProviders,
+  resourceFactory,
+  resourceCreatorFactory
+} from "@homer0/jimple";
+const provider = createProvider();
+const providerCreator = createProviderCreator();
+const providers = createProviders();
+const controllerFactory = resourceFactory();
 const controller = (connect) => controllerFactory("controller", "connect", connect);
-const controllerCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const controllerCreatorFactory = resourceCreatorFactory();
 const controllerCreator = (creator) => controllerCreatorFactory("controller", "connect", creator);
-const controllerProviderFactory = (0, import_jimple.resourceFactory)();
+const controllerProviderFactory = resourceFactory();
 const controllerProvider = (register) => controllerProviderFactory("provider", "register", register);
-const controllerProviderCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const controllerProviderCreatorFactory = resourceCreatorFactory();
 const controllerProviderCreator = (creator) => controllerProviderCreatorFactory("provider", "register", creator);
-const middlewareFactory = (0, import_jimple.resourceFactory)();
+const middlewareFactory = resourceFactory();
 const middleware = (connect) => middlewareFactory("middleware", "connect", connect);
-const middlewareCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const middlewareCreatorFactory = resourceCreatorFactory();
 const middlewareCreator = (creator) => middlewareCreatorFactory("middleware", "connect", creator);
-const middlewareProviderFactory = (0, import_jimple.resourceFactory)();
+const middlewareProviderFactory = resourceFactory();
 const middlewareProvider = (register) => middlewareProviderFactory("provider", "register", register);
-const middlewareProviderCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const middlewareProviderCreatorFactory = resourceCreatorFactory();
 const middlewareProviderCreator = (creator) => middlewareProviderCreatorFactory("provider", "register", creator);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   controller,
   controllerCreator,
   controllerProvider,
@@ -64,5 +36,5 @@ const middlewareProviderCreator = (creator) => middlewareProviderCreatorFactory(
   provider,
   providerCreator,
   providers
-});
+};
 //# sourceMappingURL=wrappers.js.map

package/dist/utils/wrappers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/wrappers.ts"],"sourcesContent":["import {\n  createProvider,\n  createProviderCreator,\n  createProviders,\n  resourceFactory,\n  type ProviderRegisterFn as OriginalProviderRegisterFn,\n  type GenericCurriedFn,\n  resourceCreatorFactory,\n} from '@homer0/jimple';\nimport type { Jimpex } from '../app';\nimport type { Router, ExpressMiddlewareLike, NoStringIndex } from '../types';\n/**\n * The function a provider uses to configure a resource in the container.\n *\n * @group Wrappers\n */\nexport type ProviderRegisterFn = OriginalProviderRegisterFn<Jimpex>;\n/**\n * Creates an object that can configure/extend the container by registering services and\n * resources.\n *\n * @example\n *\n *   class APIClient {}\n *   const apiClientProvider = provider((app) => {\n *     app.set('apiClient', () => new APIClient());\n *   });\n *\n * @group Wrappers\n */\nexport const provider = createProvider<Jimpex>();\n/**\n * Creates an object like a provider, but that it can also be used as a function, as it\n * normally expose options for the resources it will configure.\n *\n * @example\n *\n * <caption>Registering as a common provider</caption>\n *\n *   const apiClientProvider = providerCreator(\n *     ({ serviceName = 'apiClient' }) =>\n *       (app) => {\n *         app.set(serviceName, () => new APIClient());\n *       },\n *   );\n *\n *   container.register(apiClientProvider);\n *\n * @example\n *\n * <caption>Registering a created provider</caption>\n *\n *   container.register(\n *     apiClientProvider({\n *       serviceName: 'myApiClient',\n *     }),\n *   );\n *\n * @group Wrappers\n */\nexport const providerCreator = createProviderCreator<Jimpex>();\n/**\n * Creates a collection of providers that can be registered one by one, or all at once.\n *\n * @example\n *\n * <caption>Registering all the providers at once</caption>\n *\n *   const collection = providers({\n *     apiClient: apiClientProvider,\n *     http: httpProvider,\n *   });\n *\n *   container.register(collection);\n *\n * @example\n *\n * <caption>Registering one by one</caption>\n *\n *   container.register(collection.http);\n *\n * @group Wrappers\n */\nexport const providers = createProviders<Jimpex>();\n/**\n * An object that can configure/extend the container by registering services and\n * resources.\n *\n * @group Wrappers\n */\nexport type Provider = ReturnType<typeof provider>;\n/**\n * A provider creator is like a provider, but it can also be used as a function, and it\n * expose options for the resources it will configure.\n *\n * @group Wrappers\n */\nexport type ProviderCreator = ReturnType<typeof providerCreator>;\n/**\n * A collection of providers that can be registered one by one, or all at once.\n *\n * @group Wrappers\n */\nexport type Providers = ReturnType<typeof providers>;\n/**\n * A union of all types that can be registered in the provider with a `register` function.\n *\n * @group Wrappers\n */\nexport type ProviderLike = Provider | ProviderCreator | Providers;\n\n// --\n/**\n * The function a controller uses to mount a controller/middleware in the container.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      The route on which the controller will be mounted on.\n * @group Wrappers\n */\nexport type ControllerConnectFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route: string,\n) => Router | ExpressMiddlewareLike;\n\nconst controllerFactory = resourceFactory<ControllerConnectFn>();\n/**\n * Generates a routes controller for the application container to mount.\n *\n * @param connect  A function that will be called the moment the application mounts the\n *                 controller, and that is in charge of registering routes and\n *                 middlewares.\n * @example\n *\n *   const myController = controller((app) => {\n *     const router = app.getRouter();\n *     const ctrl = new MyController();\n *     return router.get('...', ctrl.doSomething()).post('...', ctrl.doSomethingElse());\n *   });\n *\n *   // ...\n *   container.mount('/charo', myController);\n *\n * @group Wrappers\n */\nexport const controller = (connect: ControllerConnectFn) =>\n  controllerFactory('controller', 'connect', connect);\n/**\n * A high order function that generates a controller. It's used on the definitions of a\n * controller creator.\n *\n * @group Wrappers\n */\nexport type ControllerCreatorFn = GenericCurriedFn<ControllerConnectFn>;\nconst controllerCreatorFactory = resourceCreatorFactory<ControllerConnectFn>();\n/**\n * Generates a configurable routes controller for the application to mount. It's\n * configurable because the `creator`, instead of just being sent to the container to\n * mount, it can also be called as a function with custom parameters the controller can\n * receive.\n *\n * @param creator  A function that will generate a controller.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myController = controllerCreator((options = {}) => (app) => {\n *     const router = app.getRouter();\n *     const ctrl = new MyController(options);\n *     return router.get('...', ctrl.doSomething()).post('...', ctrl.doSomethingElse());\n *   });\n *\n *   // ...\n *   container.mount('/charo', myController);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.mount('/pili', myController({ foo: 'bar' }));\n *\n * @group Wrappers\n */\nexport const controllerCreator = <CreatorFn extends ControllerCreatorFn>(\n  creator: CreatorFn,\n) => controllerCreatorFactory('controller', 'connect', creator);\n/**\n * A resource that will define middlewares for specific routes.\n *\n * @group Wrappers\n */\nexport type Controller = ReturnType<typeof controller>;\n/**\n * A controller creator is like a controller, but it can also be used as a function, and\n * it can receive custom parameters to configure its behavior.\n *\n * @group Wrappers\n */\nexport type ControllerCreator = ReturnType<typeof controllerCreator>;\n\n// --\n/**\n * The function a controller provider uses to configure/extend the container before\n * returning an actual controller.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      The route on which the controller will be mounted on.\n * @group Wrappers\n */\nexport type ControllerProviderRegisterFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route: string,\n) => Controller;\n\nconst controllerProviderFactory = resourceFactory<ControllerProviderRegisterFn>();\n/**\n * Creates a \"controller provider\", which is a controller that can configure/extend the\n * container before the application mounts it.\n *\n * @param register  A function that will be called the moment the application mounts\n *                  the controller provider.\n * @example\n *\n *   class MyController {}\n *   const myControllerProvider = controllerProvider((app) => {\n *     app.set('myController', () => new MyController());\n *     return controller(() => {\n *       const ctrl = app.get<MyController>('myController');\n *       const router = app.getRouter();\n *       return router.get('/', ctrl.doSomething());\n *     });\n *   });\n *\n * @group Wrappers\n */\nexport const controllerProvider = (register: ControllerProviderRegisterFn) =>\n  controllerProviderFactory('provider', 'register', register);\n/**\n * A high order function that generates a controller provider. It's used on the\n * definitions of a controller provider creator.\n *\n * @group Wrappers\n */\nexport type ControllerProviderCreatorFn = GenericCurriedFn<ControllerProviderRegisterFn>;\nconst controllerProviderCreatorFactory =\n  resourceCreatorFactory<ControllerProviderRegisterFn>();\n/**\n * Generates a configurable controller provider for the application to mount. This is a\n * mix of a controller creator and a controller provider: it gives you the flexibility of\n * the creator, with the resources of the provider.\n *\n * @param creator  A function that will generate a controller provider.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   class MyController {}\n *   const myControllerProvider = controllerProviderCreator(\n *     ({ serviceName = 'myController' }) =>\n *       (app) => {\n *         app.set(serviceName, () => new MyController());\n *         return controller(() => {\n *           const ctrl = app.get<MyController>(serviceName);\n *           const router = app.getRouter();\n *           return router.get('/', ctrl.doSomething());\n *         });\n *       },\n *   );\n *\n *   // ...\n *   container.mount('/charo', myControllerProvider);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.mount('/pili', myControllerProvider({ serviceName: 'something' }));\n *\n * @group Wrappers\n */\nexport const controllerProviderCreator = <CreatorFn extends ControllerProviderCreatorFn>(\n  creator: CreatorFn,\n) => controllerProviderCreatorFactory('provider', 'register', creator);\n/**\n * A special kind of controller that can be used to configure/extend the container before\n * returning an actual controller.\n *\n * @group Wrappers\n */\nexport type ControllerProvider = ReturnType<typeof controllerProvider>;\n/**\n * A \"creator version\" of a controller provider: a controller that can be used to\n * configure/extend the container before returning an actual controller, but that can also\n * be called as a function, and it can receive custom parameters to configure its\n * behavior.\n *\n * @group Wrappers\n */\nexport type ControllerProviderCreator = ReturnType<typeof controllerProviderCreator>;\n\n// --\n/**\n * The function a middleware uses to mount itself in the container.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      This is optional because the implementation can use it as a\n *                   \"global widdleware\", or for a specific route.\n * @returns The resource can choose to be enabled or not by returning the function, or\n *          `undefined`.\n * @group Wrappers\n */\nexport type MiddlewareConnectFn = <ContainerType extends Jimpex = Jimpex>(\n  app: ContainerType,\n  route?: string,\n) => Router | ExpressMiddlewareLike | undefined;\n\nconst middlewareFactory = resourceFactory<MiddlewareConnectFn>();\n/**\n * Generates a middleware for the application container to mount.\n *\n * @param connect  A function that will be called the moment the application tries to\n *                 mount the middleware.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myMiddleware = controller((app) => {\n *     const responsesBuilder = app.get<ResponsesBuilder>('responsesBuilder');\n *     return (_, res) => {\n *       responsesBuilder.json({ res, data: { hello: 'world' } });\n *     };\n *   });\n *\n *   // ...\n *   container.use(myMiddleware);\n *\n * @example\n *\n * <caption>On a specific route</caption>\n *\n *   container.mount('/charo', myMiddleware);\n *\n * @group Wrappers\n */\nexport const middleware = (connect: MiddlewareConnectFn) =>\n  middlewareFactory('middleware', 'connect', connect);\n/**\n * A high order function that generates a middleware. It's used on the definitions of a\n * middleware creator.\n *\n * @group Wrappers\n */\nexport type MiddlewareCreatorFn = GenericCurriedFn<MiddlewareConnectFn>;\nconst middlewareCreatorFactory = resourceCreatorFactory<MiddlewareConnectFn>();\n/**\n * Generates a configurable middleware for the application to use. It's configurable\n * because the `creator`, instead of just being sent to the container to mount, it can\n * also be called as a function with custom parameters the middleware can receive.\n *\n * @param creator  A function that will generate a middleware.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myMiddleware = middlewareCreator((options = {}) => (app) => {\n *     const message = options.message || 'Hello Charo!';\n *     const responsesBuilder = app.get<ResponsesBuilder>('responsesBuilder');\n *     return (_, res) => {\n *       responsesBuilder.json({ res, data: { message } });\n *     };\n *   });\n *\n *   // ...\n *   container.use(myMiddleware);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.use(myMiddleware({ message: 'Hello Pili!' }));\n *\n * @group Wrappers\n */\nexport const middlewareCreator = <CreatorFn extends MiddlewareCreatorFn>(\n  creator: CreatorFn,\n) => middlewareCreatorFactory('middleware', 'connect', creator);\n/**\n * A resource that will define middlewares the application can use.\n *\n * @group Wrappers\n */\nexport type Middleware = ReturnType<typeof middleware>;\n/**\n * A middleware creator is like a middleware, but i can also be used as a function, and it\n * can receive custom parameters to configure its behavior.\n *\n * @group Wrappers\n */\nexport type MiddlewareCreator = ReturnType<typeof middlewareCreator>;\n\n// --\n/**\n * The function a middelware provider uses to configure/extend the container before\n * returning an actual middleware.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      This is available only in the case the middleware is mounted on a\n *                   specific route.\n * @group Wrappers\n */\nexport type MiddlewareProviderRegisterFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route?: string,\n) => Middleware;\nconst middlewareProviderFactory = resourceFactory<MiddlewareProviderRegisterFn>();\n/**\n * Creates a \"middleware provider\", which is a middleware that can configure/extend the\n * container before the application uses it.\n *\n * @param register  A function that will be called the moment the application uses the\n *                  middleware provider.\n * @example\n *\n *   class MyServiceWithMiddleware {\n *     constructor(private readonly responsesBuilder: ResponsesBuilder) {}\n *     getMiddleware() {\n *       return (_, res) => {\n *         this.responsesBuilder.json({ res, data: { message } });\n *       };\n *     }\n *   }\n *\n *   const myMiddlewareProvider = middlewareProvider((app) => {\n *     app.set(\n *       'myMiddleware',\n *       () => new MyServiceWithMiddleware(app.get('responsesBuilder')),\n *     );\n *     return middleware(() =>\n *       app.get<MyServiceWithMiddleware>('myMiddleware').getMiddleware(),\n *     );\n *   });\n *\n * @group Wrappers\n */\nexport const middlewareProvider = (register: MiddlewareProviderRegisterFn) =>\n  middlewareProviderFactory('provider', 'register', register);\n/**\n * A high order function that generates a middleware provider. It's used on the\n * definitions of a middleware provider creator.\n *\n * @group Wrappers\n */\nexport type MiddlewareProviderCreatorFn = GenericCurriedFn<MiddlewareProviderRegisterFn>;\nconst middlewareProviderCreatorFactory =\n  resourceCreatorFactory<MiddlewareProviderRegisterFn>();\n/**\n * Generates a configurable middleware provider for the application to use. This is a mix\n * of a middleware creator and a middleware provider: it gives you the flexibility of the\n * creator, with the resources of the provider.\n *\n * @param creator  A function that will generate a middleware provider.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   class MyServiceWithMiddleware {\n *     constructor(private readonly responsesBuilder: ResponsesBuilder) {}\n *     getMiddleware() {\n *       return (_, res) => {\n *         this.responsesBuilder.json({ res, data: { message } });\n *       };\n *     }\n *   }\n *   const myMiddlewareProvider = middlewareProviderCreator(\n *     ({ serviceName = 'myMiddleware' }) =>\n *       (app) => {\n *         app.set(\n *           serviceName,\n *           () => new MyServiceWithMiddleware(app.get('responsesBuilder')),\n *         );\n *         return middleware(() =>\n *           app.get<MyServiceWithMiddleware>(serviceName).getMiddleware(),\n *         );\n *       },\n *   );\n *\n *   // ...\n *   container.use(myMiddlewareProvider);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.use(myMiddlewareProvider({ serviceName: 'something' }));\n *\n * @group Wrappers\n */\nexport const middlewareProviderCreator = <CreatorFn extends MiddlewareProviderCreatorFn>(\n  creator: CreatorFn,\n) => middlewareProviderCreatorFactory('provider', 'register', creator);\n/**\n * A special kind of middleware that can be used to configure/extend the container before\n * returning an actual middleware.\n *\n * @group Wrappers\n */\nexport type MiddlewareProvider = ReturnType<typeof middlewareProvider>;\n/**\n * A \"creator version\" of a middleware provider: a middleware that can be used to\n * configure/extend the container before returning an actual middleware, but that can also\n * be called as a function, and it can receive custom parameters to configure its\n * behavior.\n *\n * @group Wrappers\n */\nexport type MiddlewareProviderCreator = ReturnType<typeof middlewareProviderCreator>;\n\n// --\n/**\n * A union types of the different kinds of middlewares that can be used by the\n * application.\n *\n * @group Wrappers\n */\nexport type MiddlewareLike =\n  | NoStringIndex<Middleware>\n  | NoStringIndex<MiddlewareProvider>\n  | ExpressMiddlewareLike;\n/**\n * A union types of the different kinds of controllers that can be mounted by the\n * application.\n *\n * @group Wrappers\n */\nexport type ControllerLike =\n  | NoStringIndex<Controller>\n  | NoStringIndex<ControllerProvider>\n  | MiddlewareLike;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAQO;AAsBA,MAAM,eAAW,8BAAuB;AA8BxC,MAAM,sBAAkB,qCAA8B;AAuBtD,MAAM,gBAAY,+BAAwB;AAyCjD,MAAM,wBAAoB,+BAAqC;AAoBxD,MAAM,aAAa,CAAC,YACzB,kBAAkB,cAAc,WAAW,OAAO;AAQpD,MAAM,+BAA2B,sCAA4C;AA6BtE,MAAM,oBAAoB,CAC/B,YACG,yBAAyB,cAAc,WAAW,OAAO;AA6B9D,MAAM,gCAA4B,+BAA8C;AAqBzE,MAAM,qBAAqB,CAAC,aACjC,0BAA0B,YAAY,YAAY,QAAQ;AAQ5D,MAAM,uCACJ,sCAAqD;AAmChD,MAAM,4BAA4B,CACvC,YACG,iCAAiC,YAAY,YAAY,OAAO;AAkCrE,MAAM,wBAAoB,+BAAqC;AA4BxD,MAAM,aAAa,CAAC,YACzB,kBAAkB,cAAc,WAAW,OAAO;AAQpD,MAAM,+BAA2B,sCAA4C;AA8BtE,MAAM,oBAAoB,CAC/B,YACG,yBAAyB,cAAc,WAAW,OAAO;AA6B9D,MAAM,gCAA4B,+BAA8C;AA8BzE,MAAM,qBAAqB,CAAC,aACjC,0BAA0B,YAAY,YAAY,QAAQ;AAQ5D,MAAM,uCACJ,sCAAqD;AA2ChD,MAAM,4BAA4B,CACvC,YACG,iCAAiC,YAAY,YAAY,OAAO;","names":[]}
+{"version":3,"sources":["../../src/utils/wrappers.ts"],"sourcesContent":["import {\n  createProvider,\n  createProviderCreator,\n  createProviders,\n  resourceFactory,\n  type ProviderRegisterFn as OriginalProviderRegisterFn,\n  type GenericCurriedFn,\n  resourceCreatorFactory,\n} from '@homer0/jimple';\nimport type { Jimpex } from '../app/index.js';\nimport type { Router, ExpressMiddlewareLike, NoStringIndex } from '../types/index.js';\n/**\n * The function a provider uses to configure a resource in the container.\n *\n * @group Wrappers\n */\nexport type ProviderRegisterFn = OriginalProviderRegisterFn<Jimpex>;\n/**\n * Creates an object that can configure/extend the container by registering services and\n * resources.\n *\n * @example\n *\n *   class APIClient {}\n *   const apiClientProvider = provider((app) => {\n *     app.set('apiClient', () => new APIClient());\n *   });\n *\n * @group Wrappers\n */\nexport const provider = createProvider<Jimpex>();\n/**\n * Creates an object like a provider, but that it can also be used as a function, as it\n * normally expose options for the resources it will configure.\n *\n * @example\n *\n * <caption>Registering as a common provider</caption>\n *\n *   const apiClientProvider = providerCreator(\n *     ({ serviceName = 'apiClient' }) =>\n *       (app) => {\n *         app.set(serviceName, () => new APIClient());\n *       },\n *   );\n *\n *   container.register(apiClientProvider);\n *\n * @example\n *\n * <caption>Registering a created provider</caption>\n *\n *   container.register(\n *     apiClientProvider({\n *       serviceName: 'myApiClient',\n *     }),\n *   );\n *\n * @group Wrappers\n */\nexport const providerCreator = createProviderCreator<Jimpex>();\n/**\n * Creates a collection of providers that can be registered one by one, or all at once.\n *\n * @example\n *\n * <caption>Registering all the providers at once</caption>\n *\n *   const collection = providers({\n *     apiClient: apiClientProvider,\n *     http: httpProvider,\n *   });\n *\n *   container.register(collection);\n *\n * @example\n *\n * <caption>Registering one by one</caption>\n *\n *   container.register(collection.http);\n *\n * @group Wrappers\n */\nexport const providers = createProviders<Jimpex>();\n/**\n * An object that can configure/extend the container by registering services and\n * resources.\n *\n * @group Wrappers\n */\nexport type Provider = ReturnType<typeof provider>;\n/**\n * A provider creator is like a provider, but it can also be used as a function, and it\n * expose options for the resources it will configure.\n *\n * @group Wrappers\n */\nexport type ProviderCreator = ReturnType<typeof providerCreator>;\n/**\n * A collection of providers that can be registered one by one, or all at once.\n *\n * @group Wrappers\n */\nexport type Providers = ReturnType<typeof providers>;\n/**\n * A union of all types that can be registered in the provider with a `register` function.\n *\n * @group Wrappers\n */\nexport type ProviderLike = Provider | ProviderCreator | Providers;\n\n// --\n/**\n * The function a controller uses to mount a controller/middleware in the container.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      The route on which the controller will be mounted on.\n * @group Wrappers\n */\nexport type ControllerConnectFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route: string,\n) => Router | ExpressMiddlewareLike;\n\nconst controllerFactory = resourceFactory<ControllerConnectFn>();\n/**\n * Generates a routes controller for the application container to mount.\n *\n * @param connect  A function that will be called the moment the application mounts the\n *                 controller, and that is in charge of registering routes and\n *                 middlewares.\n * @example\n *\n *   const myController = controller((app) => {\n *     const router = app.getRouter();\n *     const ctrl = new MyController();\n *     return router.get('...', ctrl.doSomething()).post('...', ctrl.doSomethingElse());\n *   });\n *\n *   // ...\n *   container.mount('/charo', myController);\n *\n * @group Wrappers\n */\nexport const controller = (connect: ControllerConnectFn) =>\n  controllerFactory('controller', 'connect', connect);\n/**\n * A high order function that generates a controller. It's used on the definitions of a\n * controller creator.\n *\n * @group Wrappers\n */\nexport type ControllerCreatorFn = GenericCurriedFn<ControllerConnectFn>;\nconst controllerCreatorFactory = resourceCreatorFactory<ControllerConnectFn>();\n/**\n * Generates a configurable routes controller for the application to mount. It's\n * configurable because the `creator`, instead of just being sent to the container to\n * mount, it can also be called as a function with custom parameters the controller can\n * receive.\n *\n * @param creator  A function that will generate a controller.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myController = controllerCreator((options = {}) => (app) => {\n *     const router = app.getRouter();\n *     const ctrl = new MyController(options);\n *     return router.get('...', ctrl.doSomething()).post('...', ctrl.doSomethingElse());\n *   });\n *\n *   // ...\n *   container.mount('/charo', myController);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.mount('/pili', myController({ foo: 'bar' }));\n *\n * @group Wrappers\n */\nexport const controllerCreator = <CreatorFn extends ControllerCreatorFn>(\n  creator: CreatorFn,\n) => controllerCreatorFactory('controller', 'connect', creator);\n/**\n * A resource that will define middlewares for specific routes.\n *\n * @group Wrappers\n */\nexport type Controller = ReturnType<typeof controller>;\n/**\n * A controller creator is like a controller, but it can also be used as a function, and\n * it can receive custom parameters to configure its behavior.\n *\n * @group Wrappers\n */\nexport type ControllerCreator = ReturnType<typeof controllerCreator>;\n\n// --\n/**\n * The function a controller provider uses to configure/extend the container before\n * returning an actual controller.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      The route on which the controller will be mounted on.\n * @group Wrappers\n */\nexport type ControllerProviderRegisterFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route: string,\n) => Controller;\n\nconst controllerProviderFactory = resourceFactory<ControllerProviderRegisterFn>();\n/**\n * Creates a \"controller provider\", which is a controller that can configure/extend the\n * container before the application mounts it.\n *\n * @param register  A function that will be called the moment the application mounts\n *                  the controller provider.\n * @example\n *\n *   class MyController {}\n *   const myControllerProvider = controllerProvider((app) => {\n *     app.set('myController', () => new MyController());\n *     return controller(() => {\n *       const ctrl = app.get<MyController>('myController');\n *       const router = app.getRouter();\n *       return router.get('/', ctrl.doSomething());\n *     });\n *   });\n *\n * @group Wrappers\n */\nexport const controllerProvider = (register: ControllerProviderRegisterFn) =>\n  controllerProviderFactory('provider', 'register', register);\n/**\n * A high order function that generates a controller provider. It's used on the\n * definitions of a controller provider creator.\n *\n * @group Wrappers\n */\nexport type ControllerProviderCreatorFn = GenericCurriedFn<ControllerProviderRegisterFn>;\nconst controllerProviderCreatorFactory =\n  resourceCreatorFactory<ControllerProviderRegisterFn>();\n/**\n * Generates a configurable controller provider for the application to mount. This is a\n * mix of a controller creator and a controller provider: it gives you the flexibility of\n * the creator, with the resources of the provider.\n *\n * @param creator  A function that will generate a controller provider.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   class MyController {}\n *   const myControllerProvider = controllerProviderCreator(\n *     ({ serviceName = 'myController' }) =>\n *       (app) => {\n *         app.set(serviceName, () => new MyController());\n *         return controller(() => {\n *           const ctrl = app.get<MyController>(serviceName);\n *           const router = app.getRouter();\n *           return router.get('/', ctrl.doSomething());\n *         });\n *       },\n *   );\n *\n *   // ...\n *   container.mount('/charo', myControllerProvider);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.mount('/pili', myControllerProvider({ serviceName: 'something' }));\n *\n * @group Wrappers\n */\nexport const controllerProviderCreator = <CreatorFn extends ControllerProviderCreatorFn>(\n  creator: CreatorFn,\n) => controllerProviderCreatorFactory('provider', 'register', creator);\n/**\n * A special kind of controller that can be used to configure/extend the container before\n * returning an actual controller.\n *\n * @group Wrappers\n */\nexport type ControllerProvider = ReturnType<typeof controllerProvider>;\n/**\n * A \"creator version\" of a controller provider: a controller that can be used to\n * configure/extend the container before returning an actual controller, but that can also\n * be called as a function, and it can receive custom parameters to configure its\n * behavior.\n *\n * @group Wrappers\n */\nexport type ControllerProviderCreator = ReturnType<typeof controllerProviderCreator>;\n\n// --\n/**\n * The function a middleware uses to mount itself in the container.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      This is optional because the implementation can use it as a\n *                   \"global middleware\", or for a specific route.\n * @returns The resource can choose to be enabled or not by returning the function,\n *          or `undefined`.\n * @group Wrappers\n */\nexport type MiddlewareConnectFn = <ContainerType extends Jimpex = Jimpex>(\n  app: ContainerType,\n  route?: string,\n) => Router | ExpressMiddlewareLike | undefined;\n\nconst middlewareFactory = resourceFactory<MiddlewareConnectFn>();\n/**\n * Generates a middleware for the application container to mount.\n *\n * @param connect  A function that will be called the moment the application tries to\n *                 mount the middleware.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myMiddleware = controller((app) => {\n *     const responsesBuilder = app.get<ResponsesBuilder>('responsesBuilder');\n *     return (_, res) => {\n *       responsesBuilder.json({ res, data: { hello: 'world' } });\n *     };\n *   });\n *\n *   // ...\n *   container.use(myMiddleware);\n *\n * @example\n *\n * <caption>On a specific route</caption>\n *\n *   container.mount('/charo', myMiddleware);\n *\n * @group Wrappers\n */\nexport const middleware = (connect: MiddlewareConnectFn) =>\n  middlewareFactory('middleware', 'connect', connect);\n/**\n * A high order function that generates a middleware. It's used on the definitions of a\n * middleware creator.\n *\n * @group Wrappers\n */\nexport type MiddlewareCreatorFn = GenericCurriedFn<MiddlewareConnectFn>;\nconst middlewareCreatorFactory = resourceCreatorFactory<MiddlewareConnectFn>();\n/**\n * Generates a configurable middleware for the application to use. It's configurable\n * because the `creator`, instead of just being sent to the container to mount, it can\n * also be called as a function with custom parameters the middleware can receive.\n *\n * @param creator  A function that will generate a middleware.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   const myMiddleware = middlewareCreator((options = {}) => (app) => {\n *     const message = options.message || 'Hello Charo!';\n *     const responsesBuilder = app.get<ResponsesBuilder>('responsesBuilder');\n *     return (_, res) => {\n *       responsesBuilder.json({ res, data: { message } });\n *     };\n *   });\n *\n *   // ...\n *   container.use(myMiddleware);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.use(myMiddleware({ message: 'Hello Pili!' }));\n *\n * @group Wrappers\n */\nexport const middlewareCreator = <CreatorFn extends MiddlewareCreatorFn>(\n  creator: CreatorFn,\n) => middlewareCreatorFactory('middleware', 'connect', creator);\n/**\n * A resource that will define middlewares the application can use.\n *\n * @group Wrappers\n */\nexport type Middleware = ReturnType<typeof middleware>;\n/**\n * A middleware creator is like a middleware, but i can also be used as a function, and it\n * can receive custom parameters to configure its behavior.\n *\n * @group Wrappers\n */\nexport type MiddlewareCreator = ReturnType<typeof middlewareCreator>;\n\n// --\n/**\n * The function a middleware provider uses to configure/extend the container before\n * returning an actual middleware.\n *\n * @param container  The reference to the Jimpex container.\n * @param route      This is available only in the case the middleware is mounted on a\n *                   specific route.\n * @group Wrappers\n */\nexport type MiddlewareProviderRegisterFn = <ContainerType extends Jimpex = Jimpex>(\n  container: ContainerType,\n  route?: string,\n) => Middleware;\nconst middlewareProviderFactory = resourceFactory<MiddlewareProviderRegisterFn>();\n/**\n * Creates a \"middleware provider\", which is a middleware that can configure/extend the\n * container before the application uses it.\n *\n * @param register  A function that will be called the moment the application uses the\n *                  middleware provider.\n * @example\n *\n *   class MyServiceWithMiddleware {\n *     constructor(private readonly responsesBuilder: ResponsesBuilder) {}\n *     getMiddleware() {\n *       return (_, res) => {\n *         this.responsesBuilder.json({ res, data: { message } });\n *       };\n *     }\n *   }\n *\n *   const myMiddlewareProvider = middlewareProvider((app) => {\n *     app.set(\n *       'myMiddleware',\n *       () => new MyServiceWithMiddleware(app.get('responsesBuilder')),\n *     );\n *     return middleware(() =>\n *       app.get<MyServiceWithMiddleware>('myMiddleware').getMiddleware(),\n *     );\n *   });\n *\n * @group Wrappers\n */\nexport const middlewareProvider = (register: MiddlewareProviderRegisterFn) =>\n  middlewareProviderFactory('provider', 'register', register);\n/**\n * A high order function that generates a middleware provider. It's used on the\n * definitions of a middleware provider creator.\n *\n * @group Wrappers\n */\nexport type MiddlewareProviderCreatorFn = GenericCurriedFn<MiddlewareProviderRegisterFn>;\nconst middlewareProviderCreatorFactory =\n  resourceCreatorFactory<MiddlewareProviderRegisterFn>();\n/**\n * Generates a configurable middleware provider for the application to use. This is a mix\n * of a middleware creator and a middleware provider: it gives you the flexibility of the\n * creator, with the resources of the provider.\n *\n * @param creator  A function that will generate a middleware provider.\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   class MyServiceWithMiddleware {\n *     constructor(private readonly responsesBuilder: ResponsesBuilder) {}\n *     getMiddleware() {\n *       return (_, res) => {\n *         this.responsesBuilder.json({ res, data: { message } });\n *       };\n *     }\n *   }\n *   const myMiddlewareProvider = middlewareProviderCreator(\n *     ({ serviceName = 'myMiddleware' }) =>\n *       (app) => {\n *         app.set(\n *           serviceName,\n *           () => new MyServiceWithMiddleware(app.get('responsesBuilder')),\n *         );\n *         return middleware(() =>\n *           app.get<MyServiceWithMiddleware>(serviceName).getMiddleware(),\n *         );\n *       },\n *   );\n *\n *   // ...\n *   container.use(myMiddlewareProvider);\n *\n * @example\n *\n * <caption>Custom parameters</caption>\n *\n *   container.use(myMiddlewareProvider({ serviceName: 'something' }));\n *\n * @group Wrappers\n */\nexport const middlewareProviderCreator = <CreatorFn extends MiddlewareProviderCreatorFn>(\n  creator: CreatorFn,\n) => middlewareProviderCreatorFactory('provider', 'register', creator);\n/**\n * A special kind of middleware that can be used to configure/extend the container before\n * returning an actual middleware.\n *\n * @group Wrappers\n */\nexport type MiddlewareProvider = ReturnType<typeof middlewareProvider>;\n/**\n * A \"creator version\" of a middleware provider: a middleware that can be used to\n * configure/extend the container before returning an actual middleware, but that can also\n * be called as a function, and it can receive custom parameters to configure its\n * behavior.\n *\n * @group Wrappers\n */\nexport type MiddlewareProviderCreator = ReturnType<typeof middlewareProviderCreator>;\n\n// --\n/**\n * A union types of the different kinds of middlewares that can be used by the\n * application.\n *\n * @group Wrappers\n */\nexport type MiddlewareLike =\n  | NoStringIndex<Middleware>\n  | NoStringIndex<MiddlewareProvider>\n  | ExpressMiddlewareLike;\n/**\n * A union types of the different kinds of controllers that can be mounted by the\n * application.\n *\n * @group Wrappers\n */\nexport type ControllerLike =\n  | NoStringIndex<Controller>\n  | NoStringIndex<ControllerProvider>\n  | MiddlewareLike;\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAGA;AAAA,OACK;AAsBA,MAAM,WAAW,eAAuB;AA8BxC,MAAM,kBAAkB,sBAA8B;AAuBtD,MAAM,YAAY,gBAAwB;AAyCjD,MAAM,oBAAoB,gBAAqC;AAoBxD,MAAM,aAAa,CAAC,YACzB,kBAAkB,cAAc,WAAW,OAAO;AAQpD,MAAM,2BAA2B,uBAA4C;AA6BtE,MAAM,oBAAoB,CAC/B,YACG,yBAAyB,cAAc,WAAW,OAAO;AA6B9D,MAAM,4BAA4B,gBAA8C;AAqBzE,MAAM,qBAAqB,CAAC,aACjC,0BAA0B,YAAY,YAAY,QAAQ;AAQ5D,MAAM,mCACJ,uBAAqD;AAmChD,MAAM,4BAA4B,CACvC,YACG,iCAAiC,YAAY,YAAY,OAAO;AAkCrE,MAAM,oBAAoB,gBAAqC;AA4BxD,MAAM,aAAa,CAAC,YACzB,kBAAkB,cAAc,WAAW,OAAO;AAQpD,MAAM,2BAA2B,uBAA4C;AA8BtE,MAAM,oBAAoB,CAC/B,YACG,yBAAyB,cAAc,WAAW,OAAO;AA6B9D,MAAM,4BAA4B,gBAA8C;AA8BzE,MAAM,qBAAqB,CAAC,aACjC,0BAA0B,YAAY,YAAY,QAAQ;AAQ5D,MAAM,mCACJ,uBAAqD;AA2ChD,MAAM,4BAA4B,CACvC,YACG,iCAAiC,YAAY,YAAY,OAAO;","names":[]}

package/eslint.config.js

@@ -0,0 +1,19 @@
+import { defineConfig } from 'eslint/config';
+import { createConfig } from '@homer0/eslint-plugin/create';
+
+export default defineConfig([
+  createConfig({
+    importUrl: import.meta.url,
+    ignores: ['tests/**'],
+    configs: ['node-ts-with-prettier'],
+  }),
+  createConfig({
+    importUrl: import.meta.url,
+    files: 'all-inside:./tests',
+    configs: ['node-ts-tests-with-prettier'],
+    tsConfigPath: './tests',
+    rules: {
+      'no-use-before-define': 'off', // for global vi
+    },
+  }),
+]);

package/examples/basic/app.ts

@@ -1,7 +1,7 @@
-import { jimpex, healthController, fastHTMLMiddleware } from '../../src';
-import { dateServiceProvider } from './service';
-import { dateMiddleware } from './middleware';
-import { dateController } from './controller';
+import { jimpex, healthController, fastHTMLMiddleware } from '../../src/index.js';
+import { dateServiceProvider } from './service.js';
+import { dateMiddleware } from './middleware.js';
+import { dateController } from './controller.js';
 
 const app = jimpex();
 app.register(dateServiceProvider);

package/examples/basic/controller.ts

@@ -3,8 +3,8 @@ import {
   type ExpressMiddleware,
   type ResponsesBuilder,
   type Router,
-} from '../../src';
-import type { DateService } from './service';
+} from '../../src/index.js';
+import type { DateService } from './service.js';
 
 class DateController {
   constructor(

package/examples/basic/index.ts

@@ -1,7 +1,7 @@
-import { jimpex, healthController, fastHTMLMiddleware } from '../../src';
-import { dateServiceProvider } from './service';
-import { dateMiddleware } from './middleware';
-import { dateController } from './controller';
+import { jimpex, healthController, fastHTMLMiddleware } from '../../src/index.js';
+import { dateServiceProvider } from './service.js';
+import { dateMiddleware } from './middleware.js';
+import { dateController } from './controller.js';
 
 const PORT = 2509;
 const app = jimpex();

package/examples/basic/middleware.ts

@@ -1,5 +1,5 @@
-import { middleware, type ExpressMiddleware, type Logger } from '../../src';
-import type { DateService } from './service';
+import { middleware, type ExpressMiddleware, type Logger } from '../../src/index.js';
+import type { DateService } from './service.js';
 
 export const dateMiddleware = middleware((app) => {
   const logger = app.get<Logger>('logger');

package/examples/basic/service.ts

@@ -1,4 +1,4 @@
-import { provider } from '../../src';
+import { provider } from '../../src/index.js';
 
 export class DateService {
   now(): Date {

package/package.json

@@ -2,72 +2,84 @@
   "name": "jimpex",
   "description": "Express as dependency injection container.",
   "homepage": "https://homer0.github.io/jimpex/",
-  "version": "10.0.2",
-  "repository": "homer0/jimpex",
+  "version": "11.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/homer0/jimpex.git"
+  },
   "author": "Leonardo Apiwan (@homer0) <me@homer0.com>",
   "license": "MIT",
+  "packageManager": "pnpm@10.11.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
   "dependencies": {
-    "@homer0/api-utils": "^3.0.6",
-    "@homer0/deep-assign": "^3.0.6",
-    "@homer0/deferred": "^3.0.6",
-    "@homer0/env-utils": "^3.0.6",
-    "@homer0/events-hub": "^3.0.6",
-    "@homer0/jimple": "^3.0.6",
-    "@homer0/object-utils": "^3.0.6",
-    "@homer0/package-info": "^3.0.6",
-    "@homer0/path-utils": "^3.0.6",
-    "@homer0/root-file": "^3.0.6",
-    "@homer0/simple-config": "^3.0.6",
-    "@homer0/simple-logger": "^3.0.6",
-    "@homer0/ts-async-import": "^1.1.5",
-    "body-parser": "^1.20.3",
-    "compression": "^1.7.5",
-    "express": "^4.21.1",
-    "mime": "^4.0.4",
-    "multer": "1.4.5-lts.1",
+    "@homer0/api-utils": "^5.0.7",
+    "@homer0/deep-assign": "^5.0.7",
+    "@homer0/deferred": "^5.0.7",
+    "@homer0/env-utils": "^5.0.7",
+    "@homer0/events-hub": "^5.0.7",
+    "@homer0/jimple": "^5.0.7",
+    "@homer0/object-utils": "^5.0.7",
+    "@homer0/package-info": "^5.0.7",
+    "@homer0/path-utils": "^5.0.7",
+    "@homer0/root-file": "^5.0.7",
+    "@homer0/simple-config": "^5.0.7",
+    "@homer0/simple-logger": "^5.0.7",
+    "@homer0/ts-async-import": "^3.0.7",
+    "body-parser": "^2.2.1",
+    "compression": "^1.8.1",
+    "express": "^5.2.1",
+    "mime": "^4.1.0",
+    "multer": "2.0.2",
     "node-fetch": "^3.3.2",
     "spdy": "^4.0.2",
-    "statuses": "^2.0.1",
+    "statuses": "^2.0.2",
     "urijs": "^1.19.11"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.5.0",
-    "@commitlint/config-conventional": "^19.5.0",
-    "@homer0/eslint-plugin": "^12.0.6",
-    "@homer0/prettier-config": "^1.1.3",
-    "@homer0/prettier-plugin-jsdoc": "^9.1.0",
-    "@homer0/tsconfig": "^1.0.17",
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@homer0/eslint-plugin": "^14.2.2",
+    "@homer0/prettier-config": "^2.0.0",
+    "@homer0/prettier-plugin-jsdoc": "^11.0.1",
+    "@homer0/tsconfig": "^4.1.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@types/body-parser": "^1.19.5",
-    "@types/compression": "^1.7.5",
-    "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.14",
-    "@types/multer": "^1.4.12",
-    "@types/node": "^22.9.0",
+    "@vitest/coverage-istanbul": "^4.0.15",
+    "@types/body-parser": "^1.19.6",
+    "@types/compression": "^1.8.1",
+    "@types/express": "^5.0.6",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^24.10.1",
     "@types/spdy": "^3.4.9",
-    "@types/statuses": "^2.0.5",
-    "@types/urijs": "^1.19.25",
-    "eslint": "^8.57.1",
-    "husky": "^9.1.6",
-    "is-ci": "^3.0.1",
-    "jest": "^29.7.0",
+    "@types/statuses": "^2.0.6",
+    "@types/urijs": "^1.19.26",
+    "eslint": "^9.39.1",
+    "husky": "^9.1.7",
+    "is-ci": "^4.1.0",
     "leasot": "^14.4.0",
-    "lint-staged": "^15.2.10",
-    "semantic-release": "^24.2.0",
-    "ts-jest": "^29.2.5",
+    "lint-staged": "^16.2.7",
+    "semantic-release": "^25.0.2",
     "ts-node-dev": "^2.0.0",
-    "tsup": "^8.3.5",
-    "typedoc": "0.26.11",
-    "typescript": "^5.6.3"
+    "tsup": "^8.5.1",
+    "typedoc": "0.28.15",
+    "typescript": "^5.9.3",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.0.15",
+    "vite-tsconfig-paths": "^5.1.4"
   },
   "engine-strict": true,
   "engines": {
-    "node": ">=18.17 <23"
+    "node": ">=20"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/index.d.ts",
   "lint-staged": {
     "*.{ts,tsx,js,json,css,scss,md}": [
       "prettier --write"

package/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+onlyBuiltDependencies:
+  - '@swc/core'
+  - esbuild
+  - unrs-resolver

package/src/app/index.ts

@@ -1 +1 @@
-export * from './jimpex';
+export * from './jimpex.js';

package/src/app/jimpex.ts

@@ -1,5 +1,5 @@
-import * as path from 'path';
-import fs from 'fs/promises';
+import * as path from 'node:path';
+import fs from 'node:fs/promises';
 import { createServer as createHTTPSServer } from 'https';
 import { Jimple } from '@homer0/jimple';
 import { deepAssignWithOverwrite } from '@homer0/deep-assign';
@@ -14,16 +14,13 @@ import { simpleConfigProvider } from '@homer0/simple-config';
 import compression from 'compression';
 import bodyParser from 'body-parser';
 import multer from 'multer';
-import {
-  createServer as createSpdyServer,
-  type ServerOptions as SpdyServerOptions,
-} from 'spdy';
+import type { ServerOptions as SpdyServerOptions } from 'spdy';
 import express from 'express';
 import {
   commonServicesProvider,
   httpServicesProvider,
   utilsServicesProvider,
-} from '../services';
+} from '../services/index.js';
 import {
   statuses,
   type Controller,
@@ -31,7 +28,7 @@ import {
   type MiddlewareLike,
   type MiddlewareProvider,
   type Middleware,
-} from '../utils';
+} from '../utils/index.js';
 import type {
   DeepPartial,
   Express,
@@ -56,7 +53,8 @@ import type {
   JimpexEventListener,
   JimpexHealthCheckFn,
   Router,
-} from '../types';
+} from '../types/index.js';
+
 /**
  * Jimpex is a mix of Jimple, a Javascript port of Pimple dependency injection container,
  * and Express, one of the most popular web frameworks for Node.
@@ -79,7 +77,7 @@ export class Jimpex extends Jimple {
    */
   protected _configReady: boolean = false;
   /**
-   * A reference to the actuall HTTP the application will use. This can vary depending on
+   * A reference to the actual HTTP the application will use. This can vary depending on
    * whether HTTPS, or HTTP2 are enabled. If HTTPS is not enabled, it will be the same as
    * the `express` property; if HTTPS is enabled, it will be an `https` server; and if
    * HTTP2 is enabled, it will be an `spdy` server.
@@ -106,7 +104,7 @@ export class Jimpex extends Jimple {
   /**
    * @param options  Preferences to customize the application.
    * @param config   The default settings for the configuration service. It's a
-   *                 shortcuit for `options.config.default`
+   *                 short-circuit for `options.config.default`
    */
   constructor(options: DeepPartial<JimpexOptions> = {}, config: unknown = {}) {
     super();
@@ -171,7 +169,7 @@ export class Jimpex extends Jimple {
    * Disables the server TLS validation. Meant to be used for development purposes.
    */
   disableTLSValidation() {
-    // eslint-disable-next-line no-process-env, dot-notation
+    // eslint-disable-next-line n/no-process-env
     process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
     this.logger.warn('TLS validation has been disabled');
   }
@@ -392,7 +390,7 @@ export class Jimpex extends Jimple {
     return this.eventsHub.on(eventName, listener);
   }
   /**
-   * Adds a listener for an application event that will only be execuded once: the first
+   * Adds a listener for an application event that will only be executed once: the first
    * time the event is triggered.
    *
    * @param eventName  The name of the event to listen for.
@@ -408,7 +406,7 @@ export class Jimpex extends Jimple {
     return this.eventsHub.once(eventName, listener);
   }
   /**
-   * Based on the application options, it returns wheter the application is healthy or
+   * Based on the application options, it returns whether the application is healthy or
    * not.
    */
   isHealthy(): ReturnType<JimpexHealthCheckFn> {
@@ -417,7 +415,7 @@ export class Jimpex extends Jimple {
   /**
    * This method is like a "lifecycle method", it gets executed on the constructor right
    * before the "boot step". The idea is for the method to be a helper when the
-   * application is defined by subclassing {@link Jimpex}: the application could register
+   * application is defined by sub-classing {@link Jimpex}: the application could register
    * all important services here and the routes on boot, then, if the implementation needs
    * to access or overwrite a something, it can send `boot: false`, access/register what
    * it needs, and then call `boot()`. That would be impossible for an application without
@@ -426,7 +424,7 @@ export class Jimpex extends Jimple {
   protected _init(): void {}
   /**
    * It generates overwrites for the application options when it gets created. This method
-   * is a helper for when the application is defined by subclassing {@link Jimpex}: It's
+   * is a helper for when the application is defined by sub-classing {@link Jimpex}: It's
    * highly probable that if the application needs to change the default options, it would
    * want to do it right from the class, instead of having to do it on every
    * implementation. A way to do it would be overwriting the constructor and calling
@@ -532,7 +530,7 @@ export class Jimpex extends Jimple {
    * This helper method validates the `path` options in order to register the `app`
    * location in the `pathUtils` service. The `app` location should be the path to where
    * the application executable is located, but due to how ESM works, we can't infer it
-   * from the `module` object, so we need either recieved as the `appPath` setting, or try
+   * from the `module` object, so we need either received as the `appPath` setting, or try
    * to get it from the parent module.
    *
    * @throws If the method should use the path from the parent module, but can't find
@@ -553,8 +551,10 @@ export class Jimpex extends Jimple {
       const stackList = stack.split('\n');
       stackList.shift();
       const parentFromStack = stackList.find((line) => !line.includes(__filename));
+      /* istanbul ignore else  */
       if (parentFromStack) {
-        const parentFile = parentFromStack.replace(/^.*?\s\(([^\s]+):\d+:\d+\)/, '$1');
+        const parentFile = parentFromStack.replace(/^.*?\s\(?([^\s]+):\d+:\d+\)?/, '$1');
+        /* istanbul ignore else  */
         if (parentFile !== parentFromStack) {
           foundPath = true;
           pathUtils.addLocation('app', path.dirname(parentFile));
@@ -703,7 +703,7 @@ export class Jimpex extends Jimple {
    * @returns {Server}
    * @throws {Error} If HTTP2 is enabled but HTTPS is not.
    * @throws {Error} If HTTPS is enabled but there's no `https.credentials` object.
-   * @throws {Error} If HTTPS is enabled and no creadentials are found.
+   * @throws {Error} If HTTPS is enabled and no credentials are found.
    * @access protected
    * @ignore
    */
@@ -739,7 +739,10 @@ export class Jimpex extends Jimple {
         spdy: http2Config.spdy,
       };
 
-      return createSpdyServer(serverOptions, this._express);
+      const spdyModule = await tsAsyncImport<{
+        default: { createServer: (typeof import('spdy'))['createServer'] };
+      }>('spdy');
+      return spdyModule.default.createServer(serverOptions, this._express);
     }
 
     return createHTTPSServer(credentials, this._express);

package/src/controllers/common/config.ts

@@ -1,13 +1,13 @@
-import { controller } from '../../utils';
-import type { ResponsesBuilder } from '../../services';
+import { controller } from '../../utils/index.js';
+import type { ResponsesBuilder } from '../../services/index.js';
 import type {
   Config,
   Response,
   AsyncExpressMiddleware,
   ExpressMiddleware,
-} from '../../types';
+} from '../../types/index.js';
 /**
- * The options to contruct a {@link ConfigController}.
+ * The options to construct a {@link ConfigController}.
  *
  * @group Controllers/Config
  */

package/src/controllers/common/health.ts

@@ -1,6 +1,10 @@
-import { controller, type Statuses } from '../../utils';
-import type { ResponsesBuilder } from '../../services';
-import type { JimpexHealthStatus, Config, AsyncExpressMiddleware } from '../../types';
+import { controller, type Statuses } from '../../utils/index.js';
+import type { ResponsesBuilder } from '../../services/index.js';
+import type {
+  JimpexHealthStatus,
+  Config,
+  AsyncExpressMiddleware,
+} from '../../types/index.js';
 /**
  * A function that will return the health status of the application.
  *
@@ -8,7 +12,7 @@ import type { JimpexHealthStatus, Config, AsyncExpressMiddleware } from '../../t
  */
 export type GetHealthStatus = () => Promise<JimpexHealthStatus>;
 /**
- * The options to contruct a {@link HealthController}.
+ * The options to construct a {@link HealthController}.
  *
  * @group Controllers/Health
  */
@@ -44,7 +48,7 @@ export class HealthController {
    */
   protected readonly _config: Config;
   /**
-   * The uility service to get HTTP status codes.
+   * The utility service to get HTTP status codes.
    */
   protected readonly _statuses: Statuses;
   /**

package/src/controllers/common/index.ts

@@ -1,3 +1,3 @@
-export * from './config';
-export * from './health';
-export * from './statics';
+export * from './config.js';
+export * from './health.js';
+export * from './statics.js';