jimpex 7.0.2 → 8.0.0

package/dist/utils/fns/others.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A utility function that can be used in `.filter` calls to remove `undefined` values and
+ * assert that the type is not longer `undefined`.
+ *
+ * @param value  The value to check.
+ * @template T  The type that is not `undefined`.
+ * @example
+ *
+ *   const arr: (number | undefined)[] = [1, 2, 3, undefined];
+ *   const filtered = arr.filter(notUndefined);
+ *   // filtered = [1, 2, 3] and its type is number[]
+ *
+ * @group Utilities
+ */
+declare const notUndefined: <T>(value: T | undefined) => value is T;
+
+export { notUndefined };

package/dist/utils/fns/others.js

@@ -0,0 +1,29 @@
+"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 others_exports = {};
+__export(others_exports, {
+  notUndefined: () => notUndefined
+});
+module.exports = __toCommonJS(others_exports);
+const notUndefined = (value) => value !== void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notUndefined
+});
+//# sourceMappingURL=others.js.map

package/dist/utils/fns/others.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fns/others.ts"],"sourcesContent":["/**\n * A utility function that can be used in `.filter` calls to remove `undefined` values and\n * assert that the type is not longer `undefined`.\n *\n * @param value  The value to check.\n * @template T  The type that is not `undefined`.\n * @example\n *\n *   const arr: (number | undefined)[] = [1, 2, 3, undefined];\n *   const filtered = arr.filter(notUndefined);\n *   // filtered = [1, 2, 3] and its type is number[]\n *\n * @group Utilities\n */\nexport const notUndefined = <T>(value: T | undefined): value is T => value !== undefined;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,MAAM,eAAe,CAAI,UAAqC,UAAU;","names":[]}

package/dist/utils/fns/routes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Removes any leading slash from a URL.
+ *
+ * @param url  The URL to format.
+ * @group Utilities
+ */
+declare const removeLeadingSlash: (url: string) => string;
+/**
+ * Removes any trailing slash from a URL.
+ *
+ * @param url  The URL to format.
+ * @group Utilities
+ */
+declare const removeTrailingSlash: (url: string) => string;
+/**
+ * Remove any leading and trailing slash from a URL.
+ *
+ * @param url       The URL to format.
+ * @param leading   Whether or not to remove any leading slash.
+ * @param trailing  Whether or not to remove the trailing slash.
+ * @group Utilities
+ */
+declare const removeSlashes: (url: string, leading?: boolean, trailing?: boolean) => string;
+/**
+ * Given a server route definition, this function creates a regular expression to match
+ * it: The expression replaces the routes parameters with placeholders so it can be
+ * compared with real routes.
+ *
+ * @param route          The route from which the expression will be created.
+ * @param leadingSlash   Whether or not the expression should match a leading slash.
+ * @param trailingSlash  Whether or not the expression should match a trailing slash.
+ *                       The reason this is `false` by default is because these
+ *                       expressions are often used to match against incoming requests,
+ *                       and they don't have a trailing slash.
+ * @group Utilities
+ */
+declare const createRouteExpression: (route: string, leadingSlash?: boolean, trailingSlash?: boolean) => RegExp;
+
+export { createRouteExpression, removeLeadingSlash, removeSlashes, removeTrailingSlash };

package/dist/utils/fns/routes.js

@@ -0,0 +1,51 @@
+"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 routes_exports = {};
+__export(routes_exports, {
+  createRouteExpression: () => createRouteExpression,
+  removeLeadingSlash: () => removeLeadingSlash,
+  removeSlashes: () => removeSlashes,
+  removeTrailingSlash: () => removeTrailingSlash
+});
+module.exports = __toCommonJS(routes_exports);
+var import_text = require("./text");
+const removeLeadingSlash = (url) => url.replace(/^\/+/, "");
+const removeTrailingSlash = (url) => url.replace(/\/+$/, "");
+const removeSlashes = (url, leading = true, trailing = true) => {
+  const newUrl = leading ? removeLeadingSlash(url) : url;
+  return trailing ? removeTrailingSlash(newUrl) : newUrl;
+};
+const createRouteExpression = (route, leadingSlash = true, trailingSlash = false) => {
+  let expression = removeSlashes(route).split("/").map((part) => part.startsWith(":") ? "(?:([^\\/]+?))" : (0, import_text.escapeForRegExp)(part)).join("\\/");
+  if (leadingSlash) {
+    expression = `\\/${expression}`;
+  }
+  if (trailingSlash) {
+    expression = `${expression}\\/`;
+  }
+  return new RegExp(expression);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRouteExpression,
+  removeLeadingSlash,
+  removeSlashes,
+  removeTrailingSlash
+});
+//# sourceMappingURL=routes.js.map

