alien-middleware 0.10.3 → 0.11.0

package/dist/chunk-ENIXF4Y2.js

@@ -0,0 +1,195 @@
+// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
+function noop() {
+}
+var isArray = /* @__PURE__ */ (() => Array.isArray)();
+var asyncIteratorSymbol = (
+  /* c8 ignore next */
+  Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator")
+);
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/url.ts
+var urlDescriptor = {
+  configurable: true,
+  get() {
+    const url = new URL(this.request.url);
+    Object.defineProperty(this, "url", { value: url });
+    return url;
+  }
+};
+function defineParsedURL(context) {
+  if (!("url" in context)) {
+    Object.defineProperty(context, "url", urlDescriptor);
+  }
+}
+
+// src/middleware/filterPlatform.ts
+function filterPlatform(name) {
+  return function(ctx) {
+    if (ctx.platform.name !== name) {
+      return ctx.passThrough();
+    }
+    return null;
+  };
+}
+
+// src/index.ts
+var kRequestChain = Symbol("requestChain");
+var kIgnoreNotFound = Symbol("ignoreNotFound");
+var kMiddlewareCache = Symbol("middlewareCache");
+var kResponseHeaders = Symbol("responseHeaders");
+var MiddlewareChain = class _MiddlewareChain {
+  // Any properties added here must also be set in the `createHandler` function.
+  [kRequestChain] = [];
+  /**
+   * Add a request middleware to the end of the chain.
+   *
+   * If a middleware chain is given, its middlewares will be executed after any
+   * existing middlewares in this chain.
+   *
+   * @returns a new `MiddlewareChain` instance
+   */
+  use(middleware) {
+    return createHandler(
+      middleware instanceof _MiddlewareChain ? [...this[kRequestChain], ...middleware[kRequestChain]] : [...this[kRequestChain], middleware]
+    );
+  }
+  /**
+   * Create a middleware function that encapsulates this middleware chain, so
+   * any modifications it makes to the request context are not leaked.
+   */
+  isolate() {
+    return isFunction(this) ? (ctx) => this(ctx) : noop;
+  }
+  /**
+   * @internal You should not need to call this method, unless you want a
+   * `RequestHandler` type from an empty middleware chain. If your middleware
+   * chain is **not** empty, you won't need this.
+   */
+  toHandler() {
+    return createHandler(this[kRequestChain]);
+  }
+};
+function createExtendedEnv(context) {
+  const env = /* @__PURE__ */ Object.create(null);
+  const superEnv = context.env;
+  context.env = (key) => env[key] ?? superEnv(key);
+  return env;
+}
+async function runMiddlewareChain(requestChain, parentContext) {
+  const context = Object.create(parentContext);
+  context[kIgnoreNotFound] = true;
+  defineParsedURL(context);
+  const { passThrough } = context;
+  let shouldPassThrough = false;
+  context.passThrough = () => {
+    shouldPassThrough = true;
+  };
+  context.setHeader = (name, value) => {
+    if (context[kResponseHeaders] === parentContext[kResponseHeaders]) {
+      context[kResponseHeaders] = new Headers(parentContext[kResponseHeaders]);
+    }
+    context[kResponseHeaders].set(name, value);
+  };
+  const responseChain = [];
+  context.onResponse = (callback) => {
+    responseChain.push(callback);
+  };
+  const cache = context[kMiddlewareCache] = new Set(
+    parentContext[kMiddlewareCache]
+  );
+  let response;
+  let env;
+  for (const middleware of requestChain) {
+    if (cache.has(middleware)) {
+      continue;
+    }
+    cache.add(middleware);
+    let result = middleware(context);
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    if (shouldPassThrough) {
+      break;
+    }
+    if (result) {
+      if (result instanceof Response) {
+        response = result;
+        break;
+      }
+      for (const key in result) {
+        if (key === "env") {
+          if (result.env) {
+            env ||= createExtendedEnv(context);
+            Object.defineProperties(
+              env,
+              Object.getOwnPropertyDescriptors(result.env)
+            );
+          }
+        } else if (key === "onResponse") {
+          if (result.onResponse) {
+            responseChain.push(result.onResponse);
+          }
+        } else {
+          const descriptor = Object.getOwnPropertyDescriptor(result, key);
+          descriptor.configurable = false;
+          Object.defineProperty(context, key, descriptor);
+        }
+      }
+    }
+  }
+  if (!response) {
+    if (parentContext[kIgnoreNotFound]) {
+      return;
+    }
+    response = new Response("Not Found", { status: 404 });
+    if (shouldPassThrough) {
+      passThrough();
+      return response;
+    }
+  } else if (response.type !== "default") {
+    response = new Response(response.body, response);
+  }
+  context[kResponseHeaders]?.forEach((value, name) => {
+    response.headers.set(name, value);
+  });
+  context.setHeader = null;
+  for (const plugin of responseChain) {
+    let result = plugin(response);
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    if (result) {
+      response = result;
+      continue;
+    }
+  }
+  return response;
+}
+function createHandler(requestChain) {
+  const handler = runMiddlewareChain.bind(
+    null,
+    requestChain
+  );
+  Object.setPrototypeOf(handler, MiddlewareChain.prototype);
+  handler[kRequestChain] = requestChain;
+  return handler;
+}
+function chain(middleware) {
+  if (middleware instanceof MiddlewareChain) {
+    return middleware;
+  }
+  const empty = new MiddlewareChain();
+  return middleware ? empty.use(middleware) : empty;
+}
+
+export {
+  isArray,
+  isFunction,
+  defineParsedURL,
+  filterPlatform,
+  MiddlewareChain,
+  chain
+};

