@withbuddi/buddi 0.1.0-pre.21 → 0.1.0-pre.22

package/node_modules/hono/dist/router/reg-exp-router/prepared-router.js

@@ -1,142 +1,94 @@
-// src/router/reg-exp-router/prepared-router.ts
-import { METHOD_NAME_ALL } from "../../router.js";
-import { match, emptyParam } from "./matcher.js";
+import "../../router.js";
+import { emptyParam, match } from "./matcher.js";
 import { RegExpRouter } from "./router.js";
+//#region src/router/reg-exp-router/prepared-router.ts
 var PreparedRegExpRouter = class {
-  name = "PreparedRegExpRouter";
-  #matchers;
-  #relocateMap;
-  constructor(matchers, relocateMap) {
-    this.#matchers = matchers;
-    this.#relocateMap = relocateMap;
-  }
-  #addWildcard(method, handlerData) {
-    const matcher = this.#matchers[method];
-    matcher[1].forEach((list) => list && list.push(handlerData));
-    Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
-  }
-  #addPath(method, path, handler, indexes, map) {
-    const matcher = this.#matchers[method];
-    if (!map) {
-      matcher[2][path][0].push([handler, {}]);
-    } else {
-      indexes.forEach((index) => {
-        if (typeof index === "number") {
-          matcher[1][index].push([handler, map]);
-        } else {
-          ;
-          matcher[2][index || path][0].push([handler, map]);
-        }
-      });
-    }
-  }
-  add(method, path, handler) {
-    if (!this.#matchers[method]) {
-      const all = this.#matchers[METHOD_NAME_ALL];
-      const staticMap = {};
-      for (const key in all[2]) {
-        staticMap[key] = [all[2][key][0].slice(), emptyParam];
-      }
-      this.#matchers[method] = [
-        all[0],
-        all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
-        staticMap
-      ];
-    }
-    if (path === "/*" || path === "*") {
-      const handlerData = [handler, {}];
-      if (method === METHOD_NAME_ALL) {
-        for (const m in this.#matchers) {
-          this.#addWildcard(m, handlerData);
-        }
-      } else {
-        this.#addWildcard(method, handlerData);
-      }
-      return;
-    }
-    const data = this.#relocateMap[path];
-    if (!data) {
-      throw new Error(`Path ${path} is not registered`);
-    }
-    for (const [indexes, map] of data) {
-      if (method === METHOD_NAME_ALL) {
-        for (const m in this.#matchers) {
-          this.#addPath(m, path, handler, indexes, map);
-        }
-      } else {
-        this.#addPath(method, path, handler, indexes, map);
-      }
-    }
-  }
-  buildAllMatchers() {
-    return this.#matchers;
-  }
-  match = match;
+	name = "PreparedRegExpRouter";
+	#matchers;
+	#relocateMap;
+	constructor(matchers, relocateMap) {
+		this.#matchers = matchers;
+		this.#relocateMap = relocateMap;
+	}
+	#addWildcard(method, handlerData) {
+		const matcher = this.#matchers[method];
+		matcher[1].forEach((list) => list && list.push(handlerData));
+		Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
+	}
+	#addPath(method, path, handler, indexes, map) {
+		const matcher = this.#matchers[method];
+		if (!map) matcher[2][path][0].push([handler, {}]);
+		else indexes.forEach((index) => {
+			if (typeof index === "number") matcher[1][index].push([handler, map]);
+			else matcher[2][index || path][0].push([handler, map]);
+		});
+	}
+	add(method, path, handler) {
+		if (!this.#matchers[method]) {
+			const all = this.#matchers["ALL"];
+			const staticMap = {};
+			for (const key in all[2]) staticMap[key] = [all[2][key][0].slice(), emptyParam];
+			this.#matchers[method] = [
+				all[0],
+				all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+				staticMap
+			];
+		}
+		if (path === "/*" || path === "*") {
+			const handlerData = [handler, {}];
+			if (method === "ALL") for (const m in this.#matchers) this.#addWildcard(m, handlerData);
+			else this.#addWildcard(method, handlerData);
+			return;
+		}
+		const data = this.#relocateMap[path];
+		if (!data) throw new Error(`Path ${path} is not registered`);
+		for (const [indexes, map] of data) if (method === "ALL") for (const m in this.#matchers) this.#addPath(m, path, handler, indexes, map);
+		else this.#addPath(method, path, handler, indexes, map);
+	}
+	buildAllMatchers() {
+		return this.#matchers;
+	}
+	match = match;
 };
