hono 4.13.9 → 4.13.11

package/dist/jsx/context.js

@@ -1,162 +1,165 @@
-// src/jsx/context.ts
-import { raw } from "../helper/html/index.js";
-import { isUntrustedObject, JSXFragmentNode, renderChildren, renderUntrustedObject } from "./base.js";
+import { raw } from "../utils/html.js";
 import { DOM_RENDERER } from "./constants.js";
 import { createContextProviderFunction } from "./dom/context.js";
-var globalContexts = [];
-var alsProbed = false;
-var asyncLocalStorage;
-var fallbackStore;
-var fallbackRendersInFlight = 0;
-var warnedFallbackDefault = false;
-var loadAsyncLocalStorage = () => {
-  if (alsProbed) {
-    return asyncLocalStorage;
-  }
-  alsProbed = true;
-  const global = globalThis;
-  let AsyncLocalStorage;
-  for (const probe of [
-    // Node.js >= 20.16, Deno, Bun, Cloudflare Workers (nodejs_compat). Property
-    // access only, so bundlers don't statically resolve `node:async_hooks`.
-    () => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage,
-    // Node.js < 20.16 has no `process.getBuiltinModule`, but a CJS entrypoint
-    // exposes the main module's `require` here.
-    () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage
-  ]) {
-    try {
-      AsyncLocalStorage = probe();
-    } catch {
-    }
-    if (AsyncLocalStorage) {
-      break;
-    }
-  }
-  if (AsyncLocalStorage) {
-    asyncLocalStorage = new AsyncLocalStorage();
-  }
-  return asyncLocalStorage;
+import { JSXFragmentNode, isUntrustedObject, renderChildren, renderUntrustedObject } from "./base.js";
+//#region src/jsx/context.ts
+const globalContexts = [];
+let alsProbed = false;
+let asyncLocalStorage;
+let fallbackStore;
+let fallbackRendersInFlight = 0;
+let warnedFallbackDefault = false;
+const loadAsyncLocalStorage = () => {
+	if (alsProbed) return asyncLocalStorage;
+	alsProbed = true;
+	const global = globalThis;
+	let AsyncLocalStorage;
+	for (const probe of [() => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage, () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage]) {
+		try {
+			AsyncLocalStorage = probe();
+		} catch {}
+		if (AsyncLocalStorage) break;
+	}
+	if (AsyncLocalStorage) asyncLocalStorage = new AsyncLocalStorage();
+	return asyncLocalStorage;
 };
-var getCurrentStore = () => {
-  return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+const getCurrentStore = () => {
+	return loadAsyncLocalStorage()?.getStore() || fallbackStore;
 };
-var warnIfStorelessAccess = () => {
-  if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
-    warnedFallbackDefault = true;
-    console.warn(
-      "hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag)."
-    );
-  }
+const warnIfStorelessAccess = () => {
+	if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
+		warnedFallbackDefault = true;
+		console.warn("hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag).");
+	}
 };
-var getContextValuesIn = (store, context) => {
-  if (!store) {
-    warnIfStorelessAccess();
-    return context.values;
-  }
-  let values = store.get(context);
-  if (!values) {
-    values = [context.values[0]];
-    store.set(context, values);
-  }
-  return values;
+const getContextValuesIn = (store, context) => {
+	if (!store) {
+		warnIfStorelessAccess();
+		return context.values;
+	}
+	let values = store.get(context);
+	if (!values) {
+		values = [context.values[0]];
+		store.set(context, values);
+	}
+	return values;
 };
-var readContextValueIn = (store, context) => {
-  if (!store) {
-    warnIfStorelessAccess();
-    return context.values.at(-1);
-  }
-  const values = store.get(context);
-  return values?.length ? values.at(-1) : context.values[0];
+const readContextValueIn = (store, context) => {
+	if (!store) {
+		warnIfStorelessAccess();
+		return context.values.at(-1);
+	}
+	const values = store.get(context);
+	return values?.length ? values.at(-1) : context.values[0];
 };
-var captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [
-  c,
-  readContextValueIn(store, c)
-]);
-var resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
-  const currentStore = getCurrentStore();
-  const valuesPerContext = contexts.map(([context, value]) => {
-    const values = getContextValuesIn(currentStore, context);
-    values.push(value);
-    return values;
-  });
-  const popContextValues = () => {
-    valuesPerContext.forEach((values) => {
-      values.pop();
-    });
-  };
-  try {
-    const result = callback();
-    if (result instanceof Promise) {
-      return result.finally(popContextValues);
-    }
-    popContextValues();
-    return result;
-  } catch (e) {
-    popContextValues();
-    throw e;
-  }
+const captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [c, readContextValueIn(store, c)]);
+const resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
+	const currentStore = getCurrentStore();
+	const valuesPerContext = contexts.map(([context, value]) => {
+		const values = getContextValuesIn(currentStore, context);
+		values.push(value);
+		return values;
+	});
+	const popContextValues = () => {
+		valuesPerContext.forEach((values) => {
+			values.pop();
+		});
+	};
+	try {
+		const result = callback();
+		if (result instanceof Promise) return result.finally(popContextValues);
+		popContextValues();
+		return result;
+	} catch (e) {
+		popContextValues();
+		throw e;
+	}
 }, store);
