@piagent/platform 1.2.16 → 1.3.0-ie.8

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

@@ -0,0 +1,162 @@
+// 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 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;
+};
+var 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)."
+    );
+  }
+};
+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;
+};
+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];
+};
+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;
+  }
+}, 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;
+};
+var 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 string;
+    try {
+      string = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
+    } catch (e) {
+      contextValues.pop();
+      throw e;
+    }
+    if (string instanceof Promise) {
+      return string.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
+    } else {
+      contextValues.pop();
+      return raw(string);
+    }
+  });
+  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
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/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/benchmarks/e2-framework-v1/project/vendor/hono/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
+};

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

@@ -0,0 +1,48 @@
+// 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;
+};
+export {
+  createContext,
+  createContextProviderFunction
+};

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

@@ -0,0 +1,150 @@
+// src/jsx/dom/css.ts
+import {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  cssCommon,
+  cxCommon,
+  keyframesCommon,
+  viewTransitionCommon
+} from "../../helper/css/common.js";
+import { rawCssString } from "../../helper/css/common.js";
+var splitRule = (rule) => {
+  const result = [];
+  let startPos = 0;
+  let depth = 0;
+  for (let i = 0, len = rule.length; i < len; i++) {
+    const char = rule[i];
+    if (char === "'" || char === '"') {
+      const quote = char;
+      i++;
+      for (; i < len; i++) {
+        if (rule[i] === "\\") {
+          i++;
+          continue;
+        }
+        if (rule[i] === quote) {
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        result.push(rule.slice(startPos, i + 1));
+        startPos = i + 1;
+      }
+      continue;
+    }
+  }
+  return result;
+};
+var createCssJsxDomObjects = ({ id }) => {
+  let styleSheet = void 0;
+  const findStyleSheet = () => {
+    if (!styleSheet) {
+      styleSheet = document.querySelector(`style#${id}`)?.sheet;
+      if (styleSheet) {
+        ;
+        styleSheet.addedStyles = /* @__PURE__ */ new Set();
+      }
+    }
+    return styleSheet ? [styleSheet, styleSheet.addedStyles] : [];
+  };
+  const insertRule = (className, styleString) => {
+    const [sheet, addedStyles] = findStyleSheet();
+    if (!sheet || !addedStyles) {
+      Promise.resolve().then(() => {
+        if (!findStyleSheet()[0]) {
+          throw new Error("style sheet not found");
+        }
+        insertRule(className, styleString);
+      });
+      return;
+    }
+    if (!addedStyles.has(className)) {
+      addedStyles.add(className);
+      (className.startsWith(PSEUDO_GLOBAL_SELECTOR) ? splitRule(styleString) : [`${className[0] === "@" ? "" : "."}${className}{${styleString}}`]).forEach((rule) => {
+        sheet.insertRule(rule, sheet.cssRules.length);
+      });
+    }
+  };
+  const cssObject = {
+    toString() {
+      const selector = this[SELECTOR];
+      insertRule(selector, this[STYLE_STRING]);
+      this[SELECTORS].forEach(({ [CLASS_NAME]: className, [STYLE_STRING]: styleString }) => {
+        insertRule(className, styleString);
+      });
+      return this[CLASS_NAME];
+    }
+  };
+  const Style2 = ({ children, nonce }) => ({
+    tag: "style",
+    props: {
+      id,
+      nonce,
+      children: children && (Array.isArray(children) ? children : [children]).map(
+        (c) => c[STYLE_STRING]
+      )
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  return [cssObject, Style2];
+};
+var createCssContext = ({
+  id,
+  classNameSlug,
+  onInvalidSlug
+}) => {
+  const [cssObject, Style2] = createCssJsxDomObjects({ id });
+  const newCssClassNameObject = (cssClassName) => {
+    cssClassName.toString = cssObject.toString;
+    return cssClassName;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject(cssCommon(strings, values, classNameSlug, onInvalidSlug));
+  };
+  const cx2 = (...args) => {
+    args = cxCommon(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = (strings, ...values) => keyframesCommon(strings, values, classNameSlug, onInvalidSlug);
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject(
+      viewTransitionCommon(strings, values, classNameSlug, onInvalidSlug)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+    );
+  });
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+var defaultContext = createCssContext({ id: DEFAULT_STYLE_ID });
+var css = defaultContext.css;
+var cx = defaultContext.cx;
+var keyframes = defaultContext.keyframes;
+var viewTransition = defaultContext.viewTransition;
+var Style = defaultContext.Style;
+export {
+  Style,
+  createCssContext,
+  createCssJsxDomObjects,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/jsx/dom/hooks/index.js

@@ -0,0 +1,48 @@
+// src/jsx/dom/hooks/index.ts
+import { PERMALINK } from "../../constants.js";
+import { useContext } from "../../context.js";
+import { useCallback, useState } from "../../hooks/index.js";
+import { createContext } from "../context.js";
+var FormContext = createContext({
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+});
+var actions = /* @__PURE__ */ new Set();
+var registerAction = (action) => {
+  actions.add(action);
+  action.finally(() => actions.delete(action));
+};
+var useFormStatus = () => {
+  return useContext(FormContext);
+};
+var useOptimistic = (state, updateState) => {
+  const [optimisticState, setOptimisticState] = useState(state);
+  if (actions.size > 0) {
+    Promise.all(actions).finally(() => {
+      setOptimisticState(state);
+    });
+  } else {
+    setOptimisticState(state);
+  }
+  const cb = useCallback((newData) => {
+    setOptimisticState((currentState) => updateState(currentState, newData));
+  }, []);
+  return [optimisticState, cb];
+};
+var useActionState = (fn, initialState, permalink) => {
+  const [state, setState] = useState(initialState);
+  const actionState = async (data) => {
+    setState(await fn(state, data));
+  };
+  actionState[PERMALINK] = permalink;
+  return [state, actionState];
+};
+export {
+  FormContext,
+  registerAction,
+  useActionState,
+  useFormStatus,
+  useOptimistic
+};

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

@@ -0,0 +1,142 @@
+// src/jsx/dom/index.ts
+import { isValidElement, reactAPICompatVersion, shallowEqual } from "../base.js";
+import { Children } from "../children.js";
+import { DOM_MEMO } from "../constants.js";
+import { useContext } from "../context.js";
+import {
+  createRef,
+  forwardRef,
+  startTransition,
+  startViewTransition,
+  use,
+  useCallback,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition
+} from "../hooks/index.js";
+import { ErrorBoundary, Suspense } from "./components.js";
+import { createContext } from "./context.js";
+import { useActionState, useFormStatus, useOptimistic } from "./hooks/index.js";
+import { Fragment, jsx } from "./jsx-runtime.js";
+import { createPortal, flushSync } from "./render.js";
+import { render } from "./render.js";
+var createElement = (tag, props, ...children) => {
+  const jsxProps = props ? { ...props } : {};
+  if (children.length) {
+    jsxProps.children = children.length === 1 ? children[0] : children;
+  }
+  let key = void 0;
+  if ("key" in jsxProps) {
+    key = jsxProps.key;
+    delete jsxProps.key;
+  }
+  return jsx(tag, jsxProps, key);
+};
+var cloneElement = (element, props, ...children) => {
+  return jsx(
+    element.tag,
+    {
+      ...element.props,
+      ...props,
+      children: children.length ? children : element.props.children
+    },
+    element.key
+  );
+};
+var memo = (component, propsAreEqual = shallowEqual) => {
+  const wrapper = ((props) => component(props));
+  wrapper[DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
+var dom_default = {
+  version: reactAPICompatVersion,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  useInsertionEffect,
+  useReducer,
+  useId,
+  useDebugValue,
+  createRef,
+  forwardRef,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useFormStatus,
+  useActionState,
+  useOptimistic,
+  Suspense,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  memo,
+  isValidElement,
+  createElement,
+  cloneElement,
+  Children,
+  Fragment,
+  StrictMode: Fragment,
+  flushSync,
+  createPortal
+};
+export {
+  Children,
+  ErrorBoundary,
+  Fragment,
+  Fragment as StrictMode,
+  Suspense,
+  cloneElement,
+  createContext,
+  createElement,
+  createPortal,
+  createRef,
+  dom_default as default,
+  flushSync,
+  forwardRef,
+  isValidElement,
+  createElement as jsx,
+  memo,
+  render,
+  startTransition,
+  startViewTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useFormStatus,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+  reactAPICompatVersion as version
+};