package/dist/{index-Bzfu9JE9.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,12 +233,18 @@ 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.
      */
     isolate(): (ctx: IsolatedContext<this>) => Awaitable<Response | void>;
+    /**
+     * @internal You should not need to call this method, unless you want a
+     * `RequestHandler` type from an empty middleware chain. If your middleware
+     * chain is **not** empty, you won't need this.
+     */
+    toHandler(): RequestHandler<T>;
 }
 declare function chain<TEnv extends object = {}, TProperties extends object = {}, TPlatform = unknown>(): MiddlewareChain<{
     initial: {
@@ -247,6 +257,6 @@ declare function chain<TEnv extends object = {}, TProperties extends object = {}
     };
     platform: TPlatform;
 }>;
-declare function chain<const T extends Middleware = Middleware<{}, {}, unknown>>(middleware: T): ApplyFirstMiddleware<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-Bzfu9JE9.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-2YXTWP7H.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-Bzfu9JE9.js';
-export { b as RouteContext, c as RouteHandler } from './index-Bzfu9JE9.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-2YXTWP7H.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.3",
+  "version": "0.11.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/dist/chunk-2YXTWP7H.js

@@ -1,182 +0,0 @@
-// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
-function noop() {
-}
-var isArray = /* @__PURE__ */ (() => Array.isArray)();
-var asyncIteratorSymbol = (
-  /* c8 ignore next */
-  Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator")
-);
-function isFunction(value) {
-  return typeof value === "function";
-}
-
-// src/url.ts
-var urlDescriptor = {
-  configurable: true,
-  get() {
-    const url = new URL(this.request.url);
-    Object.defineProperty(this, "url", { value: url });
-    return url;
-  }
-};
-function defineParsedURL(context) {
-  if (!("url" in context)) {
-    Object.defineProperty(context, "url", urlDescriptor);
-  }
-}
-
-// src/middleware/filterPlatform.ts
-function filterPlatform(name) {
-  return function(ctx) {
-    if (ctx.platform.name !== name) {
-      return ctx.passThrough();
-    }
-    return null;
-  };
-}
-
-// src/index.ts
-var kRequestChain = Symbol("requestChain");
-var kIgnoreNotFound = Symbol("ignoreNotFound");
-var kMiddlewareCache = Symbol("middlewareCache");
-var kResponseHeaders = Symbol("responseHeaders");
-var MiddlewareChain = class _MiddlewareChain {
-  [kRequestChain] = [];
-  /**
-   * Add a request middleware to the end of the chain.
-   *
-   * If a middleware chain is given, its middlewares will be executed after any
-   * existing middlewares in this chain.
-   *
-   * @returns a new `MiddlewareChain` instance
-   */
-  use(middleware) {
-    return createHandler(
-      middleware instanceof _MiddlewareChain ? [...this[kRequestChain], ...middleware[kRequestChain]] : [...this[kRequestChain], middleware]
-    );
-  }
-  /**
-   * Create a middleware function that encapsulates this middleware chain, so
-   * any modifications it makes to the request context are not leaked.
-   */
-  isolate() {
-    return isFunction(this) ? (ctx) => this(ctx) : noop;
-  }
-};
-function createHandler(requestChain) {
-  async function handler(parentContext) {
-    const context = Object.create(parentContext);
-    context[kIgnoreNotFound] = true;
-    defineParsedURL(context);
-    const { passThrough } = context;
-    let shouldPassThrough = false;
-    context.passThrough = () => {
-      shouldPassThrough = true;
-    };
-    context.setHeader = (name, value) => {
-      if (context[kResponseHeaders] === parentContext[kResponseHeaders]) {
-        context[kResponseHeaders] = new Headers(parentContext[kResponseHeaders]);
-      }
-      context[kResponseHeaders].set(name, value);
-    };
-    const responseChain = [];
-    context.onResponse = (callback) => {
-      responseChain.push(callback);
-    };
-    const cache = context[kMiddlewareCache] = new Set(
-      parentContext[kMiddlewareCache]
-    );
-    let response;
-    let env;
-    for (const middleware of requestChain) {
-      if (cache.has(middleware)) {
-        continue;
-      }
-      cache.add(middleware);
-      let result = middleware(context);
-      if (result instanceof Promise) {
-        result = await result;
-      }
-      if (shouldPassThrough) {
-        break;
-      }
-      if (result) {
-        if (result instanceof Response) {
-          response = result;
-          break;
-        }
-        for (const key in result) {
-          if (key === "env") {
-            if (result.env) {
-              env ||= createExtendedEnv(context);
-              Object.defineProperties(
-                env,
-                Object.getOwnPropertyDescriptors(result.env)
-              );
-            }
-          } else if (key === "onResponse") {
-            if (result.onResponse) {
-              responseChain.push(result.onResponse);
-            }
-          } else {
-            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-            descriptor.configurable = false;
-            Object.defineProperty(context, key, descriptor);
-          }
-        }
-      }
-    }
-    if (!response) {
-      if (parentContext[kIgnoreNotFound]) {
-        return;
-      }
-      response = new Response("Not Found", { status: 404 });
-      if (shouldPassThrough) {
-        passThrough();
-        return response;
-      }
-    } else if (response.type !== "default") {
-      response = new Response(response.body, response);
-    }
-    context[kResponseHeaders]?.forEach((value, name) => {
-      response.headers.set(name, value);
-    });
-    context.setHeader = null;
-    for (const plugin of responseChain) {
-      let result = plugin(response);
-      if (result instanceof Promise) {
-        result = await result;
-      }
-      if (result) {
-        response = result;
-        continue;
-      }
-    }
-    return response;
-  }
-  Object.setPrototypeOf(handler, MiddlewareChain.prototype);
-  handler[kRequestChain] = requestChain;
-  return handler;
-}
-function createExtendedEnv(context) {
-  const env = /* @__PURE__ */ Object.create(null);
-  const superEnv = context.env;
-  context.env = (key) => env[key] ?? superEnv(key);
-  return env;
-}
-function chain(middleware) {
-  if (middleware instanceof MiddlewareChain) {
-    return middleware;
-  }
-  const empty = new MiddlewareChain();
-  return middleware ? empty.use(middleware) : empty;
-}
-
-export {
-  isArray,
-  isFunction,
-  defineParsedURL,
-  filterPlatform,
-  MiddlewareChain,
-  chain
-};