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

package/node_modules/hono/dist/helper/proxy/index.js

@@ -1,93 +1,121 @@
-// src/helper/proxy/index.ts
 import { HTTPException } from "../../http-exception.js";
-var hopByHopHeaders = [
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
+//#region src/helper/proxy/index.ts
+/**
+* @module
+* Proxy Helper for Hono.
+*/
+const hopByHopHeaders = [
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
 ];
-var ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
-var buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
-  if (!request) {
-    return {};
-  }
-  const headers = new Headers(request.headers);
-  if (strictConnectionProcessing) {
-    const connectionValue = headers.get("connection");
-    if (connectionValue) {
-      const headerNames = connectionValue.split(",").map((h) => h.trim());
-      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
-      if (invalidHeaders.length > 0) {
-        throw new HTTPException(400, {
-          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
-        });
-      }
-      headerNames.forEach((headerName) => {
-        headers.delete(headerName);
-      });
-    }
-  }
-  hopByHopHeaders.forEach((header) => {
-    headers.delete(header);
-  });
-  return {
-    method: request.method,
-    body: request.body,
-    duplex: request.body ? "half" : void 0,
-    headers,
-    signal: request.signal
-  };
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+	if (!request) return {};
+	const headers = new Headers(request.headers);
+	if (strictConnectionProcessing) {
+		const connectionValue = headers.get("connection");
+		if (connectionValue) {
+			const headerNames = connectionValue.split(",").map((h) => h.trim());
+			const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+			if (invalidHeaders.length > 0) throw new HTTPException(400, { message: `Invalid Connection header value: ${invalidHeaders.join(", ")}` });
+			headerNames.forEach((headerName) => {
+				headers.delete(headerName);
+			});
+		}
+	}
+	hopByHopHeaders.forEach((header) => {
+		headers.delete(header);
+	});
+	return {
+		method: request.method,
+		body: request.body,
+		duplex: request.body ? "half" : void 0,
+		headers,
+		signal: request.signal
+	};
 };
-var preprocessRequestInit = (requestInit) => {
-  if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) {
-    return requestInit;
-  }
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(requestInit.headers)) {
-    if (value == null) {
-      headers.delete(key);
-    } else {
-      headers.set(key, value);
-    }
-  }
-  requestInit.headers = headers;
-  return requestInit;
+const preprocessRequestInit = (requestInit) => {
+	if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) return requestInit;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(requestInit.headers)) if (value == null) headers.delete(key);
+	else headers.set(key, value);
+	requestInit.headers = headers;
+	return requestInit;
 };
