hono 2.3.2 → 2.4.0

package/dist/router/trie-router/node.js

@@ -1,170 +1,159 @@
-import { METHOD_NAME_ALL } from '../../router';
-import { splitPath, getPattern } from '../../utils/url';
+// src/router/trie-router/node.ts
+import { METHOD_NAME_ALL } from "../../router.js";
+import { splitPath, getPattern } from "../../utils/url.js";
 function findParam(node, name) {
-    for (let i = 0, len = node.patterns.length; i < len; i++) {
-        if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
-            return true;
-        }
+  for (let i = 0, len = node.patterns.length; i < len; i++) {
+    if (typeof node.patterns[i] === "object" && node.patterns[i][1] === name) {
+      return true;
     }
-    const nodes = Object.values(node.children);
-    for (let i = 0, len = nodes.length; i < len; i++) {
-        if (findParam(nodes[i], name)) {
-            return true;
-        }
+  }
+  const nodes = Object.values(node.children);
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    if (findParam(nodes[i], name)) {
+      return true;
     }
-    return false;
+  }
+  return false;
 }
-export class Node {
-    constructor(method, handler, children) {
-        this.order = 0;
-        this.children = children || {};
-        this.methods = [];
-        this.name = '';
-        if (method && handler) {
-            const m = {};
-            m[method] = { handler: handler, score: 0, name: this.name };
-            this.methods = [m];
-        }
-        this.patterns = [];
-        this.handlerSetCache = {};
+var Node = class {
+  constructor(method, handler, children) {
+    this.order = 0;
+    this.children = children || {};
+    this.methods = [];
+    this.name = "";
+    if (method && handler) {
+      const m = {};
+      m[method] = { handler, score: 0, name: this.name };
+      this.methods = [m];
     }
-    insert(method, path, handler) {
-        this.name = `${method} ${path}`;
-        this.order = ++this.order;
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let curNode = this;
-        const parts = splitPath(path);
-        const parentPatterns = [];
-        const errorMessage = (name) => {
-            return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
-        };
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const p = parts[i];
-            if (Object.keys(curNode.children).includes(p)) {
-                parentPatterns.push(...curNode.patterns);
-                curNode = curNode.children[p];
-                continue;
+    this.patterns = [];
+    this.handlerSetCache = {};
+  }
+  insert(method, path, handler) {
+    this.name = `${method} ${path}`;
+    this.order = ++this.order;
+    let curNode = this;
+    const parts = splitPath(path);
+    const parentPatterns = [];
+    const errorMessage = (name) => {
+      return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
+    };
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      if (Object.keys(curNode.children).includes(p)) {
+        parentPatterns.push(...curNode.patterns);
+        curNode = curNode.children[p];
+        continue;
+      }
+      curNode.children[p] = new Node();
+      const pattern = getPattern(p);
+      if (pattern) {
+        if (typeof pattern === "object") {
+          for (let j = 0, len2 = parentPatterns.length; j < len2; j++) {
+            if (typeof parentPatterns[j] === "object" && parentPatterns[j][1] === pattern[1]) {
+              throw new Error(errorMessage(pattern[1]));
             }
-            curNode.children[p] = new Node();
-            const pattern = getPattern(p);
-            if (pattern) {
-                if (typeof pattern === 'object') {
-                    for (let j = 0, len = parentPatterns.length; j < len; j++) {
-                        if (typeof parentPatterns[j] === 'object' && parentPatterns[j][1] === pattern[1]) {
-                            throw new Error(errorMessage(pattern[1]));
-                        }
-                    }
-                    if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
-                        throw new Error(errorMessage(pattern[1]));
-                    }
-                }
-                curNode.patterns.push(pattern);
-                parentPatterns.push(...curNode.patterns);
-            }
-            parentPatterns.push(...curNode.patterns);
-            curNode = curNode.children[p];
-        }
-        if (!curNode.methods.length) {
-            curNode.methods = [];
+          }
+          if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
+            throw new Error(errorMessage(pattern[1]));
+          }
         }
-        const m = {};
-        const handlerSet = { handler: handler, name: this.name, score: this.order };
-        m[method] = handlerSet;
-        curNode.methods.push(m);
-        return curNode;
+        curNode.patterns.push(pattern);
+        parentPatterns.push(...curNode.patterns);
+      }
+      parentPatterns.push(...curNode.patterns);
+      curNode = curNode.children[p];
     }
-    getHandlerSets(node, method, wildcard) {
-        var _a, _b;
-        return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
-            const handlerSets = [];
-            for (let i = 0, len = node.methods.length; i < len; i++) {
-                const m = node.methods[i];
-                const handlerSet = m[method] || m[METHOD_NAME_ALL];
-                if (handlerSet !== undefined) {
-                    handlerSets.push(handlerSet);
-                }
-            }
-            return handlerSets;
-        })()));
+    if (!curNode.methods.length) {
+      curNode.methods = [];
     }