package/dist/utils/fns/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fns/routes.ts"],"sourcesContent":["import { escapeForRegExp } from './text';\n\n/**\n * Removes any leading slash from a URL.\n *\n * @param url  The URL to format.\n * @group Utilities\n */\nexport const removeLeadingSlash = (url: string): string => url.replace(/^\\/+/, '');\n/**\n * Removes any trailing slash from a URL.\n *\n * @param url  The URL to format.\n * @group Utilities\n */\nexport const removeTrailingSlash = (url: string): string => url.replace(/\\/+$/, '');\n/**\n * Remove any leading and trailing slash from a URL.\n *\n * @param url       The URL to format.\n * @param leading   Whether or not to remove any leading slash.\n * @param trailing  Whether or not to remove the trailing slash.\n * @group Utilities\n */\nexport const removeSlashes = (\n  url: string,\n  leading: boolean = true,\n  trailing: boolean = true,\n) => {\n  const newUrl = leading ? removeLeadingSlash(url) : url;\n  return trailing ? removeTrailingSlash(newUrl) : newUrl;\n};\n\n/**\n * Given a server route definition, this function creates a regular expression to match\n * it: The expression replaces the routes parameters with placeholders so it can be\n * compared with real routes.\n *\n * @param route          The route from which the expression will be created.\n * @param leadingSlash   Whether or not the expression should match a leading slash.\n * @param trailingSlash  Whether or not the expression should match a trailing slash.\n *                       The reason this is `false` by default is because these\n *                       expressions are often used to match against incoming requests,\n *                       and they don't have a trailing slash.\n * @group Utilities\n */\nexport const createRouteExpression = (\n  route: string,\n  leadingSlash: boolean = true,\n  trailingSlash: boolean = false,\n): RegExp => {\n  let expression = removeSlashes(route)\n    .split('/')\n    .map((part) => (part.startsWith(':') ? '(?:([^\\\\/]+?))' : escapeForRegExp(part)))\n    .join('\\\\/');\n  if (leadingSlash) {\n    expression = `\\\\/${expression}`;\n  }\n  if (trailingSlash) {\n    expression = `${expression}\\\\/`;\n  }\n\n  return new RegExp(expression);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAgC;AAQzB,MAAM,qBAAqB,CAAC,QAAwB,IAAI,QAAQ,QAAQ,EAAE;AAO1E,MAAM,sBAAsB,CAAC,QAAwB,IAAI,QAAQ,QAAQ,EAAE;AAS3E,MAAM,gBAAgB,CAC3B,KACA,UAAmB,MACnB,WAAoB,SACjB;AACH,QAAM,SAAS,UAAU,mBAAmB,GAAG,IAAI;AACnD,SAAO,WAAW,oBAAoB,MAAM,IAAI;AAClD;AAeO,MAAM,wBAAwB,CACnC,OACA,eAAwB,MACxB,gBAAyB,UACd;AACX,MAAI,aAAa,cAAc,KAAK,EACjC,MAAM,GAAG,EACT,IAAI,CAAC,SAAU,KAAK,WAAW,GAAG,IAAI,uBAAmB,6BAAgB,IAAI,CAAE,EAC/E,KAAK,KAAK;AACb,MAAI,cAAc;AAChB,iBAAa,MAAM;AAAA,EACrB;AACA,MAAI,eAAe;AACjB,iBAAa,GAAG;AAAA,EAClB;AAEA,SAAO,IAAI,OAAO,UAAU;AAC9B;","names":[]}

package/dist/utils/fns/statuses.d.ts

@@ -0,0 +1,45 @@
+export { default as statuses } from 'statuses';
+
+/**
+ * The type definitions for the `statuses` library.
+ *
+ * While the library has type definitions, TypeScript throws an error that they can't be
+ * exported, so that's why they are copied in there.
+ */
+type Statuses = {
+    /**
+     * Given a status code, returns the status text, and given a status text, returns the
+     * status code.
+     *
+     * @param code  The status code or status text to look up.
+     * @throws If the status is invalid.
+     */
+    (code: number | string): number | string;
+    /**
+     * A list of all the supported status codes.
+     */
+    codes: number[];
+    /**
+     * A dictionary with the status texts and their corresponding status codes.
+     */
+    code: Record<string, number | undefined>;
+    /**
+     * A dictionary with the status codes and their corresponding status texts, for
+     * responses that expect an empty body.
+     */
+    empty: Record<number, boolean | undefined>;
+    /**
+     * A dictionary with the status codes and their corresponding status texts.
+     */
+    message: Record<number, string | undefined>;
+    /**
+     * A dictionary with status codes for responses that are valid for redirections.
+     */
+    redirect: Record<number, boolean | undefined>;
+    /**
+     * A dictionary with status codes that should be retried.
+     */
+    retry: Record<number, boolean | undefined>;
+};
+
+export { Statuses };

package/dist/utils/fns/statuses.js

@@ -0,0 +1,35 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var statuses_exports = {};
+__export(statuses_exports, {
+  statuses: () => import_statuses.default
+});
+module.exports = __toCommonJS(statuses_exports);
+var import_statuses = __toESM(require("statuses"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  statuses
+});
+//# sourceMappingURL=statuses.js.map

package/dist/utils/fns/statuses.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fns/statuses.ts"],"sourcesContent":["import statuses from 'statuses';\n/**\n * The type definitions for the `statuses` library.\n *\n * While the library has type definitions, TypeScript throws an error that they can't be\n * exported, so that's why they are copied in there.\n */\nexport type Statuses = {\n  /**\n   * Given a status code, returns the status text, and given a status text, returns the\n   * status code.\n   *\n   * @param code  The status code or status text to look up.\n   * @throws If the status is invalid.\n   */\n  (code: number | string): number | string;\n  /**\n   * A list of all the supported status codes.\n   */\n  codes: number[];\n  /**\n   * A dictionary with the status texts and their corresponding status codes.\n   */\n  code: Record<string, number | undefined>;\n  /**\n   * A dictionary with the status codes and their corresponding status texts, for\n   * responses that expect an empty body.\n   */\n  empty: Record<number, boolean | undefined>;\n  /**\n   * A dictionary with the status codes and their corresponding status texts.\n   */\n  message: Record<number, string | undefined>;\n  /**\n   * A dictionary with status codes for responses that are valid for redirections.\n   */\n  redirect: Record<number, boolean | undefined>;\n  /**\n   * A dictionary with status codes that should be retried.\n   */\n  retry: Record<number, boolean | undefined>;\n};\n\nexport { statuses };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,kCAAAA;AAAA;AAAA;AAAA,sBAAqB;","names":["statuses"]}

package/dist/utils/fns/text.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Escapes a string to be used on `new RegExp(...)`.
+ *
+ * @param text  The text to escape.
+ * @group Utilities
+ */
+declare const escapeForRegExp: (text: string) => string;
+
+export { escapeForRegExp };

package/dist/utils/fns/text.js

@@ -0,0 +1,29 @@
+"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 text_exports = {};
+__export(text_exports, {
+  escapeForRegExp: () => escapeForRegExp
+});
+module.exports = __toCommonJS(text_exports);
+const escapeForRegExp = (text) => text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeForRegExp
+});
+//# sourceMappingURL=text.js.map

