alien-middleware 0.10.4 → 0.11.0

package/dist/{chunk-FHGDNFTY.js → chunk-ENIXF4Y2.js}

@@ -169,7 +169,10 @@ async function runMiddlewareChain(requestChain, parentContext) {
   return response;
 }
 function createHandler(requestChain) {
-  const handler = runMiddlewareChain.bind(null, requestChain);
+  const handler = runMiddlewareChain.bind(
+    null,
+    requestChain
+  );
   Object.setPrototypeOf(handler, MiddlewareChain.prototype);
   handler[kRequestChain] = requestChain;
   return handler;

package/dist/{index-BK1OAKm-.d.ts → index-Dj_pJd-o.d.ts}

@@ -115,7 +115,7 @@ type RequestContext<TEnv extends object = any, TProperties extends object = neve
  */
 type MiddlewareContext<T extends MiddlewareChain | Middleware[]> = [
     T
-] extends [never] ? RequestContext<{}, never, unknown> : T extends MiddlewareChain ? RequestContext<Env<T>, Properties<T>, Platform<T>> : T extends Middleware[] ? MiddlewareContext<ApplyMiddlewares<T>> : never;
+] extends [never] ? RequestContext<{}, never, unknown> : T extends MiddlewareChain ? RequestContext<Env<T>, Properties<T>, Platform<T>> : T extends Middleware[] ? MiddlewareContext<MiddlewareChain<ApplyMiddlewares<T>>> : never;
 type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>;
 type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
 type ResponseCallback = (response: Response) => Awaitable<Response | void>;
@@ -161,25 +161,18 @@ type MiddlewareInputs<T extends Middleware> = T extends Middleware<infer TEnv, i
 } : never;
 type MiddlewarePlatform<T extends Middleware> = T extends Middleware<any, any, infer TPlatform> ? TPlatform : never;
 /**
- * This applies a middleware to a chain. If the type `TMiddleware` is itself a
+ * This applies a middleware to a chain. If the type `TSecond` is itself a
  * chain, it's treated as a nested chain, which won't leak its plugins into the
  * parent chain.
  *
  * The `TFirst` type is allowed to be `never`, which results in the middleware's
  * output types being used as the request handler's input types.
  */
-type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware> = ApplyMiddlewareOutputs<TFirst, TSecond> extends infer TCurrent extends MiddlewareTypes['current'] ? RequestHandler<{
+type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware> = ApplyMiddlewareOutputs<TFirst, TSecond> extends infer TCurrent extends MiddlewareTypes['current'] ? {
     initial: CastNever<Inputs<TFirst>, MiddlewareInputs<TSecond>>;
     current: TCurrent;
     platform: CastNever<Platform<TFirst>, MiddlewarePlatform<TSecond>>;
-}> : never;
-/**
- * Apply a list of middlewares to an empty middleware chain.
- */
-type ApplyMiddlewares<T extends Middleware[]> = T extends [
-    ...infer TRest extends Middleware[],
-    infer TLast extends Middleware
-] ? ApplyMiddleware<ApplyMiddlewares<TRest>, TLast> : ApplyFirstMiddleware<T[0]>;
+} : never;
 type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     initial: {
         env: {};
@@ -191,12 +184,23 @@ type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     };
     platform: TPlatform;
 }>;
-type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain<MiddlewarePlatform<T>>, T>;
+/**
+ * Convert a `Middleware` type into a `MiddlewareTypes` type.
+ * @internal For similar behavior with public APIs, use `ApplyMiddlewares<[T]>`.
+ */
+type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain<infer TInternal> ? TInternal : ApplyMiddleware<EmptyMiddlewareChain<MiddlewarePlatform<T>>, T>;
+/**
+ * Flatten a list of middlewares into a `MiddlewareTypes` type.
+ */
+type ApplyMiddlewares<T extends Middleware[]> = T extends [
+    ...infer TRest extends Middleware[],
+    infer TLast extends Middleware
+] ? ApplyMiddleware<MiddlewareChain<ApplyMiddlewares<TRest>>, TLast> : ApplyFirstMiddleware<T[0]>;
 type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | (string & {});