-    search(method, path) {
-        const handlerSets = [];
-        const params = {};
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const curNode = this;
-        let curNodes = [curNode];
-        const parts = splitPath(path);
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const part = parts[i];
-            const isLast = i === len - 1;
-            const tempNodes = [];
-            let matched = false;
-            for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-                const node = curNodes[j];
-                const nextNode = node.children[part];
-                if (nextNode) {
-                    if (isLast === true) {
-                        // '/hello/*' => match '/hello'
-                        if (nextNode.children['*']) {
-                            handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
-                        }
-                        handlerSets.push(...this.getHandlerSets(nextNode, method));
-                        matched = true;
-                    }
-                    else {
-                        tempNodes.push(nextNode);
-                    }
-                }
-                for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-                    const pattern = node.patterns[k];
-                    // Wildcard
-                    // '/hello/*/foo' => match /hello/bar/foo
-                    if (pattern === '*') {
-                        const astNode = node.children['*'];
-                        if (astNode) {
-                            handlerSets.push(...this.getHandlerSets(astNode, method));
-                            tempNodes.push(astNode);
-                        }
-                        continue;
-                    }
-                    if (part === '')
-                        continue;
-                    // Named match
-                    // `/posts/:id` => match /posts/123
-                    const [key, name, matcher] = pattern;
-                    if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
-                        if (typeof key === 'string') {
-                            if (isLast === true) {
-                                handlerSets.push(...this.getHandlerSets(node.children[key], method));
-                            }
-                            else {
-                                tempNodes.push(node.children[key]);
-                            }
-                        }
-                        // '/book/a'     => not-slug
-                        // '/book/:slug' => slug
-                        // GET /book/a   ~> no-slug, param['slug'] => undefined
-                        // GET /book/foo ~> slug, param['slug'] => foo
-                        if (typeof name === 'string' && !matched) {
-                            params[name] = part;
-                        }
-                    }
-                }
+    const m = {};
+    const handlerSet = { handler, name: this.name, score: this.order };
+    m[method] = handlerSet;
+    curNode.methods.push(m);
+    return curNode;
+  }
+  getHandlerSets(node, method, wildcard) {
+    var _a, _b;
+    return (_a = node.handlerSetCache)[_b = `${method}:${wildcard ? "1" : "0"}`] || (_a[_b] = (() => {
+      const handlerSets = [];
+      for (let i = 0, len = node.methods.length; i < len; i++) {
+        const m = node.methods[i];
+        const handlerSet = m[method] || m[METHOD_NAME_ALL];
+        if (handlerSet !== void 0) {
+          handlerSets.push(handlerSet);
+        }
+      }
+      return handlerSets;
+    })());
+  }
+  search(method, path) {
+    const handlerSets = [];
+    const params = {};
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    for (let i = 0, len2 = parts.length; i < len2; i++) {
+      const part = parts[i];
+      const isLast = i === len2 - 1;
+      const tempNodes = [];
+      let matched = false;
+      for (let j = 0, len22 = curNodes.length; j < len22; j++) {
+        const node = curNodes[j];
+        const nextNode = node.children[part];
+        if (nextNode) {
+          if (isLast === true) {
+            if (nextNode.children["*"]) {
+              handlerSets.push(...this.getHandlerSets(nextNode.children["*"], method, true));
+            }
+            handlerSets.push(...this.getHandlerSets(nextNode, method));
+            matched = true;
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+          const pattern = node.patterns[k];
+          if (pattern === "*") {
+            const astNode = node.children["*"];
+            if (astNode) {
+              handlerSets.push(...this.getHandlerSets(astNode, method));
+              tempNodes.push(astNode);
             }
-            curNodes = tempNodes;
+            continue;
+          }
+          if (part === "")
+            continue;
+          const [key, name, matcher] = pattern;
+          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+            if (typeof key === "string") {
+              if (isLast === true) {
+                handlerSets.push(...this.getHandlerSets(node.children[key], method));
+              } else {
+                tempNodes.push(node.children[key]);
+              }
+            }
+            if (typeof name === "string" && !matched) {
+              params[name] = part;
+            }
+          }
         }
-        const len = handlerSets.length;
-        if (len === 0)
-            return null;
-        if (len === 1)
-            return { handlers: [handlerSets[0].handler], params };
-        const handlers = handlerSets
-            .sort((a, b) => {
-            return a.score - b.score;
-        })
-            .map((s) => {
-            return s.handler;
-        });
-        return { handlers, params };
+      }
+      curNodes = tempNodes;
     }
-}
+    const len = handlerSets.length;
+    if (len === 0)
+      return null;
+    if (len === 1)
+      return { handlers: [handlerSets[0].handler], params };
+    const handlers = handlerSets.sort((a, b) => {
+      return a.score - b.score;
+    }).map((s) => {
+      return s.handler;
+    });
+    return { handlers, params };
+  }
+};
+export {
+  Node
+};