-var proxy = async (input, proxyInit) => {
-  const {
-    raw,
-    customFetch,
-    strictConnectionProcessing = false,
-    ...requestInit
-  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
-  const req = new Request(input, {
-    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
-    ...preprocessRequestInit(requestInit)
-  });
-  req.headers.delete("accept-encoding");
-  const res = await (customFetch || fetch)(req);
-  const resHeaders = new Headers(res.headers);
-  const connectionValue = resHeaders.get("connection");
-  if (connectionValue) {
-    connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
-  }
-  hopByHopHeaders.forEach((header) => {
-    resHeaders.delete(header);
-  });
-  if (resHeaders.has("content-encoding")) {
-    resHeaders.delete("content-encoding");
-    resHeaders.delete("content-length");
-  }
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers: resHeaders
-  });
-};
-export {
-  proxy
+/**
+* Fetch API wrapper for proxy.
+* The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+*
+* The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
+* Unnecessary response headers are deleted and a Response object is returned that can be returned
+* as is as a response from the handler.
+*
+* @example
+* ```ts
+* app.get('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     headers: {
+*       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   }).then((res) => {
+*     res.headers.delete('Set-Cookie')
+*     return res
+*   })
+* })
+*
+* app.all('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*     headers: {
+*       ...c.req.header(),
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   })
+* })
+*
+* // Strict RFC compliance mode (use only in trusted environments)
+* app.get('/internal-proxy/:path', (c) => {
+*   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+*     ...c.req,
+*     strictConnectionProcessing: true,
+*   })
+* })
+* ```
+*/
+const proxy = async (input, proxyInit) => {
+	const { raw, customFetch, strictConnectionProcessing = false, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+	const req = new Request(input, {
+		...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+		...preprocessRequestInit(requestInit)
+	});
+	req.headers.delete("accept-encoding");
+	const res = await (customFetch || fetch)(req);
+	const resHeaders = new Headers(res.headers);
+	const connectionValue = resHeaders.get("connection");
+	if (connectionValue) connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
+	hopByHopHeaders.forEach((header) => {
+		resHeaders.delete(header);
+	});
+	if (resHeaders.has("content-encoding")) {
+		resHeaders.delete("content-encoding");
+		resHeaders.delete("content-length");
+	}
+	return new Response(res.body, {
+		status: res.status,
+		statusText: res.statusText,
+		headers: resHeaders
+	});
 };
+//#endregion
+export { proxy };

package/node_modules/hono/dist/helper/route/index.js

@@ -1,46 +1,124 @@
-// src/helper/route/index.ts
 import { GET_MATCH_RESULT } from "../../request/constants.js";
 import { getPattern, splitRoutingPath } from "../../utils/url.js";
-var matchedRoutes = (c) => (
-  // @ts-expect-error c.req[GET_MATCH_RESULT] is not typed
-  c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route)
-);
-var routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
-var baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
-var basePathCacheMap = /* @__PURE__ */ new WeakMap();
-var basePath = (c, index) => {
-  index ??= c.req.routeIndex;
-  const cache = basePathCacheMap.get(c) || [];
-  if (typeof cache[index] === "string") {
-    return cache[index];
-  }
-  let result;
-  const rp = baseRoutePath(c, index);
-  if (!/[:*]/.test(rp)) {
-    result = rp;
-  } else {
-    const paths = splitRoutingPath(rp);
-    const reqPath = c.req.path;
-    let basePathLength = 0;
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const pattern = getPattern(paths[i], paths[i + 1]);
-      if (pattern) {
-        const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
-        basePathLength += reqPath.substring(basePathLength + 1).match(re)?.[0].length || 0;
-      } else {
-        basePathLength += paths[i].length;
-      }
-      basePathLength += 1;
-    }
-    result = reqPath.substring(0, basePathLength);
-  }
-  cache[index] = result;
-  basePathCacheMap.set(c, cache);
-  return result;
-};
-export {
-  basePath,
-  baseRoutePath,
-  matchedRoutes,
-  routePath
+//#region src/helper/route/index.ts
+/**
+* Get matched routes in the handler
+*
+* @param {Context} c - The context object
+* @returns An array of matched routes
+*
+* @example
+* ```ts
+* import { matchedRoutes } from 'hono/route'
+*
+* app.use('*', async function logger(c, next) {
+*   await next()
+*   matchedRoutes(c).forEach(({ handler, method, path }, i) => {
+*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+*     console.log(
+*       method,
+*       ' ',
+*       path,
+*       ' '.repeat(Math.max(10 - path.length, 0)),
+*       name,
+*       i === c.req.routeIndex ? '<- respond from here' : ''
+*     )
+*   })
+* })
+* ```
+*/
+const matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
+/**
+* Get the route path registered within the handler
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The route path registered within the handler
+*
+* @example
+* ```ts
+* import { routePath } from 'hono/route'
+*
+* app.use('*', (c, next) => {
+*   console.log(routePath(c)) // '*'
+*   console.log(routePath(c, -1)) // '/posts/:id'
+*   return next()
+* })
+*
+* app.get('/posts/:id', (c) => {
+*   return c.text(routePath(c)) // '/posts/:id'
+* })
+* ```
+*/
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+/**
+* Get the basePath of the as-is route specified by routing.
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath of the as-is route specified by routing.
+*
+* @example
+* ```ts
+* import { baseRoutePath } from 'hono/route'
+*
+* const app = new Hono()
+*
+* const subApp = new Hono()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(baseRoutePath(c)) // '/:sub'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+/**
+* Get the basePath with embedded parameters
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath with embedded parameters.
+*
+* @example
+* ```ts
+* import { basePath } from 'hono/route'
+*
+* const app = new Hono()
+*
+* const subApp = new Hono()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(basePath(c)) // '/requested-sub-app-path'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c, index) => {
+	index ??= c.req.routeIndex;
+	const cache = basePathCacheMap.get(c) || [];
+	if (typeof cache[index] === "string") return cache[index];
+	let result;
+	const rp = baseRoutePath(c, index);
+	if (!/[:*]/.test(rp)) result = rp;
+	else {
+		const paths = splitRoutingPath(rp);
+		const reqPath = c.req.path;
+		let basePathLength = 0;
+		for (let i = 0, len = paths.length; i < len; i++) {
+			const pattern = getPattern(paths[i], paths[i + 1]);
+			if (pattern) {
+				const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+				basePathLength += reqPath.substring(basePathLength + 1).match(re)?.[0].length || 0;
+			} else basePathLength += paths[i].length;
+			basePathLength += 1;
+		}
+		result = reqPath.substring(0, basePathLength);
+	}
+	cache[index] = result;
+	basePathCacheMap.set(c, cache);
+	return result;
 };
+//#endregion
+export { basePath, baseRoutePath, matchedRoutes, routePath };

package/node_modules/hono/dist/helper/ssg/index.js

@@ -1,19 +1,4 @@
-// src/helper/ssg/index.ts
-export * from "./ssg.js";
-import {
-  X_HONO_DISABLE_SSG_HEADER_KEY,
-  ssgParams,
-  isSSGContext,
-  disableSSG,
-  onlySSG
-} from "./middleware.js";
+import { X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams } from "./middleware.js";
 import { defaultPlugin, redirectPlugin } from "./plugins.js";
-export {
-  X_HONO_DISABLE_SSG_HEADER_KEY,
-  defaultPlugin,
-  disableSSG,
-  isSSGContext,
-  onlySSG,
-  redirectPlugin,
-  ssgParams
-};
+import { DEFAULT_OUTPUT_DIR, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, fetchRoutesContent, saveContentToFile, toSSG } from "./ssg.js";
+export { DEFAULT_OUTPUT_DIR, X_HONO_DISABLE_SSG_HEADER_KEY, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, defaultPlugin, disableSSG, fetchRoutesContent, isSSGContext, onlySSG, redirectPlugin, saveContentToFile, ssgParams, toSSG };

package/node_modules/hono/dist/helper/ssg/middleware.js

@@ -1,45 +1,58 @@
-// src/helper/ssg/middleware.ts
 import { isDynamicRoute } from "./utils.js";
-var SSG_CONTEXT = "HONO_SSG_CONTEXT";
-var X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
-var SSG_DISABLED_RESPONSE = (() => {
-  try {
-    return new Response("SSG is disabled", {
-      status: 404,
-      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
-    });
-  } catch {
-    return null;
-  }
+//#region src/helper/ssg/middleware.ts
+const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+const X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+/**
+* @deprecated
+* Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
+* This constant will be removed in the next minor version.
+*/
+const SSG_DISABLED_RESPONSE = (() => {
+	try {
+		return new Response("SSG is disabled", {
+			status: 404,
+			headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+		});
+	} catch {
+		return null;
+	}
 })();
-var ssgParams = (params) => async (c, next) => {
-  if (isDynamicRoute(c.req.path)) {
-    ;
-    c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
-    return c.notFound();
-  }
-  await next();
+/**
+* Define SSG Route
+*/
+const ssgParams = (params) => async (c, next) => {
+	if (isDynamicRoute(c.req.path)) {
+		c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+		return c.notFound();
+	}
+	await next();
 };
-var isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
-var disableSSG = () => async function disableSSG2(c, next) {
-  if (isSSGContext(c)) {
-    c.header(X_HONO_DISABLE_SSG_HEADER_KEY, "true");
-    return c.notFound();
-  }
-  await next();
+/**
+* @experimental
+* `isSSGContext` is an experimental feature.
+* The API might be changed.
+*/
+const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+/**
+* @experimental
+* `disableSSG` is an experimental feature.
+* The API might be changed.
+*/
+const disableSSG = () => async function disableSSG(c, next) {
+	if (isSSGContext(c)) {
+		c.header(X_HONO_DISABLE_SSG_HEADER_KEY, "true");
+		return c.notFound();
+	}
+	await next();
 };
-var onlySSG = () => async function onlySSG2(c, next) {
-  if (!isSSGContext(c)) {
-    return c.notFound();
-  }
-  await next();
-};
-export {
-  SSG_CONTEXT,
-  SSG_DISABLED_RESPONSE,
-  X_HONO_DISABLE_SSG_HEADER_KEY,
-  disableSSG,
-  isSSGContext,
-  onlySSG,
-  ssgParams
+/**
+* @experimental
+* `onlySSG` is an experimental feature.
+* The API might be changed.
+*/
+const onlySSG = () => async function onlySSG(c, next) {
+	if (!isSSGContext(c)) return c.notFound();
+	await next();
 };
+//#endregion
+export { SSG_CONTEXT, SSG_DISABLED_RESPONSE, X_HONO_DISABLE_SSG_HEADER_KEY, disableSSG, isSSGContext, onlySSG, ssgParams };

package/node_modules/hono/dist/helper/ssg/plugins.js

@@ -1,18 +1,27 @@
-// src/helper/ssg/plugins.ts
 import { html } from "../html/index.js";
-var defaultPlugin = () => {
-  return {
-    afterResponseHook: (res) => {
-      if (res.status !== 200) {
-        return false;
-      }
-      return res;
-    }
-  };
+//#region src/helper/ssg/plugins.ts
+/**
+* The default plugin that defines the recommended behavior.
+*
+* @experimental
+* `defaultPlugin` is an experimental feature.
+* The API might be changed.
+*/
+const defaultPlugin = () => {
+	return { afterResponseHook: (res) => {
+		if (res.status !== 200) return false;
+		return res;
+	} };
 };
-var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-var generateRedirectHtml = (location) => {
-  const content = html`<!DOCTYPE html>
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const generateRedirectHtml = (location) => {
+	return html`<!DOCTYPE html>
 <title>Redirecting to: ${location}</title>
 <meta http-equiv="refresh" content="0;url=${location}" />
 <meta name="robots" content="noindex" />
@@ -20,28 +29,38 @@ var generateRedirectHtml = (location) => {
 <body>
 <a href="${location}">Redirecting to <code>${location}</code></a>
 </body>
-`;
-  return content.toString().replace(/\n/g, "");
+`.toString().replace(/\n/g, "");
 };
-var redirectPlugin = () => {
-  return {
-    afterResponseHook: (res) => {
-      if (REDIRECT_STATUS_CODES.has(res.status)) {
-        const location = res.headers.get("Location");
-        if (!location) {
-          return false;
-        }
-        const htmlBody = generateRedirectHtml(location);
-        return new Response(htmlBody, {
-          status: 200,
-          headers: { "Content-Type": "text/html; charset=utf-8" }
-        });
-      }
-      return res;
-    }
-  };
-};
-export {
-  defaultPlugin,
-  redirectPlugin
+/**
+* The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+*
+* When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+*
+* ```ts
+* // ✅ Will work as expected
+* toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+*
+* // ❌ Will not work as expected
+* toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+* ```
+*
+* @experimental
+* `redirectPlugin` is an experimental feature.
+* The API might be changed.
+*/
+const redirectPlugin = () => {
+	return { afterResponseHook: (res) => {
+		if (REDIRECT_STATUS_CODES.has(res.status)) {
+			const location = res.headers.get("Location");
+			if (!location) return false;
+			const htmlBody = generateRedirectHtml(location);
+			return new Response(htmlBody, {
+				status: 200,
+				headers: { "Content-Type": "text/html; charset=utf-8" }
+			});
+		}
+		return res;
+	} };
 };
+//#endregion
+export { defaultPlugin, redirectPlugin };