-var buildInitParams = ({ paths }) => {
-  const RegExpRouterWithMatcherExport = class extends RegExpRouter {
-    buildAndExportAllMatchers() {
-      return this.buildAllMatchers();
-    }
-  };
-  const router = new RegExpRouterWithMatcherExport();
-  for (const path of paths) {
-    router.add(METHOD_NAME_ALL, path, path);
-  }
-  const matchers = router.buildAndExportAllMatchers();
-  const all = matchers[METHOD_NAME_ALL];
-  const relocateMap = {};
-  for (const path of paths) {
-    if (path === "/*" || path === "*") {
-      continue;
-    }
-    all[1].forEach((list, i) => {
-      list.forEach(([p, map]) => {
-        if (p === path) {
-          if (relocateMap[path]) {
-            relocateMap[path][0][1] = {
-              ...relocateMap[path][0][1],
-              ...map
-            };
-          } else {
-            relocateMap[path] = [[[], map]];
-          }
-          if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) {
-            relocateMap[path][0][0].push(i);
-          }
-        }
-      });
-    });
-    for (const path2 in all[2]) {
-      all[2][path2][0].forEach(([p]) => {
-        if (p === path) {
-          relocateMap[path] ||= [[[]]];
-          const value = path2 === path ? "" : path2;
-          if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) {
-            relocateMap[path][0][0].push(value);
-          }
-        }
-      });
-    }
-  }
-  for (let i = 0, len = all[1].length; i < len; i++) {
-    all[1][i] = all[1][i] ? [] : 0;
-  }
-  for (const path in all[2]) {
-    all[2][path][0] = [];
-  }
-  return [matchers, relocateMap];
+const buildInitParams = ({ paths }) => {
+	const RegExpRouterWithMatcherExport = class extends RegExpRouter {
+		buildAndExportAllMatchers() {
+			return this.buildAllMatchers();
+		}
+	};
+	const router = new RegExpRouterWithMatcherExport();
+	for (const path of paths) router.add("ALL", path, path);
+	const matchers = router.buildAndExportAllMatchers();
+	const all = matchers["ALL"];
+	const relocateMap = {};
+	for (const path of paths) {
+		if (path === "/*" || path === "*") continue;
+		all[1].forEach((list, i) => {
+			list.forEach(([p, map]) => {
+				if (p === path) {
+					if (relocateMap[path]) relocateMap[path][0][1] = {
+						...relocateMap[path][0][1],
+						...map
+					};
+					else relocateMap[path] = [[[], map]];
+					if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) relocateMap[path][0][0].push(i);
+				}
+			});
+		});
+		for (const path2 in all[2]) all[2][path2][0].forEach(([p]) => {
+			if (p === path) {
+				relocateMap[path] ||= [[[]]];
+				const value = path2 === path ? "" : path2;
+				if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) relocateMap[path][0][0].push(value);
+			}
+		});
+	}
+	for (let i = 0, len = all[1].length; i < len; i++) all[1][i] = all[1][i] ? [] : 0;
+	for (const path in all[2]) all[2][path][0] = [];
+	return [matchers, relocateMap];
 };