package/dist/router/trie-router/router.js

@@ -1,20 +1,24 @@
-import { checkOptionalParameter } from '../../utils/url';
-import { Node } from './node';
-export class TrieRouter {
-    constructor() {
-        this.node = new Node();
+// src/router/trie-router/router.ts
+import { checkOptionalParameter } from "../../utils/url.js";
+import { Node } from "./node.js";
+var TrieRouter = class {
+  constructor() {
+    this.node = new Node();
+  }
+  add(method, path, handler) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (const p of results) {
+        this.node.insert(method, p, handler);
+      }
+      return;
     }
-    add(method, path, handler) {
-        const results = checkOptionalParameter(path);
-        if (results) {
-            for (const p of results) {
-                this.node.insert(method, p, handler);
-            }
-            return;
-        }
-        this.node.insert(method, path, handler);
-    }
-    match(method, path) {
-        return this.node.search(method, path);
-    }
-}
+    this.node.insert(method, path, handler);
+  }
+  match(method, path) {
+    return this.node.search(method, path);
+  }
+};
+export {
+  TrieRouter
+};

package/dist/router.js

@@ -1,5 +1,12 @@
-export const METHOD_NAME_ALL = 'ALL';
-export const METHOD_NAME_ALL_LOWERCASE = 'all';
-export const METHODS = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
-export class UnsupportedPathError extends Error {
-}
+// src/router.ts
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "head", "options", "patch"];
+var UnsupportedPathError = class extends Error {
+};
+export {
+  METHODS,
+  METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError
+};

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from './context';
+import type { Schema } from './validator/schema';
+export interface ContextVariableMap {
+}
+export declare type Bindings = Record<string, any>;
+export declare type Variables = Record<string, any>;
+export declare type Environment = {
+    Bindings: Bindings;
+    Variables: Variables;
+};
+export declare type Handler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>, next: Next) => Response | Promise<Response | undefined | void>;
+export declare type MiddlewareHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>, next: Next) => Promise<Response | undefined | void>;
+export declare type NotFoundHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>) => Response | Promise<Response>;
+export declare type ErrorHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (err: Error, c: Context<P, E, S>) => Response;
+export declare type Next = () => Promise<void>;
+declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
+declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
+export declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
+export interface CustomHandler<P extends string | Partial<Environment> | Schema = string, E = Partial<Environment> | Partial<Schema>, S = Partial<Schema>> {
+    (c: Context<P extends string ? P : P extends Partial<Environment> ? string : P extends Partial<Schema> ? string : never, P extends Partial<Environment> ? P : P extends Partial<Schema> ? Partial<Environment> : E extends Partial<Environment> ? E extends Partial<Schema> ? Environment : E : E extends Partial<Schema> ? Partial<Environment> : Environment, P extends Partial<Schema> ? P : E extends Partial<Schema> ? P extends Partial<Environment> ? E extends Partial<Environment> ? unknown : E : unknown : S extends Partial<Schema> ? S : never>, next: Next): Response | Promise<Response | undefined | void>;
+}
+export {};

package/dist/utils/body.js

