@nocobase/plugin-mcp-server 2.3.0-beta.12 → 2.3.0-beta.14

package/dist/node_modules/hono/dist/jsx/components.js

@@ -1,91 +1,83 @@
-// src/jsx/components.ts
-import { raw } from "../helper/html/index.js";
-import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
-import { jsx, Fragment } from "./base.js";
+import { HtmlEscapedCallbackPhase, raw, resolveCallback } from "../utils/html.js";
 import { DOM_RENDERER } from "./constants.js";
-import { useContext } from "./context.js";
-import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
+import { captureRenderContext, useContext } from "./context.js";
+import { Fragment, isUntrustedObject, jsx, renderChildren, renderUntrustedObject } from "./base.js";
+import { ErrorBoundary as ErrorBoundary$1 } from "./dom/components.js";
 import { StreamingContext } from "./streaming.js";
-var errorBoundaryCounter = 0;
-var childrenToString = async (children) => {
-  try {
-    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
-  } catch (e) {
-    if (e instanceof Promise) {
-      await e;
-      return childrenToString(children);
-    } else {
-      throw e;
-    }
-  }
+//#region src/jsx/components.ts
+let errorBoundaryCounter = 0;
+const childrenToString = async (children) => {
+	try {
+		return children.flat().map(resolveChildEarly);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			await e;
+			return resume(() => childrenToString(children));
+		} else throw e;
+	}
 };
