hono 2.3.1 → 2.4.0

package/dist/utils/object.js

@@ -1,35 +1,34 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val);
-export const mergeObjects = (target, source) => {
-    const merged = Object.assign({}, target);
-    if (isObject(target) && isObject(source)) {
-        for (const key of Object.keys(source)) {
-            if (isObject(source[key])) {
-                if (target[key] === undefined)
-                    Object.assign(merged, { [key]: source[key] });
-                else
-                    merged[key] = mergeObjects(target[key], source[key]);
-            }
-            else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
-                const srcArr = source[key];
-                const tgtArr = target[key];
-                const outArr = [];
-                for (let i = 0; i < srcArr.length; i += 1) {
-                    // If corresponding index for both arrays is an object, then merge them
-                    // Otherwise just copy src arr index into out arr index
-                    if (isObject(srcArr[i]) && isObject(tgtArr[i])) {
-                        outArr[i] = mergeObjects(tgtArr[i], srcArr[i]);
-                    }
-                    else {
-                        outArr[i] = srcArr[i];
-                    }
-                }
-                Object.assign(merged, { [key]: outArr });
-            }
-            else {
-                Object.assign(merged, { [key]: source[key] });
-            }
+// src/utils/object.ts
+var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+var mergeObjects = (target, source) => {
+  const merged = Object.assign({}, target);
+  if (isObject(target) && isObject(source)) {
+    for (const key of Object.keys(source)) {
+      if (isObject(source[key])) {
+        if (target[key] === void 0)
+          Object.assign(merged, { [key]: source[key] });
+        else
+          merged[key] = mergeObjects(target[key], source[key]);
+      } else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
+        const srcArr = source[key];
+        const tgtArr = target[key];
+        const outArr = [];
+        for (let i = 0; i < srcArr.length; i += 1) {
+          if (isObject(srcArr[i]) && isObject(tgtArr[i])) {
+            outArr[i] = mergeObjects(tgtArr[i], srcArr[i]);
+          } else {
+            outArr[i] = srcArr[i];
+          }
         }
+        Object.assign(merged, { [key]: outArr });
+      } else {
+        Object.assign(merged, { [key]: source[key] });
+      }
     }
-    return merged;
+  }
+  return merged;
+};
+export {
+  isObject,
+  mergeObjects
 };

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare type Expect<T extends true> = T;
+export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;

package/dist/utils/url.js

@@ -1,85 +1,77 @@
-export const splitPath = (path) => {
-    const paths = path.split(/\//); // faster than path.split('/')
-    if (paths[0] === '') {
-        paths.shift();
-    }
-    return paths;
+// src/utils/url.ts
+var splitPath = (path) => {
+  const paths = path.split(/\//);
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
 };
-const patternCache = {};
-export const getPattern = (label) => {
-    // *            => wildcard
-    // :id{[0-9]+}  => ([0-9]+)
-    // :id          => (.+)
-    //const name = ''
-    if (label === '*') {
-        return '*';
-    }
-    const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    if (match) {
-        if (!patternCache[label]) {
-            if (match[2]) {
-                patternCache[label] = [label, match[1], new RegExp('^' + match[2] + '$')];
-            }
-            else {
-                patternCache[label] = [label, match[1], true];
-            }
-        }
-        return patternCache[label];
+var patternCache = {};
+var getPattern = (label) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    if (!patternCache[label]) {
+      if (match[2]) {
+        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+      } else {
+        patternCache[label] = [label, match[1], true];
+      }
     }
-    return null;
+    return patternCache[label];
+  }
+  return null;
 };
-export const getPathFromURL = (url, strict = true) => {
-    const queryIndex = url.indexOf('?');
-    const result = url.substring(url.indexOf('/', 8), queryIndex === -1 ? url.length : queryIndex);
-    // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
-    // default is true
-    if (strict === false && result.endsWith('/')) {
-        return result.slice(0, -1);
-    }
-    return result;
+var getPathFromURL = (url, strict = true) => {
+  const queryIndex = url.indexOf("?");
+  const result = url.substring(url.indexOf("/", 8), queryIndex === -1 ? url.length : queryIndex);
+  if (strict === false && result.endsWith("/")) {
+    return result.slice(0, -1);
+  }
+  return result;
 };
-export const getQueryStringFromURL = (url) => {
-    const queryIndex = url.indexOf('?');
-    const result = queryIndex !== -1 ? url.substring(queryIndex) : '';
-    return result;
+var getQueryStringFromURL = (url) => {
+  const queryIndex = url.indexOf("?");
+  const result = queryIndex !== -1 ? url.substring(queryIndex) : "";
+  return result;
 };
-export const mergePath = (...paths) => {
-    let p = '';
-    let endsWithSlash = false;
-    for (let path of paths) {
-        /* ['/hey/','/say'] => ['/hey', '/say'] */
-        if (p.endsWith('/')) {
-            p = p.slice(0, -1);
-            endsWithSlash = true;
-        }
-        /* ['/hey','say'] => ['/hey', '/say'] */
-        if (!path.startsWith('/')) {
-            path = `/${path}`;
-        }
-        /* ['/hey/', '/'] => `/hey/` */
-        if (path === '/' && endsWithSlash) {
-            p = `${p}/`;
-        }
-        else if (path !== '/') {
-            p = `${p}${path}`;
-        }
-        /* ['/', '/'] => `/` */
-        if (path === '/' && p === '') {
-            p = '/';
-        }
+var mergePath = (...paths) => {
+  let p = "";
+  let endsWithSlash = false;
+  for (let path of paths) {
+    if (p.endsWith("/")) {
+      p = p.slice(0, -1);
+      endsWithSlash = true;
+    }
+    if (!path.startsWith("/")) {
+      path = `/${path}`;
     }
-    return p;
+    if (path === "/" && endsWithSlash) {
+      p = `${p}/`;
+    } else if (path !== "/") {
+      p = `${p}${path}`;
+    }
+    if (path === "/" && p === "") {
+      p = "/";
+    }
+  }
+  return p;
+};
+var checkOptionalParameter = (path) => {
+  const match = path.match(/(^.+)(\/\:[^\/]+)\?$/);
+  if (!match)
+    return null;
+  const base = match[1];
+  const optional = base + match[2];
+  return [base, optional];
 };
-export const checkOptionalParameter = (path) => {
-    /*
-     If path is `/api/animals/:type?` it will return:
-     [`/api/animals`, `/api/animals/:type`]
-     in other cases it will return null
-     */
-    const match = path.match(/(^.+)(\/\:[^\/]+)\?$/);
-    if (!match)
-        return null;
-    const base = match[1];
-    const optional = base + match[2];
-    return [base, optional];
+export {
+  checkOptionalParameter,
+  getPathFromURL,
+  getPattern,
+  getQueryStringFromURL,
+  mergePath,
+  splitPath
 };

package/dist/validator/rule.js

@@ -0,0 +1,57 @@
+// src/validator/rule.ts
+var rule = {
+  isEmpty(value, options = { ignore_whitespace: false }) {
+    return (options.ignore_whitespace ? value.trim().length : value.length) === 0;
+  },
+  isLength: (value, options, arg2) => {
+    let min;
+    let max;
+    if (typeof options === "object") {
+      min = options.min || 0;
+      max = options.max;
+    } else {
+      min = options || 0;
+      max = arg2;
+    }
+    const presentationSequences = value.match(/(\uFE0F|\uFE0E)/g) || [];
+    const surrogatePairs = value.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
+    const len = value.length - presentationSequences.length - surrogatePairs.length;
+    return len >= min && (typeof max === "undefined" || len <= max);
+  },
+  isAlpha: (value) => {
+    return /^[A-Z]+$/i.test(value);
+  },
+  isNumeric: (value) => {
+    return /^[0-9]+$/.test(value);
+  },
+  contains: (value, elem, options = {
+    ignoreCase: false,
+    minOccurrences: 1
+  }) => {
+    options.ignoreCase || (options.ignoreCase = false);
+    options.minOccurrences || (options.minOccurrences = 1);
+    if (options.ignoreCase) {
+      return value.toLowerCase().split(elem.toLowerCase()).length > options.minOccurrences;
+    }
+    return value.split(elem).length > options.minOccurrences;
+  },
+  isIn: (value, options) => {
+    if (typeof options === "object") {
+      for (const elem of options) {
+        if (elem === value)
+          return true;
+      }
+    }
+    return false;
+  },
+  match: (value, regExp) => {
+    return regExp.test(value);
+  },
+  isGte: (value, min) => min <= value,
+  isLte: (value, max) => value <= max,
+  isTrue: (value) => value === true,
+  isFalse: (value) => value === false
+};
+export {
+  rule
+};

package/dist/validator/sanitizer.js

@@ -0,0 +1,7 @@
+// src/validator/sanitizer.ts
+var sanitizer = {
+  trim: (value) => value.trim()
+};
+export {
+  sanitizer
+};

package/dist/validator/schema.d.ts

@@ -0,0 +1,7 @@
+import type { VString, VNumber, VBoolean, VObject, VNumberArray, VStringArray, VBooleanArray, VArray, VObjectBase } from './validator';
+export declare type Schema = {
+    [key: string]: VString | VNumber | VBoolean | VStringArray | VNumberArray | VBooleanArray | Schema | VObject<Schema> | VArray<Schema>;
+};
+export declare type SchemaToProp<T> = {
+    [K in keyof T]: T[K] extends VNumberArray ? number[] : T[K] extends VBooleanArray ? boolean[] : T[K] extends VStringArray ? string[] : T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : T[K] extends VString ? string : T[K] extends VObjectBase<Schema> ? T[K]['container'] extends VNumber ? number : T[K]['container'] extends VString ? string : T[K]['container'] extends VBoolean ? boolean : T[K] extends VArray<Schema> ? SchemaToProp<ReadonlyArray<T[K]['container']>> : T[K] extends VObject<Schema> ? SchemaToProp<T[K]['container']> : T[K] extends Schema ? SchemaToProp<T[K]> : never : SchemaToProp<T[K]>;
+};

package/dist/{middleware/validator → validator}/validator.d.ts

@@ -1,6 +1,6 @@
-import type { JSONObject, JSONPrimitive, JSONArray } from '../../utils/json';
-import type { Schema } from './middleware';
-declare type Target = 'query' | 'header' | 'body' | 'json';
+import type { JSONObject, JSONPrimitive, JSONArray } from './../utils/json';
+import type { Schema } from './schema';
+declare type Target = 'query' | 'queries' | 'header' | 'body' | 'json';
 declare type Type = JSONPrimitive | JSONObject | JSONArray | File;
 declare type RuleFunc = (value: Type) => boolean;
 declare type Rule = {
@@ -13,9 +13,9 @@ declare type Sanitizer = (value: Type) => Type;
 export declare type ValidateResult = {
     isValid: boolean;
     message: string | undefined;
-    target: Target;
-    key: string;
-    value: Type;
+    target: Target | 'unknown';
+    key: string | null;
+    value: Type | null;
     ruleName: string;
     ruleType: 'type' | 'value';
     jsonData?: JSONObject;
@@ -38,6 +38,7 @@ export declare class VArray<T extends Schema> extends VObjectBase<T> {
 export declare class Validator {
     isArray: boolean;
     query: (key: string) => VString;
+    queries: (key: string) => VStringArray;
     header: (key: string) => VString;
     body: (key: string) => VString;
     json: (key: string) => VString;
@@ -71,7 +72,9 @@ export declare abstract class VBase {
     asNumber: () => VNumber | VNumberArray;
     asBoolean: () => VBoolean | VBooleanArray;
     get(value: string): this;
-    validate: (req: Request) => Promise<ValidateResult[]>;
+    validate: <R extends Request<string, {
+        [x: string]: any;
+    }>>(req: R) => Promise<ValidateResult[]>;
     protected getTypeRuleName(): string;
     private validateRule;
     private validateType;