@@ -1,14 +1,16 @@
-export async function parseBody(r) {
-    let body = {};
-    const contentType = r.headers.get('Content-Type');
-    if (contentType &&
-        (contentType.startsWith('multipart/form-data') ||
-            contentType === 'application/x-www-form-urlencoded')) {
-        const form = {};
-        body = [...(await r.formData())].reduce((acc, cur) => {
-            acc[cur[0]] = cur[1];
-            return acc;
-        }, form);
-    }
-    return body;
+// src/utils/body.ts
+async function parseBody(r) {
+  let body = {};
+  const contentType = r.headers.get("Content-Type");
+  if (contentType && (contentType.startsWith("multipart/form-data") || contentType === "application/x-www-form-urlencoded")) {
+    const form = {};
+    body = [...await r.formData()].reduce((acc, cur) => {
+      acc[cur[0]] = cur[1];
+      return acc;
+    }, form);
+  }
+  return body;
 }
+export {
+  parseBody
+};

package/dist/utils/buffer.js

@@ -1,33 +1,39 @@
-import { sha256 } from './crypto';
-export const equal = (a, b) => {
-    if (a === b) {
-        return true;
-    }
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    const va = new DataView(a);
-    const vb = new DataView(b);
-    let i = va.byteLength;
-    while (i--) {
-        if (va.getUint8(i) !== vb.getUint8(i)) {
-            return false;
-        }
-    }
+// src/utils/buffer.ts
+import { sha256 } from "./crypto.js";
+var equal = (a, b) => {
+  if (a === b) {
     return true;
-};
-export const timingSafeEqual = async (a, b, hashFunction) => {
-    if (!hashFunction) {
-        hashFunction = sha256;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const va = new DataView(a);
+  const vb = new DataView(b);
+  let i = va.byteLength;
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false;
     }
-    const sa = await hashFunction(a);
-    const sb = await hashFunction(b);
-    return sa === sb && a === b;
+  }
+  return true;
 };
-export const bufferToString = (buffer) => {
-    if (buffer instanceof ArrayBuffer) {
-        const enc = new TextDecoder('utf-8');
-        return enc.decode(buffer);
-    }
-    return buffer;
+var timingSafeEqual = async (a, b, hashFunction) => {
+  if (!hashFunction) {
+    hashFunction = sha256;
+  }
+  const sa = await hashFunction(a);
+  const sb = await hashFunction(b);
+  return sa === sb && a === b;
+};
+var bufferToString = (buffer) => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder("utf-8");
+    return enc.decode(buffer);
+  }
+  return buffer;
+};
+export {
+  bufferToString,
+  equal,
+  timingSafeEqual
 };

package/dist/utils/cloudflare.js

@@ -1,35 +1,35 @@
-export const getContentFromKVAsset = async (path, options) => {
-    let ASSET_MANIFEST = {};
-    if (options && options.manifest) {
-        if (typeof options.manifest === 'string') {
-            ASSET_MANIFEST = JSON.parse(options.manifest);
-        }
-        else {
-            ASSET_MANIFEST = options.manifest;
-        }
+// src/utils/cloudflare.ts
+var getContentFromKVAsset = async (path, options) => {
+  let ASSET_MANIFEST = {};
+  if (options && options.manifest) {
+    if (typeof options.manifest === "string") {
+      ASSET_MANIFEST = JSON.parse(options.manifest);
+    } else {
+      ASSET_MANIFEST = options.manifest;
     }
-    else {
-        if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
-            ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
-        }
-        else {
-            ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
-        }
+  } else {
+    if (typeof __STATIC_CONTENT_MANIFEST === "string") {
+      ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+    } else {
+      ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
     }
-    let ASSET_NAMESPACE;
-    if (options && options.namespace) {
-        ASSET_NAMESPACE = options.namespace;
-    }
-    else {
-        ASSET_NAMESPACE = __STATIC_CONTENT;
-    }
-    const key = ASSET_MANIFEST[path] || path;
-    if (!key) {
-        return null;
-    }
-    let content = await ASSET_NAMESPACE.get(key, { type: 'arrayBuffer' });
-    if (content) {
-        content = content;
-    }
-    return content;
+  }
+  let ASSET_NAMESPACE;
+  if (options && options.namespace) {
+    ASSET_NAMESPACE = options.namespace;
+  } else {
+    ASSET_NAMESPACE = __STATIC_CONTENT;
+  }
+  const key = ASSET_MANIFEST[path] || path;
+  if (!key) {
+    return null;
+  }
+  let content = await ASSET_NAMESPACE.get(key, { type: "arrayBuffer" });
+  if (content) {
+    content = content;
+  }
+  return content;
+};
+export {
+  getContentFromKVAsset
 };