@depup/hono 4.12.8-depup.0

package/dist/jsx/base.js

@@ -0,0 +1,331 @@
+// src/jsx/base.ts
+import { raw } from "../helper/html/index.js";
+import { escapeToBuffer, resolveCallbackSync, stringBufferToString } from "../utils/html.js";
+import { DOM_RENDERER, DOM_MEMO } from "./constants.js";
+import { createContext, globalContexts, useContext } from "./context.js";
+import { domRenderers } from "./intrinsic-element/common.js";
+import * as intrinsicElementTags from "./intrinsic-element/components.js";
+import { normalizeIntrinsicElementKey, styleObjectForEach } from "./utils.js";
+var nameSpaceContext = void 0;
+var getNameSpaceContext = () => nameSpaceContext;
+var toSVGAttributeName = (key) => /[A-Z]/.test(key) && // Presentation attributes are findable in style object. "clip-path", "font-size", "stroke-width", etc.
+// Or other un-deprecated kebab-case attributes. "overline-position", "paint-order", "strikethrough-position", etc.
+key.match(
+  /^(?:al|basel|clip(?:Path|Rule)$|co|do|fill|fl|fo|gl|let|lig|i|marker[EMS]|o|pai|pointe|sh|st[or]|text[^L]|tr|u|ve|w)/
+) ? key.replace(/([A-Z])/g, "-$1").toLowerCase() : key;
+var emptyTags = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var booleanAttributes = [
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "download",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+];
+var childrenToStringToBuffer = (children, buffer) => {
+  for (let i = 0, len = children.length; i < len; i++) {
+    const child = children[i];
+    if (typeof child === "string") {
+      escapeToBuffer(child, buffer);
+    } else if (typeof child === "boolean" || child === null || child === void 0) {
+      continue;
+    } else if (child instanceof JSXNode) {
+      child.toStringToBuffer(buffer);
+    } else if (typeof child === "number" || child.isEscaped) {
+      ;
+      buffer[0] += child;
+    } else if (child instanceof Promise) {
+      buffer.unshift("", child);
+    } else {
+      childrenToStringToBuffer(child, buffer);
+    }
+  }
+};
+var JSXNode = class {
+  tag;
+  props;
+  key;
+  children;
+  isEscaped = true;
+  localContexts;
+  constructor(tag, props, children) {
+    this.tag = tag;
+    this.props = props;
+    this.children = children;
+  }
+  get type() {
+    return this.tag;
+  }
+  // Added for compatibility with libraries that rely on React's internal structure
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get ref() {
+    return this.props.ref || null;
+  }
+  toString() {
+    const buffer = [""];
+    this.localContexts?.forEach(([context, value]) => {
+      context.values.push(value);
+    });
+    try {
+      this.toStringToBuffer(buffer);
+    } finally {
+      this.localContexts?.forEach(([context]) => {
+        context.values.pop();
+      });
+    }
+    return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
+  }
+  toStringToBuffer(buffer) {
+    const tag = this.tag;
+    const props = this.props;
+    let { children } = this;
+    buffer[0] += `<${tag}`;
+    const normalizeKey = nameSpaceContext && useContext(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName(normalizeIntrinsicElementKey(key)) : (key) => normalizeIntrinsicElementKey(key);
+    for (let [key, v] of Object.entries(props)) {
+      key = normalizeKey(key);
+      if (key === "children") {
+      } else if (key === "style" && typeof v === "object") {
+        let styleStr = "";
+        styleObjectForEach(v, (property, value) => {
+          if (value != null) {
+            styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+          }
+        });
+        buffer[0] += ' style="';
+        escapeToBuffer(styleStr, buffer);
+        buffer[0] += '"';
+      } else if (typeof v === "string") {
+        buffer[0] += ` ${key}="`;
+        escapeToBuffer(v, buffer);
+        buffer[0] += '"';
+      } else if (v === null || v === void 0) {
+      } else if (typeof v === "number" || v.isEscaped) {
+        buffer[0] += ` ${key}="${v}"`;
+      } else if (typeof v === "boolean" && booleanAttributes.includes(key)) {
+        if (v) {
+          buffer[0] += ` ${key}=""`;
+        }
+      } else if (key === "dangerouslySetInnerHTML") {
+        if (children.length > 0) {
+          throw new Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
+        }
+        children = [raw(v.__html)];
+      } else if (v instanceof Promise) {
+        buffer[0] += ` ${key}="`;
+        buffer.unshift('"', v);
+      } else if (typeof v === "function") {
+        if (!key.startsWith("on") && key !== "ref") {
+          throw new Error(`Invalid prop '${key}' of type 'function' supplied to '${tag}'.`);
+        }
+      } else {
+        buffer[0] += ` ${key}="`;
+        escapeToBuffer(v.toString(), buffer);
+        buffer[0] += '"';
+      }
+    }
+    if (emptyTags.includes(tag) && children.length === 0) {
+      buffer[0] += "/>";
+      return;
+    }
+    buffer[0] += ">";
+    childrenToStringToBuffer(children, buffer);
+    buffer[0] += `</${tag}>`;
+  }
+};
+var JSXFunctionNode = class extends JSXNode {
+  toStringToBuffer(buffer) {
+    const { children } = this;
+    const props = { ...this.props };
+    if (children.length) {
+      props.children = children.length === 1 ? children[0] : children;
+    }
+    const res = this.tag.call(null, props);
+    if (typeof res === "boolean" || res == null) {
+      return;
+    } else if (res instanceof Promise) {
+      if (globalContexts.length === 0) {
+        buffer.unshift("", res);
+      } else {
+        const currentContexts = globalContexts.map((c) => [c, c.values.at(-1)]);
+        buffer.unshift(
+          "",
+          res.then((childRes) => {
+            if (childRes instanceof JSXNode) {
+              childRes.localContexts = currentContexts;
+            }
+            return childRes;
+          })
+        );
+      }
+    } else if (res instanceof JSXNode) {
+      res.toStringToBuffer(buffer);
+    } else if (typeof res === "number" || res.isEscaped) {
+      buffer[0] += res;
+      if (res.callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...res.callbacks);
+      }
+    } else {
+      escapeToBuffer(res, buffer);
+    }
+  }
+};
+var JSXFragmentNode = class extends JSXNode {
+  toStringToBuffer(buffer) {
+    childrenToStringToBuffer(this.children, buffer);
+  }
+};
+var jsx = (tag, props, ...children) => {
+  props ??= {};
+  if (children.length) {
+    props.children = children.length === 1 ? children[0] : children;
+  }
+  const key = props.key;
+  delete props["key"];
+  const node = jsxFn(tag, props, children);
+  node.key = key;
+  return node;
+};
+var initDomRenderer = false;
+var jsxFn = (tag, props, children) => {
+  if (!initDomRenderer) {
+    for (const k in domRenderers) {
+      ;
+      intrinsicElementTags[k][DOM_RENDERER] = domRenderers[k];
+    }
+    initDomRenderer = true;
+  }
+  if (typeof tag === "function") {
+    return new JSXFunctionNode(tag, props, children);
+  } else if (intrinsicElementTags[tag]) {
+    return new JSXFunctionNode(
+      intrinsicElementTags[tag],
+      props,
+      children
+    );
+  } else if (tag === "svg" || tag === "head") {
+    nameSpaceContext ||= createContext("");
+    return new JSXNode(tag, props, [
+      new JSXFunctionNode(
+        nameSpaceContext,
+        {
+          value: tag
+        },
+        children
+      )
+    ]);
+  } else {
+    return new JSXNode(tag, props, children);
+  }
+};
+var shallowEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (let i = 0, len = aKeys.length; i < len; i++) {
+    if (aKeys[i] === "children" && bKeys[i] === "children" && !a.children?.length && !b.children?.length) {
+      continue;
+    } else if (a[aKeys[i]] !== b[aKeys[i]]) {
+      return false;
+    }
+  }
+  return true;
+};
+var memo = (component, propsAreEqual = shallowEqual) => {
+  let computed = null;
+  let prevProps = void 0;
+  const wrapper = ((props) => {
+    if (prevProps && !propsAreEqual(prevProps, props)) {
+      computed = null;
+    }
+    prevProps = props;
+    return computed ||= component(props);
+  });
+  wrapper[DOM_MEMO] = propsAreEqual;
+  wrapper[DOM_RENDERER] = component;
+  return wrapper;
+};
+var Fragment = ({
+  children
+}) => {
+  return new JSXFragmentNode(
+    "",
+    {
+      children
+    },
+    Array.isArray(children) ? children : children ? [children] : []
+  );
+};
+var isValidElement = (element) => {
+  return !!(element && typeof element === "object" && "tag" in element && "props" in element);
+};
+var cloneElement = (element, props, ...children) => {
+  let childrenToClone;
+  if (children.length > 0) {
+    childrenToClone = children;
+  } else {
+    const c = element.props.children;
+    childrenToClone = Array.isArray(c) ? c : [c];
+  }
+  return jsx(
+    element.tag,
+    { ...element.props, ...props },
+    ...childrenToClone
+  );
+};
+var reactAPICompatVersion = "19.0.0-hono-jsx";
+export {
+  Fragment,
+  JSXFragmentNode,
+  JSXNode,
+  booleanAttributes,
+  cloneElement,
+  getNameSpaceContext,
+  isValidElement,
+  jsx,
+  jsxFn,
+  memo,
+  reactAPICompatVersion,
+  shallowEqual
+};