-var serializeInitParams = ([matchers, relocateMap]) => {
-  const matchersStr = JSON.stringify(
-    matchers,
-    (_, value) => value instanceof RegExp ? `##${value.toString()}##` : value
-  ).replace(/"##(.+?)##"/g, (_, str) => str.replace(/\\\\/g, "\\"));
-  const relocateMapStr = JSON.stringify(relocateMap);
-  return `[${matchersStr},${relocateMapStr}]`;
-};
-export {
-  PreparedRegExpRouter,
-  buildInitParams,
-  serializeInitParams
+const serializeInitParams = ([matchers, relocateMap]) => {
+	return `[${JSON.stringify(matchers, (_, value) => value instanceof RegExp ? `##${value.toString()}##` : value).replace(/"##(.+?)##"/g, (_, str) => str.replace(/\\\\/g, "\\"))},${JSON.stringify(relocateMap)}]`;
 };
+//#endregion
+export { PreparedRegExpRouter, buildInitParams, serializeInitParams };

package/node_modules/hono/dist/router/reg-exp-router/router.js

@@ -1,138 +1,101 @@
-// src/router/reg-exp-router/router.ts
-import {
-  MESSAGE_MATCHER_IS_ALREADY_BUILT,
-  METHOD_NAME_ALL,
-  UnsupportedPathError
-} from "../../router.js";
 import { checkOptionalParameter } from "../../utils/url.js";
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
 import { createNullObject } from "../utils.js";
-import { match, emptyParam } from "./matcher.js";
-import {
-  LABEL_REG_EXP_STR,
-  ONLY_WILDCARD_REG_EXP_STR,
-  PATH_ERROR,
-  TAIL_WILDCARD_REG_EXP_STR
-} from "./node.js";
+import { emptyParam, match } from "./matcher.js";
+import { LABEL_REG_EXP_STR, PATH_ERROR, TAIL_WILDCARD_REG_EXP_STR } from "./node.js";
 import { Trie } from "./trie.js";
-var wildcardRegExpCache = createNullObject();
+//#region src/router/reg-exp-router/router.ts
+let wildcardRegExpCache = createNullObject();
 function buildWildcardRegExp(path) {
-  return wildcardRegExpCache[path] ??= new RegExp(
-    `^${path.replace(
-      /\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g,
-      (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ONLY_WILDCARD_REG_EXP_STR : `/:${LABEL_REG_EXP_STR}`
-    )}$`
-  );
+	return wildcardRegExpCache[path] ??= new RegExp(`^${path.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match, metaChar) => metaChar ? `\\${metaChar}` : match === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
 }
 function findMiddleware(middleware, path) {
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path)) {
-      return [...middleware[k]];
-    }
-  }
-  return void 0;
+	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path)) return [...middleware[k]];
 }
 var RegExpRouter = class {
-  name = "RegExpRouter";
-  #middleware;
-  #routes;
-  #tries;
-  constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: createNullObject() };
-    this.#routes = { [METHOD_NAME_ALL]: createNullObject() };
-    this.#tries = { [METHOD_NAME_ALL]: new Trie() };
-  }
-  #insertPath(method, path) {
-    try {
-      this.#tries[method].insert(path, !/\*|\/:/.test(path));
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-    }
-  }
-  add(method, path, handler) {
-    const middleware = this.#middleware;
-    const routes = this.#routes;
-    if (!middleware) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    if (!middleware[method]) {
-      this.#tries[method] = new Trie();
-      for (const handlerMap of [middleware, routes]) {
-        handlerMap[method] = createNullObject();
-        for (const p in handlerMap[METHOD_NAME_ALL]) {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-          this.#insertPath(method, p);
-        }
-      }
-    }
-    if (path === "/*") {
-      path = "*";
-    }
-    const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method];
-    if (/\*$/.test(path)) {
-      const re = buildWildcardRegExp(path);
-      for (const m of methods) {
-        if (!middleware[m][path]) {
-          this.#insertPath(m, path);
-          middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-        }
-      }
-      for (const handlerMap of [middleware, routes]) {
-        for (const m of methods) {
-          for (const p in handlerMap[m]) {
-            re.test(p) && handlerMap[m][p].push([handler, path]);
-          }
-        }
-      }
-      return;
-    }
-    const paths = checkOptionalParameter(path) || [path];
-    for (const path2 of paths) {
-      for (const m of methods) {
-        if (!routes[m][path2]) {
-          this.#insertPath(m, path2);
-          routes[m][path2] = findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
-        }
-        routes[m][path2].push([handler, path2]);
-      }
-    }
-  }
-  match = match;
-  buildAllMatchers() {
-    const matchers = createNullObject();
-    for (const method of Object.keys(this.#routes)) {
-      matchers[method] = this.#buildMatcher(method);
-    }
-    this.#middleware = this.#routes = this.#tries = void 0;
-    wildcardRegExpCache = createNullObject();
-    return matchers;
-  }
-  #buildMatcher(method) {
-    const middleware = this.#middleware[method];
-    const routes = this.#routes[method];
-    const trie = this.#tries[method];
-    const staticMap = createNullObject();
-    const handlerData = [];
-    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-    for (const r of [middleware, routes]) {
-      for (const path in r) {
-        const handlers = r[path];
-        const pathData = trie.paths[path];
-        if (!pathData) {
-          staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
-          continue;
-        }
-        handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
-          h,
-          trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
-            map[key] = paramReplacementMap[pathData[1][i][1]];
-            return map;
-          }, createNullObject())
-        ]);
-      }
-    }
-    return [regexp, indexReplacementMap.map((i) => handlerData[i]), staticMap];
-  }
-};
-export {
-  RegExpRouter
+	name = "RegExpRouter";
+	#middleware;
+	#routes;
+	#tries;
+	constructor() {
+		this.#middleware = { ["ALL"]: createNullObject() };
+		this.#routes = { ["ALL"]: createNullObject() };
+		this.#tries = { ["ALL"]: new Trie() };
+	}
+	#insertPath(method, path) {
+		try {
+			this.#tries[method].insert(path, !/\*|\/:/.test(path));
+		} catch (e) {
+			throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+		}
+	}
+	add(method, path, handler) {
+		const middleware = this.#middleware;
+		const routes = this.#routes;
+		if (!middleware) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		if (!middleware[method]) {
+			this.#tries[method] = new Trie();
+			for (const handlerMap of [middleware, routes]) {
+				handlerMap[method] = createNullObject();
+				for (const p in handlerMap["ALL"]) {
+					handlerMap[method][p] = [...handlerMap["ALL"][p]];
+					this.#insertPath(method, p);
+				}
+			}
+		}
+		if (path === "/*") path = "*";
+		const methods = method === "ALL" ? Object.keys(middleware) : [method];
+		if (/\*$/.test(path)) {
+			const re = buildWildcardRegExp(path);
+			for (const m of methods) if (!middleware[m][path]) {
+				this.#insertPath(m, path);
+				middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			for (const handlerMap of [middleware, routes]) for (const m of methods) for (const p in handlerMap[m]) re.test(p) && handlerMap[m][p].push([handler, path]);
+			return;
+		}
+		const paths = checkOptionalParameter(path) || [path];
+		for (const path of paths) for (const m of methods) {
+			if (!routes[m][path]) {
+				this.#insertPath(m, path);
+				routes[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			routes[m][path].push([handler, path]);
+		}
+	}
+	match = match;
+	buildAllMatchers() {
+		const matchers = createNullObject();
+		for (const method of Object.keys(this.#routes)) matchers[method] = this.#buildMatcher(method);
+		this.#middleware = this.#routes = this.#tries = void 0;
+		wildcardRegExpCache = createNullObject();
+		return matchers;
+	}
+	#buildMatcher(method) {
+		const middleware = this.#middleware[method];
+		const routes = this.#routes[method];
+		const trie = this.#tries[method];
+		const staticMap = createNullObject();
+		const handlerData = [];
+		const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+		for (const r of [middleware, routes]) for (const path in r) {
+			const handlers = r[path];
+			const pathData = trie.paths[path];
+			if (!pathData) {
+				staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+				continue;
+			}
+			handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [h, trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+				map[key] = paramReplacementMap[pathData[1][i][1]];
+				return map;
+			}, createNullObject())]);
+		}
+		return [
+			regexp,
+			indexReplacementMap.map((i) => handlerData[i]),
+			staticMap
+		];
+	}
 };
+//#endregion
+export { RegExpRouter };

package/node_modules/hono/dist/router/reg-exp-router/trie.js

@@ -1,68 +1,73 @@
-// src/router/reg-exp-router/trie.ts
 import { createNullObject } from "../utils.js";
 import { Node } from "./node.js";
+//#region src/router/reg-exp-router/trie.ts
 var Trie = class {
-  #context = { varIndex: 0 };
-  #root = new Node();
-  #index = 0;
-  // dynamic path -> [handler index, param assoc]; static paths are not registered
-  paths = createNullObject();
-  insert(path, isStatic) {
-    if (isStatic) {
-      this.#root.insert(path.split(""), 0, [], this.#context, true);
-      return;
-    }
-    const paramAssoc = [];
-    const groups = [];
-    let markedPath = path;
-    for (let i = 0; ; ) {
-      let replaced = false;
-      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
-      }
-    }
-    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
-        }
-      }
-    }
-    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
-    this.paths[path] = [this.#index++, paramAssoc];
-  }
-  buildRegExp() {
-    let regexp = this.#root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
-    }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (handlerIndex !== void 0) {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
-      }
-      if (paramIndex !== void 0) {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
-      }
-      return "";
-    });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-  }
-};
-export {
-  Trie
+	#context = { varIndex: 0 };
+	#root = new Node();
+	#index = 0;
+	paths = createNullObject();
+	insert(path, isStatic) {
+		if (isStatic) {
+			this.#root.insert(path.split(""), 0, [], this.#context, true);
+			return;
+		}
+		const paramAssoc = [];
+		const groups = [];
+		let markedPath = path;
+		for (let i = 0;;) {
+			let replaced = false;
+			markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+				const mark = `@\\${i}`;
+				groups[i] = [mark, m];
+				i++;
+				replaced = true;
+				return mark;
+			});
+			if (!replaced) break;
+		}
+		/**
+		*  - pattern (:label, :label{0-9]+}, ...)
+		*  - /* wildcard
+		*  - character
+		*/
+		const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+		for (let i = groups.length - 1; i >= 0; i--) {
+			const [mark] = groups[i];
+			for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
+				tokens[j] = tokens[j].replace(mark, groups[i][1]);
+				break;
+			}
+		}
+		this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+		this.paths[path] = [this.#index++, paramAssoc];
+	}
+	buildRegExp() {
+		let regexp = this.#root.buildRegExpStr();
+		if (regexp === "") return [
+			/^$/,
+			[],
+			[]
+		];
+		let captureIndex = 0;
+		const indexReplacementMap = [];
+		const paramReplacementMap = [];
+		regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+			if (handlerIndex !== void 0) {
+				indexReplacementMap[++captureIndex] = Number(handlerIndex);
+				return "$()";
+			}
+			if (paramIndex !== void 0) {
+				paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+				return "";
+			}
+			return "";
+		});
+		return [
+			new RegExp(`^${regexp}`),
+			indexReplacementMap,
+			paramReplacementMap
+		];
+	}
 };
+//#endregion
+export { Trie };

package/node_modules/hono/dist/router/smart-router/index.js

@@ -1,5 +1,2 @@
-// src/router/smart-router/index.ts
 import { SmartRouter } from "./router.js";
-export {
-  SmartRouter
-};
+export { SmartRouter };