package/dist/utils/fns/text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fns/text.ts"],"sourcesContent":["/**\n * Escapes a string to be used on `new RegExp(...)`.\n *\n * @param text  The text to escape.\n * @group Utilities\n */\nexport const escapeForRegExp = (text: string): string =>\n  text.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,kBAAkB,CAAC,SAC9B,KAAK,QAAQ,4BAA4B,MAAM;","names":[]}

package/dist/utils/index.d.ts

@@ -0,0 +1,18 @@
+export { notUndefined } from './fns/others.js';
+export { createRouteExpression, removeLeadingSlash, removeSlashes, removeTrailingSlash } from './fns/routes.js';
+export { Statuses } from './fns/statuses.js';
+export { escapeForRegExp } from './fns/text.js';
+export { H as Controller, C as ControllerConnectFn, I as ControllerCreator, F as ControllerCreatorFn, a2 as ControllerLike, O as ControllerProvider, Q as ControllerProviderCreator, M as ControllerProviderCreatorFn, K as ControllerProviderRegisterFn, V as Middleware, R as MiddlewareConnectFn, W as MiddlewareCreator, T as MiddlewareCreatorFn, a1 as MiddlewareLike, $ as MiddlewareProvider, a0 as MiddlewareProviderCreator, Z as MiddlewareProviderCreatorFn, X as MiddlewareProviderRegisterFn, y as Provider, z as ProviderCreator, B as ProviderLike, P as ProviderRegisterFn, A as Providers, D as controller, G as controllerCreator, L as controllerProvider, N as controllerProviderCreator, S as middleware, U as middlewareCreator, Y as middlewareProvider, _ as middlewareProviderCreator, v as provider, w as providerCreator, x as providers } from '../jimpex-7eaee271.js';
+export { default as statuses } from 'statuses';
+import '@homer0/jimple';
+import '@homer0/events-hub';
+import '../types/express.js';
+import 'express';
+import '../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '@homer0/simple-config';
+import '../types/utils.js';
+import '@homer0/simple-logger';

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./fns"), module.exports);
+__reExport(utils_exports, require("./wrappers"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/index.ts"],"sourcesContent":["export * from './fns';\nexport * from './wrappers';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,kBAAd;AACA,0BAAc,uBADd;","names":[]}

package/dist/utils/wrappers.d.ts

@@ -0,0 +1,13 @@
+import '@homer0/jimple';
+export { H as Controller, C as ControllerConnectFn, I as ControllerCreator, F as ControllerCreatorFn, a2 as ControllerLike, O as ControllerProvider, Q as ControllerProviderCreator, M as ControllerProviderCreatorFn, K as ControllerProviderRegisterFn, V as Middleware, R as MiddlewareConnectFn, W as MiddlewareCreator, T as MiddlewareCreatorFn, a1 as MiddlewareLike, $ as MiddlewareProvider, a0 as MiddlewareProviderCreator, Z as MiddlewareProviderCreatorFn, X as MiddlewareProviderRegisterFn, y as Provider, z as ProviderCreator, B as ProviderLike, P as ProviderRegisterFn, A as Providers, D as controller, G as controllerCreator, L as controllerProvider, N as controllerProviderCreator, S as middleware, U as middlewareCreator, Y as middlewareProvider, _ as middlewareProviderCreator, v as provider, w as providerCreator, x as providers } from '../jimpex-7eaee271.js';
+import '../types/express.js';
+import '../types/utils.js';
+import 'express';
+import '@homer0/events-hub';
+import '../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '@homer0/simple-config';
+import '@homer0/simple-logger';

package/dist/utils/wrappers.js

@@ -0,0 +1,68 @@
+"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)();
+const controller = (connect) => controllerFactory("controller", "connect", connect);
+const controllerCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const controllerCreator = (creator) => controllerCreatorFactory("controller", "connect", creator);
+const controllerProviderFactory = (0, import_jimple.resourceFactory)();
+const controllerProvider = (register) => controllerProviderFactory("provider", "register", register);
+const controllerProviderCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const controllerProviderCreator = (creator) => controllerProviderCreatorFactory("provider", "register", creator);
+const middlewareFactory = (0, import_jimple.resourceFactory)();
+const middleware = (connect) => middlewareFactory("middleware", "connect", connect);
+const middlewareCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const middlewareCreator = (creator) => middlewareCreatorFactory("middleware", "connect", creator);
+const middlewareProviderFactory = (0, import_jimple.resourceFactory)();
+const middlewareProvider = (register) => middlewareProviderFactory("provider", "register", register);
+const middlewareProviderCreatorFactory = (0, import_jimple.resourceCreatorFactory)();
+const middlewareProviderCreator = (creator) => middlewareProviderCreatorFactory("provider", "register", creator);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  controller,
+  controllerCreator,
+  controllerProvider,
+  controllerProviderCreator,
+  middleware,
+  middlewareCreator,
+  middlewareProvider,
+  middlewareProviderCreator,
+  provider,
+  providerCreator,
+  providers
+});
+//# sourceMappingURL=wrappers.js.map

