@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/jsx/base.js

@@ -0,0 +1,346 @@
+// 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 {
+  captureRenderContext,
+  createContext,
+  globalContexts,
+  runWithRenderContext,
+  useContext
+} from "./context.js";
+import { domRenderers } from "./intrinsic-element/common.js";
+import * as intrinsicElementTags from "./intrinsic-element/components.js";
+import {
+  isValidAttributeName,
+  isValidTagName,
+  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 resolveFunctionComponentResult = (result, suspendedContext) => result.then((resolved) => {
+  if (!Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+    return resolved;
+  }
+  const children = Array.isArray(resolved) ? resolved : [resolved];
+  const render = () => {
+    const buffer = [""];
+    childrenToStringToBuffer(children, buffer);
+    return buffer.length === 1 ? raw(buffer[0], buffer.callbacks) : stringBufferToString(buffer, buffer.callbacks);
+  };
+  return suspendedContext ? suspendedContext(render) : runWithRenderContext(render);
+});
+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") {
+      ;
+      buffer[0] += child;
+    } else if (child.isEscaped) {
+      ;
+      buffer[0] += child;
+      const callbacks = child.callbacks;
+      if (callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...callbacks);
+      }
+    } else if (child instanceof Promise) {
+      buffer.unshift("", child);
+    } else {
+      childrenToStringToBuffer(child, buffer);
+    }
+  }
+};
+var JSXNode = class {
+  tag;
+  props;
+  key;
+  children;
+  isEscaped = true;
+  constructor(tag, props, children) {
+    if (typeof tag !== "function" && !isValidTagName(tag)) {
+      throw new Error(`Invalid JSX tag name: ${tag}`);
+    }
+    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 render = () => {
+      const buffer = [""];
+      this.toStringToBuffer(buffer);
+      return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
+    };
+    return runWithRenderContext(render);
+  }
+  toStringToBuffer(buffer) {
+    const tag = this.tag;
+    const props = this.props;
+    let { children } = this;
+    buffer[0] += `<${tag}`;
+    const normalizeKey = tag === "svg" || nameSpaceContext && useContext(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName(normalizeIntrinsicElementKey(key)) : (key) => normalizeIntrinsicElementKey(key);
+    for (let [key, v] of Object.entries(props)) {
+      key = normalizeKey(key);
+      if (!isValidAttributeName(key)) {
+        continue;
+      }
+      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("", resolveFunctionComponentResult(res));
+      } else {
+        buffer.unshift("", resolveFunctionComponentResult(res, captureRenderContext()));
+      }
+    } else if (res instanceof JSXNode) {
+      res.toStringToBuffer(buffer);
+    } else if (Array.isArray(res)) {
+      childrenToStringToBuffer(res, 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) => {
+  const wrapper = ((props) => 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/benchmarks/e2-framework-v1/project/vendor/hono/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/benchmarks/e2-framework-v1/project/vendor/hono/dist/jsx/components.js

@@ -0,0 +1,198 @@
+// 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 { captureRenderContext, 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) {
+      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;
+    }
+  }
+};
+var 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 (typeof awaitedFallback === "string") {
+      return awaitedFallback;
+    } else {
+      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
+      if (typeof fallbackResult === "string") {
+        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 resume2 = getResume();
+    if (e instanceof Promise) {
+      resArray = [
+        e.then(() => resume2(() => childrenToString(children))).catch((e2) => renderFallback(e2))
+      ];
+    } 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}-->)`);
+    let caught = false;
+    const catchCallback = async ({ error: error2, buffer }) => {
+      if (caught) {
+        return "";
+      }
+      caught = true;
+      const fallbackResString = await renderFallback(error2);
+      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}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
+d.replaceWith(c.content)
+})(document)
+</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>
+((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/benchmarks/e2-framework-v1/project/vendor/hono/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
+};