package/dist/jsx/children.js

@@ -0,0 +1,21 @@
+// src/jsx/children.ts
+var toArray = (children) => Array.isArray(children) ? children : [children];
+var Children = {
+  map: (children, fn) => toArray(children).map(fn),
+  forEach: (children, fn) => {
+    toArray(children).forEach(fn);
+  },
+  count: (children) => toArray(children).length,
+  only: (_children) => {
+    const children = toArray(_children);
+    if (children.length !== 1) {
+      throw new Error("Children.only() expects only one child");
+    }
+    return children[0];
+  },
+  toArray
+};
+export {
+  Children,
+  toArray
+};

package/dist/jsx/components.js

@@ -0,0 +1,178 @@
+// 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 { DOM_RENDERER } from "./constants.js";
+import { useContext } from "./context.js";
+import { ErrorBoundary as ErrorBoundaryDomRenderer } 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;
+    }
+  }
+};
+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;
+    }
+  }
+};
+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>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+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}"` : ""}>
+((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>
+((d,c,n) => {
+d=d.getElementById('E:${index}')
+if(!d)return
+n=d.nextSibling
+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
+};

package/dist/jsx/constants.js

@@ -0,0 +1,15 @@
+// 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
+};

package/dist/jsx/context.js

@@ -0,0 +1,38 @@
+// src/jsx/context.ts
+import { raw } from "../helper/html/index.js";
+import { JSXFragmentNode } from "./base.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
+};

package/dist/jsx/dom/client.js

@@ -0,0 +1,53 @@
+// 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;
+    }
+  };
+};
+var 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
+};

package/dist/jsx/dom/components.js

@@ -0,0 +1,32 @@
+// 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;
+});
+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;
+});
+export {
+  ErrorBoundary,
+  Suspense
+};