package/dist/utils/wrappers.js.map

@@ -0,0 +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":[]}

package/examples/basic/404.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Jimpex - Not found</title>
+</head>
+<body>
+  Nothing here :D
+</body>
+</html>

package/examples/basic/README.md

@@ -0,0 +1,30 @@
+# Jimpex basic example
+
+This is a very small app with one service, one middleware, and one controller.
+
+## Service
+
+The `DateService` only has a `now()` method and returns a new instance of `Date`.
+
+## Middleware
+
+Every time there's an incoming request, the middleware uses the data obtained from the service, to log a message.
+
+## Controller
+
+The controller, mounted on `/date`, has two routes:
+
+- `/` returns the current date.
+- `/info` returns the current date and the current time.
+
+## Other Jimpex features
+
+If you read the `app.ts` file, you'll se a few other features of Jimpex:
+
+### Health controller
+
+This controller is mounted in the root route and just returns a `200` status code.
+
+### Fast HTML middleware
+
+This middleware serves a `404.html` file whenever a request is made for a route that has no controller/middleware mounted.

package/examples/basic/app.ts

@@ -0,0 +1,18 @@
+import { jimpex, healthController, fastHTMLMiddleware } from '../../src';
+import { dateServiceProvider } from './service';
+import { dateMiddleware } from './middleware';
+import { dateController } from './controller';
+
+const app = jimpex();
+app.register(dateServiceProvider);
+
+app.use(dateMiddleware);
+app.mount('/', healthController);
+app.use(
+  fastHTMLMiddleware({
+    file: '404.html',
+  }),
+);
+app.mount('/date', dateController);
+
+export { app };

