alien-middleware 0.11.0 → 0.11.2

package/dist/{index-Dj_pJd-o.d.ts → index-Bncc19bC.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<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>;
+] 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,25 +144,27 @@ 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 `TSecond` is itself a
  * chain, it's treated as a nested chain, which won't leak its plugins into the
@@ -168,7 +173,7 @@ type MiddlewarePlatform<T extends Middleware> = T extends Middleware<any, any, i
  * 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'] ? {
+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>>;
@@ -188,13 +193,13 @@ type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
  * 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>;
+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 Middleware[]> = T extends [
-    ...infer TRest extends Middleware[],
-    infer TLast extends Middleware
+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<MiddlewareChain<ApplyMiddleware<MiddlewareChain<T['$Router']>, () => {
@@ -257,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 ? RequestHandler<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 MiddlewareTypes as j, type RequestContext as k, type RequestHandler as l, type RequestMiddleware as m, type RequestPlugin as n, type ResponseCallback as o };
+export { type AnyMiddleware 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 AnyMiddlewareChain as e, filterPlatform as f, type ApplyMiddleware as g, type ApplyMiddlewares as h, type EnvAccessor as i, type ExtractMiddleware as j, type Middleware as k, type MiddlewareTypes as l, type RequestContext as m, type RequestHandler as n, type RequestMiddleware as o, type RequestPlugin as p, type ResponseCallback as q };

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 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';
+export { A as AnyMiddleware, e as AnyMiddlewareChain, g as ApplyMiddleware, h as ApplyMiddlewares, E as EmptyMiddlewareChain, i as EnvAccessor, j as ExtractMiddleware, H as HattipContext, k as Middleware, a as MiddlewareChain, M as MiddlewareContext, l as MiddlewareTypes, m as RequestContext, n as RequestHandler, o as RequestMiddleware, p as RequestPlugin, q as ResponseCallback, d as chain, f as filterPlatform } from './index-Bncc19bC.js';
 import '@hattip/core';
 import 'pathic';

package/dist/router.d.ts

@@ -1,5 +1,5 @@
-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 { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-Bncc19bC.js';
+export { b as RouteContext, c as RouteHandler } from './index-Bncc19bC.js';
 import '@hattip/core';
 import 'pathic';
 

package/package.json

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