alien-middleware 0.10.4 → 0.11.1

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-F_xAxN5f.d.ts}

@@ -66,7 +66,10 @@ type AnyMiddlewareTypes = {
     };
     platform: any;
 };
-type AnyMiddlewareChain = MiddlewareChain<AnyMiddlewareTypes>;
+type AnyMiddlewareChain<T extends AnyMiddlewareTypes = AnyMiddlewareTypes> = {
+    $MiddlewareChain: T;
+};
+type AnyMiddleware = Middleware | AnyMiddlewareChain;
 type Inputs<T extends AnyMiddlewareChain> = T['$MiddlewareChain']['initial'];
 type InputProperties<T extends AnyMiddlewareChain> = Inputs<T>['properties'];
 type InputEnv<T extends AnyMiddlewareChain> = Inputs<T>['env'];
@@ -113,11 +116,11 @@ type RequestContext<TEnv extends object = any, TProperties extends object = neve
  *
  * When type `T` is `never`, a default context is returned.
  */
-type MiddlewareContext<T extends MiddlewareChain | Middleware[]> = [
+type MiddlewareContext<T extends AnyMiddlewareChain | AnyMiddleware[]> = [
     T
-] extends [never] ? RequestContext<{}, never, unknown> : T extends MiddlewareChain ? RequestContext<Env<T>, Properties<T>, Platform<T>> : T extends Middleware[] ? MiddlewareContext<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>;
+] extends [never] ? RequestContext<{}, never, unknown> : T extends AnyMiddlewareChain ? RequestContext<Env<T>, Properties<T>, Platform<T>> : T extends AnyMiddleware[] ? MiddlewareContext<MiddlewareChain<ApplyMiddlewares<T>>> : never;
+type IsolatedContext<T extends AnyMiddlewareChain> = RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>;
+type RequestMiddleware<T extends AnyMiddlewareChain = MiddlewareChain> = (context: RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
 type ResponseCallback = (response: Response) => Awaitable<Response | void>;
 interface RequestHandler<T extends MiddlewareTypes = any> extends HattipHandler<T['platform']>, MiddlewareChain<T> {
 }
@@ -141,45 +144,40 @@ type Middleware<TEnv extends object = any, TProperties extends object = any, TPl
 /**
  * Extract a `Middleware` type from a `MiddlewareChain` type.
  */
-type ExtractMiddleware<T extends MiddlewareChain> = [T] extends [never] ? Middleware<{}, {}, any> : Middleware<Env<T>, Properties<T>, Platform<T>>;
+type ExtractMiddleware<T extends AnyMiddlewareChain> = [T] extends [
+    never
+] ? Middleware<{}, {}, any> : Middleware<Env<T>, Properties<T>, Platform<T>>;
 /**
  * Merge a request plugin into a middleware chain.
  */
-type ApplyMiddlewareResult<TParent extends MiddlewareChain, TResult> = Eval<{
+type ApplyMiddlewareResult<TParent extends AnyMiddlewareChain, TResult> = Eval<{
     env: Merge<Env<TParent>, TResult extends {
         env: infer TEnv extends object | undefined;
     } ? TEnv : undefined>;
     properties: Merge<Properties<TParent>, TResult extends RequestPlugin ? Omit<TResult, keyof ReservedProperties> : undefined>;
 }>;
-type ApplyMiddlewareOutputs<TFirst extends MiddlewareChain, TSecond extends Middleware> = TSecond extends MiddlewareChain ? {
+type ApplyMiddlewareOutputs<TFirst extends AnyMiddlewareChain, TSecond extends AnyMiddleware> = TSecond extends AnyMiddlewareChain ? {
     env: Merge<Env<TFirst>, Env<TSecond>>;
     properties: Merge<Properties<TFirst>, Properties<TSecond>>;
 } : TSecond extends (...args: any[]) => Awaitable<infer TResult> ? ApplyMiddlewareResult<TFirst, Exclude<TResult, Response>> : Current<TFirst>;
-type MiddlewareInputs<T extends Middleware> = T extends Middleware<infer TEnv, infer TProperties> ? {
+type MiddlewareInputs<T extends AnyMiddleware> = T extends AnyMiddlewareChain ? Inputs<T> : T extends Middleware<infer TEnv, infer TProperties> ? {
     env: TEnv;
     properties: TProperties;
 } : never;
-type MiddlewarePlatform<T extends Middleware> = T extends Middleware<any, any, infer TPlatform> ? TPlatform : never;
+type MiddlewarePlatform<T extends AnyMiddleware> = T extends AnyMiddlewareChain ? Platform<T> : 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 AnyMiddlewareChain, TSecond extends AnyMiddleware> = 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 +189,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 AnyMiddleware> = T extends AnyMiddlewareChain<infer TInternal> ? TInternal : ApplyMiddleware<EmptyMiddlewareChain<MiddlewarePlatform<T>>, T>;
+/**
+ * Flatten a list of middlewares into a `MiddlewareTypes` type.
+ */
+type ApplyMiddlewares<T extends AnyMiddleware[]> = T extends [
+    ...infer TRest extends AnyMiddleware[],
+    infer TLast extends AnyMiddleware
+] ? 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 +238,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 +262,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 AnyMiddleware>(middleware: T): T extends AnyMiddlewareChain ? T : RequestHandler<ApplyFirstMiddleware<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-F_xAxN5f.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-F_xAxN5f.js';
+export { b as RouteContext, c as RouteHandler } from './index-F_xAxN5f.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.1",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",