package/examples/basic/controller.ts

@@ -0,0 +1,45 @@
+import {
+  controller,
+  type ExpressMiddleware,
+  type ResponsesBuilder,
+  type Router,
+} from '../../src';
+import type { DateService } from './service';
+
+class DateController {
+  constructor(
+    private readonly dateService: DateService,
+    private readonly responsesBuilder: ResponsesBuilder,
+  ) {}
+
+  showNow(): ExpressMiddleware {
+    return (_, res) => {
+      this.responsesBuilder.json({
+        res,
+        data: {
+          now: this.dateService.now(),
+        },
+      });
+    };
+  }
+
+  showInfo(): ExpressMiddleware {
+    return (_, res) => {
+      const now = this.dateService.now();
+      const [date, time] = now.toISOString().split('T');
+      this.responsesBuilder.json({
+        res,
+        data: {
+          date,
+          time,
+        },
+      });
+    };
+  }
+}
+
+export const dateController = controller((app) => {
+  const router = app.get<Router>('router');
+  const ctrl = new DateController(app.get('date'), app.get('responsesBuilder'));
+  return router.get('/', ctrl.showNow()).get('/info', ctrl.showInfo());
+});

package/examples/basic/index.ts

@@ -0,0 +1,19 @@
+import { jimpex, healthController, fastHTMLMiddleware } from '../../src';
+import { dateServiceProvider } from './service';
+import { dateMiddleware } from './middleware';
+import { dateController } from './controller';
+
+const PORT = 2509;
+const app = jimpex();
+app.register(dateServiceProvider);
+
+app.use(dateMiddleware);
+app.mount('/', healthController);
+app.use(
+  fastHTMLMiddleware({
+    file: '404.html',
+  }),
+);
+app.mount('/date', dateController);
+
+app.listen(PORT);

package/examples/basic/middleware.ts

@@ -0,0 +1,13 @@
+import { middleware, type ExpressMiddleware, type Logger } from '../../src';
+import type { DateService } from './service';
+
+export const dateMiddleware = middleware((app) => {
+  const logger = app.get<Logger>('logger');
+  const service = app.get<DateService>('date');
+  const mdw: ExpressMiddleware = (_, __, next) => {
+    logger.log(`Request received at ${service.now()}`);
+    next();
+  };
+
+  return mdw;
+});

package/examples/basic/service.ts

@@ -0,0 +1,11 @@
+import { provider } from '../../src';
+
+export class DateService {
+  now(): Date {
+    return new Date();
+  }
+}
+
+export const dateServiceProvider = provider((app) => {
+  app.set('date', () => new DateService());
+});