-var resolveChildEarly = (c) => {
-  if (c == null || typeof c === "boolean") {
-    return "";
-  } else if (typeof c === "string") {
-    return c;
-  } else {
-    const str = c.toString();
-    if (!(str instanceof Promise)) {
-      return raw(str);
-    } else {
-      return str;
-    }
-  }
+const resolveChildEarly = (child) => {
+	if (child == null || typeof child === "boolean") return "";
+	else if (typeof child === "string" || Array.isArray(child)) return renderChildren([child]);
+	else if (isUntrustedObject(child)) return renderUntrustedObject(child);
+	else {
+		const str = child.toString();
+		return str instanceof Promise ? str : raw(str);
+	}
 };
-var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
-  if (!children) {
-    return raw("");
-  }
-  if (!Array.isArray(children)) {
-    children = [children];
-  }
-  const nonce = useContext(StreamingContext)?.scriptNonce;
-  let fallbackStr;
-  const resolveFallbackStr = async () => {
-    const awaitedFallback = await fallback;
-    if (typeof awaitedFallback === "string") {
-      fallbackStr = awaitedFallback;
-    } else {
-      fallbackStr = await awaitedFallback?.toString();
-      if (typeof fallbackStr === "string") {
-        fallbackStr = raw(fallbackStr);
-      }
-    }
-  };
-  const fallbackRes = (error) => {
-    onError?.(error);
-    return fallbackStr || fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
-  };
-  let resArray = [];
-  try {
-    resArray = children.map(resolveChildEarly);
-  } catch (e) {
-    await resolveFallbackStr();
-    if (e instanceof Promise) {
-      resArray = [
-        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
-      ];
-    } else {
-      resArray = [fallbackRes(e)];
-    }
-  }
-  if (resArray.some((res) => res instanceof Promise)) {
-    await resolveFallbackStr();
-    const index = errorBoundaryCounter++;
-    const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
-    const caught = false;
-    const catchCallback = async ({ error: error2, buffer }) => {
-      if (caught) {
-        return "";
-      }
-      const fallbackResString = await Fragment({
-        children: fallbackRes(error2)
-      }).toString();
-      if (buffer) {
-        buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
-      }
-      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+/**
+* @experimental
+* `ErrorBoundary` is an experimental feature.
+* The API might be changed.
+*/
+const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
+	if (!children) return raw("");
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resume;
+	const getResume = () => resume ||= captureRenderContext();
+	let fallbackStrPromise;
+	const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
+		const awaitedFallback = await fallback;
+		if (awaitedFallback === null || awaitedFallback === void 0) return;
+		if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) return getResume()(() => renderChildren([awaitedFallback]));
+		if (isUntrustedObject(awaitedFallback)) return getResume()(() => renderUntrustedObject(awaitedFallback));
+		const fallbackResult = await getResume()(() => awaitedFallback.toString());
+		return raw(fallbackResult, fallbackResult.callbacks || awaitedFallback.callbacks);
+	})();
+	const renderFallback = async (error) => {
+		const fallbackStr = await resolveFallbackStr();
+		return getResume()(async () => {
+			onError?.(error);
+			const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+			const fallbackResString = await Fragment({ children: fallbackRes }).toString();
+			return raw(fallbackResString, fallbackResString.callbacks || fallbackRes.callbacks);
+		});
+	};
+	let resArray = [];
+	try {
+		resArray = children.map(resolveChildEarly);
+	} catch (e) {
+		const resume = getResume();
+		if (e instanceof Promise) resArray = [e.then(() => resume(() => childrenToString(children))).catch((e) => renderFallback(e))];
+		else resArray = [await renderFallback(e)];
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		getResume();
+		const index = errorBoundaryCounter++;
+		const replaceRe = RegExp(`(<template id="E:${index}"></template>)(.*?)(<!--E:${index}-->)`, "s");
+		let caught = false;
+		const catchCallback = async ({ error, buffer }) => {
+			if (caught) return "";
+			caught = true;
+			const fallbackResString = await renderFallback(error);
+			const fallbackCallbacks = fallbackResString.callbacks;
+			if (buffer) {
+				buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
+				return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
+			}
+			return raw(`<template data-hono-target="E:${index}">${fallbackResString}</template><script>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
@@ -93,63 +85,40 @@ if(!d)return
 do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
 d.replaceWith(c.content)
 })(document)
-</script>`;
-    };
-    let error;
-    const promiseAll = Promise.all(resArray).catch((e) => error = e);
-    return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [
-      ({ phase, buffer, context }) => {
-        if (phase === HtmlEscapedCallbackPhase.BeforeStream) {
-          return;
-        }
-        return promiseAll.then(async (htmlArray) => {
-          if (error) {
-            throw error;
-          }
-          htmlArray = htmlArray.flat();
-          const content = htmlArray.join("");
-          let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+<\/script>`, fallbackCallbacks);
+		};
+		let error;
+		const promiseAll = Promise.all(resArray).catch((e) => error = e);
+		return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return promiseAll.then(async (htmlArray) => {
+				if (error) throw error;
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				let html = buffer ? "" : `<template data-hono-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
 ((d,c) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
 if(!d)return
 d.parentElement.insertBefore(c.content,d.nextSibling)
 })(document)
-</script>`;
-          if (htmlArray.every((html2) => !html2.callbacks?.length)) {
-            if (buffer) {
-              buffer[0] = buffer[0].replace(replaceRe, content);
-            }
-            return html;
-          }
-          if (buffer) {
-            buffer[0] = buffer[0].replace(
-              replaceRe,
-              (_all, pre, _, post) => `${pre}${content}${post}`
-            );
-          }
-          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
-          if (phase === HtmlEscapedCallbackPhase.Stream) {
-            html = await resolveCallback(
-              html,
-              HtmlEscapedCallbackPhase.BeforeStream,
-              true,
-              context
-            );
-          }
-          let resolvedCount = 0;
-          const promises = callbacks.map(
-            (c) => (...args) => c(...args)?.then((content2) => {
-              resolvedCount++;
-              if (buffer) {
-                if (resolvedCount === callbacks.length) {
-                  buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content3) => content3);
-                }
-                buffer[0] += content2;
-                return raw("", content2.callbacks);
-              }
-              return raw(
-                content2 + (resolvedCount !== callbacks.length ? "" : `<script>
+<\/script>`;
+				if (htmlArray.every((html) => !html.callbacks?.length)) {
+					if (buffer) buffer[0] = buffer[0].replace(replaceRe, () => content);
+					return html;
+				}
+				if (buffer) buffer[0] = buffer[0].replace(replaceRe, (_all, pre, _, post) => `${pre}${content}${post}`);
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				let resolvedCount = 0;
+				const promises = callbacks.map((c) => (...args) => c(...args)?.then((content) => {
+					resolvedCount++;
+					if (buffer) {
+						if (resolvedCount === callbacks.length) buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content) => content);
+						buffer[0] += content;
+						return raw("", content.callbacks);
+					}
+					return raw(content + (resolvedCount !== callbacks.length ? "" : `<script>
 ((d,c,n) => {
 d=d.getElementById('E:${index}')
 if(!d)return
@@ -158,21 +127,19 @@ while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
 n.remove()
 d.remove()
 })(document)
-</script>`),
-                content2.callbacks
-              );
-            }).catch((error2) => catchCallback({ error: error2, buffer }))
-          );
-          return raw(html, promises);
-        }).catch((error2) => catchCallback({ error: error2, buffer }));
-      }
-    ]);
-  } else {
-    return Fragment({ children: resArray });
-  }
-};
-ErrorBoundary[DOM_RENDERER] = ErrorBoundaryDomRenderer;
-export {
-  ErrorBoundary,
-  childrenToString
+<\/script>`), content.callbacks);
+				}).catch((error) => catchCallback({
+					error,
+					buffer
+				})));
+				return raw(html, promises);
+			}).catch((error) => catchCallback({
+				error,
+				buffer
+			}));
+		}]);
+	} else return Fragment({ children: resArray });
 };