-var runWithRenderContext = (callback, resumeStore) => {
-  if (getCurrentStore()) {
-    return callback();
-  }
-  const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
-  const storage = loadAsyncLocalStorage();
-  if (storage) {
-    return storage.run(store, callback);
-  }
-  fallbackStore = store;
-  let result;
-  try {
-    result = callback();
-  } finally {
-    fallbackStore = void 0;
-  }
-  if (!warnedFallbackDefault && result instanceof Promise) {
-    fallbackRendersInFlight++;
-    result = result.finally(() => {
-      fallbackRendersInFlight--;
-    });
-  }
-  return result;
+/**
+* Establish the request-scoped context store for a render.
+*
+* `resumeStore` continues a suspended subtree in the same store on the fallback
+* path (ignored when `AsyncLocalStorage` is available, where isolation is
+* automatic).
+*
+* Without `AsyncLocalStorage` a render can't be followed across `await`, so the
+* store lives in `fallbackStore` only during synchronous work (mirroring
+* React's request storage). Reading context after `await` then finds no store
+* and falls back to the default value — never another request's value.
+*/
+const runWithRenderContext = (callback, resumeStore) => {
+	if (getCurrentStore()) return callback();
+	const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
+	const storage = loadAsyncLocalStorage();
+	if (storage) return storage.run(store, callback);
+	fallbackStore = store;
+	let result;
+	try {
+		result = callback();
+	} finally {
+		fallbackStore = void 0;
+	}
+	if (!warnedFallbackDefault && result instanceof Promise) {
+		fallbackRendersInFlight++;
+		result = result.finally(() => {
+			fallbackRendersInFlight--;
+		});
+	}
+	return result;
 };
-var captureRenderContext = () => {
-  const store = getCurrentStore();
-  const contexts = captureContextValues(store);
-  return (callback) => resumeWithContextValues(callback, store, contexts);
+/**
+* Capture the current render store and return a resumer that re-establishes it
+* around a deferred continuation (e.g. a re-render after a suspended promise
+* settles). Shared by every suspension point so none reimplements it.
+*/
+const captureRenderContext = () => {
+	const store = getCurrentStore();
+	const contexts = captureContextValues(store);
+	return (callback) => resumeWithContextValues(callback, store, contexts);
 };
-var createContext = (defaultValue) => {
-  const values = [defaultValue];
-  const context = ((props) => {
-    const contextValues = getContextValuesIn(getCurrentStore(), context);
-    contextValues.push(props.value);
-    let rendered;
-    try {
-      rendered = typeof props.children === "string" ? renderChildren([props.children]) : isUntrustedObject(props.children) ? renderUntrustedObject(props.children) : props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : raw("");
-    } catch (e) {
-      contextValues.pop();
-      throw e;
-    }
-    if (rendered instanceof Promise) {
-      return rendered.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
-    } else {
-      contextValues.pop();
-      return raw(rendered);
-    }
-  });
-  context.values = values;
-  context.Provider = context;
-  context[DOM_RENDERER] = createContextProviderFunction(values);
-  globalContexts.push(context);
-  return context;
+/**
+* Create a context whose value can be provided with `<Context.Provider>` and
+* read with {@link useContext}.
+*
+* Server-side renders are isolated per request, so a provided value never leaks
+* into a concurrent request — even across `await` in an async component, when
+* `AsyncLocalStorage` is available (Node.js >= 20.16, Deno, Bun, Cloudflare
+* Workers with `nodejs_compat`). Without it, reading context after `await`
+* returns the default value; synchronous components and `use()`-based
+* suspension are unaffected.
+*/
+const createContext = (defaultValue) => {
+	const values = [defaultValue];
+	const context = ((props) => {
+		const contextValues = getContextValuesIn(getCurrentStore(), context);
+		contextValues.push(props.value);
+		let rendered;
+		try {
+			rendered = typeof props.children === "string" ? renderChildren([props.children]) : isUntrustedObject(props.children) ? renderUntrustedObject(props.children) : props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : raw("");
+		} catch (e) {
+			contextValues.pop();
+			throw e;
+		}
+		if (rendered instanceof Promise) return rendered.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
+		else {
+			contextValues.pop();
+			return raw(rendered);
+		}
+	});
+	context.values = values;
+	context.Provider = context;
+	context[DOM_RENDERER] = createContextProviderFunction(values);
+	globalContexts.push(context);
+	return context;
 };
-var useContext = (context) => {
-  return readContextValueIn(getCurrentStore(), context);
-};
-export {
-  captureRenderContext,
-  createContext,
-  globalContexts,
-  runWithRenderContext,
-  useContext
+/**
+* Read the current value of a context created with {@link createContext}.
+*
+* Safe to call from async components after `await`. See {@link createContext}
+* for the per-runtime isolation guarantees.
+*/
+const useContext = (context) => {
+	return readContextValueIn(getCurrentStore(), context);
 };
+//#endregion
+export { captureRenderContext, createContext, globalContexts, runWithRenderContext, useContext };

package/dist/jsx/dom/client.js

@@ -1,53 +1,50 @@
-// src/jsx/dom/client.ts
-import { useState } from "../hooks/index.js";
 import { buildNode, renderNode } from "./render.js";
-var createRoot = (element, options = {}) => {
-  let setJsxNode = (
-    // unmounted
-    void 0
-  );
-  if (Object.keys(options).length > 0) {
-    console.warn("createRoot options are not supported yet");
-  }
-  return {
-    render(jsxNode) {
-      if (setJsxNode === null) {
-        throw new Error("Cannot update an unmounted root");
-      }
-      if (setJsxNode) {
-        setJsxNode(jsxNode);
-      } else {
-        renderNode(
-          buildNode({
-            tag: () => {
-              const [_jsxNode, _setJsxNode] = useState(jsxNode);
-              setJsxNode = _setJsxNode;
-              return _jsxNode;
-            },
-            props: {}
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          }),
-          element
-        );
-      }
-    },
-    unmount() {
-      setJsxNode?.(null);
-      setJsxNode = null;
-    }
-  };
+import { useState } from "../hooks/index.js";
+//#region src/jsx/dom/client.ts
+/**
+* Create a root object for rendering
+* @param element Render target
+* @param options Options for createRoot (not supported yet)
+* @returns Root object has `render` and `unmount` methods
+*/
+const createRoot = (element, options = {}) => {
+	let setJsxNode = void 0;
+	if (Object.keys(options).length > 0) console.warn("createRoot options are not supported yet");
+	return {
+		render(jsxNode) {
+			if (setJsxNode === null) throw new Error("Cannot update an unmounted root");
+			if (setJsxNode) setJsxNode(jsxNode);
+			else renderNode(buildNode({
+				tag: () => {
+					const [_jsxNode, _setJsxNode] = useState(jsxNode);
+					setJsxNode = _setJsxNode;
+					return _jsxNode;
+				},
+				props: {}
+			}), element);
+		},
+		unmount() {
+			setJsxNode?.(null);
+			setJsxNode = null;
+		}
+	};
 };
-var hydrateRoot = (element, reactNode, options = {}) => {
-  const root = createRoot(element, options);
-  root.render(reactNode);
-  return root;
+/**
+* Create a root object and hydrate app to the target element.
+* In hono/jsx/dom, hydrate is equivalent to render.
+* @param element Render target
+* @param reactNode A JSXNode to render
+* @param options Options for createRoot (not supported yet)
+* @returns Root object has `render` and `unmount` methods
+*/
+const hydrateRoot = (element, reactNode, options = {}) => {
+	const root = createRoot(element, options);
+	root.render(reactNode);
+	return root;
 };
 var client_default = {
-  createRoot,
-  hydrateRoot
-};
-export {
-  createRoot,
-  client_default as default,
-  hydrateRoot
+	createRoot,
+	hydrateRoot
 };
+//#endregion
+export { createRoot, client_default as default, hydrateRoot };

package/dist/jsx/dom/components.js

@@ -1,32 +1,24 @@
-// src/jsx/dom/components.ts
 import { DOM_ERROR_HANDLER } from "../constants.js";
-import { Fragment } from "./jsx-runtime.js";
-var ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
-  const res = Fragment({ children });
-  res[DOM_ERROR_HANDLER] = (err) => {
-    if (err instanceof Promise) {
-      throw err;
-    }
-    onError?.(err);
-    return fallbackRender?.(err) || fallback;
-  };
-  return res;
+import { Fragment } from "./jsx-dev-runtime.js";
+import "./jsx-runtime.js";
+//#region src/jsx/dom/components.ts
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err) => {
+		if (err instanceof Promise) throw err;
+		onError?.(err);
+		return fallbackRender?.(err) || fallback;
+	};
+	return res;
 });
-var Suspense = (({
-  children,
-  fallback
-}) => {
-  const res = Fragment({ children });
-  res[DOM_ERROR_HANDLER] = (err, retry) => {
-    if (!(err instanceof Promise)) {
-      throw err;
-    }
-    err.finally(retry);
-    return fallback;
-  };
-  return res;
+const Suspense = (({ children, fallback }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err, retry) => {
+		if (!(err instanceof Promise)) throw err;
+		err.finally(retry);
+		return fallback;
+	};
+	return res;
 });
-export {
-  ErrorBoundary,
-  Suspense
-};
+//#endregion
+export { ErrorBoundary, Suspense };

package/dist/jsx/dom/context.js

@@ -1,48 +1,41 @@
-// src/jsx/dom/context.ts
 import { DOM_ERROR_HANDLER } from "../constants.js";
-import { globalContexts } from "../context.js";
 import { setInternalTagFlag } from "./utils.js";
-var createContextProviderFunction = (values) => ({ value, children }) => {
-  if (!children) {
-    return void 0;
-  }
-  const props = {
-    children: [
-      {
-        tag: setInternalTagFlag(() => {
-          values.push(value);
-        }),
-        props: {}
-      }
-    ]
-  };
-  if (Array.isArray(children)) {
-    props.children.push(...children.flat());
-  } else {
-    props.children.push(children);
-  }
-  props.children.push({
-    tag: setInternalTagFlag(() => {
-      values.pop();
-    }),
-    props: {}
-  });
-  const res = { tag: "", props, type: "" };
-  res[DOM_ERROR_HANDLER] = (err) => {
-    values.pop();
-    throw err;
-  };
-  return res;
-};
-var createContext = (defaultValue) => {
-  const values = [defaultValue];
-  const context = createContextProviderFunction(values);
-  context.values = values;
-  context.Provider = context;
-  globalContexts.push(context);
-  return context;
+import { globalContexts } from "../context.js";
+//#region src/jsx/dom/context.ts
+const createContextProviderFunction = (values) => ({ value, children }) => {
+	if (!children) return;
+	const props = { children: [{
+		tag: setInternalTagFlag(() => {
+			values.push(value);
+		}),
+		props: {}
+	}] };
+	if (Array.isArray(children)) props.children.push(...children.flat());
+	else props.children.push(children);
+	props.children.push({
+		tag: setInternalTagFlag(() => {
+			values.pop();
+		}),
+		props: {}
+	});
+	const res = {
+		tag: "",
+		props,
+		type: ""
+	};
+	res[DOM_ERROR_HANDLER] = (err) => {
+		values.pop();
+		throw err;
+	};
+	return res;
 };
-export {
-  createContext,
-  createContextProviderFunction
+const createContext = (defaultValue) => {
+	const values = [defaultValue];
+	const context = createContextProviderFunction(values);
+	context.values = values;
+	context.Provider = context;
+	globalContexts.push(context);
+	return context;
 };
+//#endregion
+export { createContext, createContextProviderFunction };