-type RouteContext<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<ApplyMiddleware<MiddlewareChain<T['$Router']>, () => {
+type RouteContext<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<MiddlewareChain<ApplyMiddleware<MiddlewareChain<T['$Router']>, () => {
     params: TPathParams;
     method: TMethod;
-}>>;
+}>>>;
 type RouteHandler<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = (context: RouteContext<T, TPathParams, TMethod>) => Awaitable<Response | void>;
 declare class RouterTypes<T extends MiddlewareChain = any> extends Function {
     /** This property won't exist at runtime. It contains type information for inference purposes. */
@@ -229,7 +233,7 @@ declare class MiddlewareChain<T extends MiddlewareTypes = any> {
      *
      * @returns a new `MiddlewareChain` instance
      */
-    use<const TMiddleware extends ExtractMiddleware<this>>(middleware: TMiddleware): ApplyMiddleware<this, TMiddleware>;
+    use<const TMiddleware extends ExtractMiddleware<this>>(middleware: TMiddleware): RequestHandler<ApplyMiddleware<this, TMiddleware>>;
     /**
      * Create a middleware function that encapsulates this middleware chain, so
      * any modifications it makes to the request context are not leaked.
@@ -253,6 +257,6 @@ declare function chain<TEnv extends object = {}, TProperties extends object = {}
     };
     platform: TPlatform;
 }>;
-declare function chain<T extends Middleware | MiddlewareChain>(middleware: T): T extends Middleware ? ApplyFirstMiddleware<T> : T;
+declare function chain<T extends Middleware | MiddlewareChain>(middleware: T): T extends Middleware ? RequestHandler<ApplyFirstMiddleware<T>> : T;
 
-export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, type HattipContext as H, type MiddlewareContext as M, type Router as R, MiddlewareChain as a, type RouteContext as b, type RouteHandler as c, chain as d, type ApplyMiddlewares as e, filterPlatform as f, type EnvAccessor as g, type ExtractMiddleware as h, type Middleware as i, type RequestContext as j, type RequestHandler as k, type RequestMiddleware as l, type RequestPlugin as m, type ResponseCallback as n };
+export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, type HattipContext as H, type MiddlewareContext as M, type Router as R, MiddlewareChain as a, type RouteContext as b, type RouteHandler as c, chain as d, type ApplyMiddlewares as e, filterPlatform as f, type EnvAccessor as g, type ExtractMiddleware as h, type Middleware as i, type MiddlewareTypes as j, type RequestContext as k, type RequestHandler as l, type RequestMiddleware as m, type RequestPlugin as n, type ResponseCallback as o };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { A as ApplyMiddleware, e as ApplyMiddlewares, E as EmptyMiddlewareChain, g as EnvAccessor, h as ExtractMiddleware, H as HattipContext, i as Middleware, a as MiddlewareChain, M as MiddlewareContext, j as RequestContext, k as RequestHandler, l as RequestMiddleware, m as RequestPlugin, n as ResponseCallback, d as chain, f as filterPlatform } from './index-BK1OAKm-.js';
+export { A as ApplyMiddleware, e as ApplyMiddlewares, E as EmptyMiddlewareChain, g as EnvAccessor, h as ExtractMiddleware, H as HattipContext, i as Middleware, a as MiddlewareChain, M as MiddlewareContext, j as MiddlewareTypes, k as RequestContext, l as RequestHandler, m as RequestMiddleware, n as RequestPlugin, o as ResponseCallback, d as chain, f as filterPlatform } from './index-Dj_pJd-o.js';
 import '@hattip/core';
 import 'pathic';

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   MiddlewareChain,
   chain,
   filterPlatform
-} from "./chunk-FHGDNFTY.js";
+} from "./chunk-ENIXF4Y2.js";
 export {
   MiddlewareChain,
   chain,

package/dist/router.d.ts

@@ -1,5 +1,5 @@
-import { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-BK1OAKm-.js';
-export { b as RouteContext, c as RouteHandler } from './index-BK1OAKm-.js';
+import { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-Dj_pJd-o.js';
+export { b as RouteContext, c as RouteHandler } from './index-Dj_pJd-o.js';
 import '@hattip/core';
 import 'pathic';
 

package/dist/router.js

@@ -3,7 +3,7 @@ import {
   defineParsedURL,
   isArray,
   isFunction
-} from "./chunk-FHGDNFTY.js";
+} from "./chunk-ENIXF4Y2.js";
 
 // src/router.ts
 import { compilePaths } from "pathic";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alien-middleware",
   "type": "module",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",