+ErrorBoundary[DOM_RENDERER] = ErrorBoundary$1;
+//#endregion
+export { ErrorBoundary, childrenToString };

package/dist/node_modules/hono/dist/jsx/constants.js

@@ -1,15 +1,9 @@
-// src/jsx/constants.ts
-var DOM_RENDERER = /* @__PURE__ */ Symbol("RENDERER");
-var DOM_ERROR_HANDLER = /* @__PURE__ */ Symbol("ERROR_HANDLER");
-var DOM_STASH = /* @__PURE__ */ Symbol("STASH");
-var DOM_INTERNAL_TAG = /* @__PURE__ */ Symbol("INTERNAL");
-var DOM_MEMO = /* @__PURE__ */ Symbol("MEMO");
-var PERMALINK = /* @__PURE__ */ Symbol("PERMALINK");
-export {
-  DOM_ERROR_HANDLER,
-  DOM_INTERNAL_TAG,
-  DOM_MEMO,
-  DOM_RENDERER,
-  DOM_STASH,
-  PERMALINK
-};
+//#region src/jsx/constants.ts
+const DOM_RENDERER = Symbol("RENDERER");
+const DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
+const DOM_STASH = Symbol("STASH");
+const DOM_INTERNAL_TAG = Symbol("INTERNAL");
+const DOM_MEMO = Symbol("MEMO");
+const PERMALINK = Symbol("PERMALINK");
+//#endregion
+export { DOM_ERROR_HANDLER, DOM_INTERNAL_TAG, DOM_MEMO, DOM_RENDERER, DOM_STASH, PERMALINK };

package/dist/node_modules/hono/dist/jsx/context.js

@@ -1,38 +1,165 @@
-// src/jsx/context.ts
-import { raw } from "../helper/html/index.js";
-import { JSXFragmentNode } from "./base.js";
+import { raw } from "../utils/html.js";
 import { DOM_RENDERER } from "./constants.js";
 import { createContextProviderFunction } from "./dom/context.js";
-var globalContexts = [];
-var createContext = (defaultValue) => {
-  const values = [defaultValue];
-  const context = ((props) => {
-    values.push(props.value);
-    let string;
-    try {
-      string = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
-    } catch (e) {
-      values.pop();
-      throw e;
-    }
-    if (string instanceof Promise) {
-      return string.finally(() => values.pop()).then((resString) => raw(resString, resString.callbacks));
-    } else {
-      values.pop();
-      return raw(string);
-    }
-  });
-  context.values = values;
-  context.Provider = context;
-  context[DOM_RENDERER] = createContextProviderFunction(values);
-  globalContexts.push(context);
-  return context;
-};
-var useContext = (context) => {
-  return context.values.at(-1);
-};
-export {
-  createContext,
-  globalContexts,
-  useContext
+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;
 };
+const getCurrentStore = () => {
+	return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+};
+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).");
+	}
+};
+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;
+};
+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];
+};
+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);
+/**
+* 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;
+};
+/**
+* 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);
+};
+/**
+* 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;
+};
+/**
+* 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/node_modules/hono/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 };