@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/hooks/index.js

@@ -0,0 +1,328 @@
+// src/jsx/hooks/index.ts
+import { DOM_STASH } from "../constants.js";
+import { buildDataStack, update } from "../dom/render.js";
+var STASH_SATE = 0;
+var STASH_EFFECT = 1;
+var STASH_CALLBACK = 2;
+var STASH_MEMO = 3;
+var STASH_REF = 4;
+var resolvedPromiseValueMap = /* @__PURE__ */ new WeakMap();
+var isDepsChanged = (prevDeps, deps) => !prevDeps || !deps || prevDeps.length !== deps.length || deps.some((dep, i) => dep !== prevDeps[i]);
+var viewTransitionState = void 0;
+var documentStartViewTransition = (cb) => {
+  if (document?.startViewTransition) {
+    return document.startViewTransition(cb);
+  } else {
+    cb();
+    return { finished: Promise.resolve() };
+  }
+};
+var updateHook = void 0;
+var viewTransitionHook = (context, node, cb) => {
+  const state = [true, false];
+  let lastVC = node.vC;
+  return documentStartViewTransition(() => {
+    if (lastVC === node.vC) {
+      viewTransitionState = state;
+      cb(context);
+      viewTransitionState = void 0;
+      lastVC = node.vC;
+    }
+  }).finished.then(() => {
+    if (state[1] && lastVC === node.vC) {
+      state[0] = false;
+      viewTransitionState = state;
+      cb(context);
+      viewTransitionState = void 0;
+    }
+  });
+};
+var startViewTransition = (callback) => {
+  updateHook = viewTransitionHook;
+  try {
+    callback();
+  } finally {
+    updateHook = void 0;
+  }
+};
+var useViewTransition = () => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return [false, () => {
+    }];
+  }
+  if (viewTransitionState) {
+    viewTransitionState[1] = true;
+  }
+  return [!!viewTransitionState?.[0], startViewTransition];
+};
+var pendingStack = [];
+var runCallback = (type, callback) => {
+  let resolve;
+  const promise = new Promise((r) => resolve = r);
+  pendingStack.push([type, promise]);
+  try {
+    const res = callback();
+    if (res instanceof Promise) {
+      res.then(resolve, resolve);
+    } else {
+      resolve();
+    }
+  } finally {
+    pendingStack.pop();
+  }
+};
+var startTransition = (callback) => {
+  runCallback(1, callback);
+};
+var startTransitionHook = (callback) => {
+  runCallback(2, callback);
+};
+var useTransition = () => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return [false, () => {
+    }];
+  }
+  const [error, setError] = useState();
+  const [state, updateState] = useState();
+  if (error) {
+    throw error[0];
+  }
+  const startTransitionLocalHook = useCallback(
+    (callback) => {
+      startTransitionHook(() => {
+        updateState((state2) => !state2);
+        let res = callback();
+        if (res instanceof Promise) {
+          res = res.catch((e) => {
+            setError([e]);
+          });
+        }
+        return res;
+      });
+    },
+    [state]
+  );
+  const [context] = buildData;
+  return [context[0] === 2, startTransitionLocalHook];
+};
+var useDeferredValue = (value, ...rest) => {
+  const [values, setValues] = useState(
+    rest.length ? [rest[0], rest[0]] : [value, value]
+  );
+  if (Object.is(values[1], value)) {
+    return values[1];
+  }
+  pendingStack.push([3, Promise.resolve()]);
+  updateHook = async (context, _, cb) => {
+    cb(context);
+    values[0] = value;
+  };
+  setValues([values[0], value]);
+  updateHook = void 0;
+  pendingStack.pop();
+  return values[0];
+};
+var useState = (initialState) => {
+  const resolveInitialState = () => typeof initialState === "function" ? initialState() : initialState;
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return [resolveInitialState(), () => {
+    }];
+  }
+  const [, node] = buildData;
+  const stateArray = node[DOM_STASH][1][STASH_SATE] ||= [];
+  const hookIndex = node[DOM_STASH][0]++;
+  return stateArray[hookIndex] ||= [
+    resolveInitialState(),
+    (newState) => {
+      const localUpdateHook = updateHook;
+      const stateData = stateArray[hookIndex];
+      if (typeof newState === "function") {
+        newState = newState(stateData[0]);
+      }
+      if (!Object.is(newState, stateData[0])) {
+        stateData[0] = newState;
+        if (pendingStack.length) {
+          const [pendingType, pendingPromise] = pendingStack.at(-1);
+          Promise.all([
+            pendingType === 3 ? node : update([pendingType, false, localUpdateHook], node),
+            pendingPromise
+          ]).then(([node2]) => {
+            if (!node2 || !(pendingType === 2 || pendingType === 3)) {
+              return;
+            }
+            const lastVC = node2.vC;
+            const addUpdateTask = () => {
+              setTimeout(() => {
+                if (lastVC !== node2.vC) {
+                  return;
+                }
+                update([pendingType === 3 ? 1 : 0, false, localUpdateHook], node2);
+              });
+            };
+            requestAnimationFrame(addUpdateTask);
+          });
+        } else {
+          update([0, false, localUpdateHook], node);
+        }
+      }
+    }
+  ];
+};
+var useReducer = (reducer, initialArg, init) => {
+  const handler = useCallback(
+    (action) => {
+      setState((state2) => reducer(state2, action));
+    },
+    [reducer]
+  );
+  const [state, setState] = useState(() => init ? init(initialArg) : initialArg);
+  return [state, handler];
+};
+var useEffectCommon = (index, effect, deps) => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return;
+  }
+  const [, node] = buildData;
+  const effectDepsArray = node[DOM_STASH][1][STASH_EFFECT] ||= [];
+  const hookIndex = node[DOM_STASH][0]++;
+  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] ||= [];
+  if (isDepsChanged(prevDeps, deps)) {
+    if (prevCleanup) {
+      prevCleanup();
+    }
+    const runner = () => {
+      data[index] = void 0;
+      data[2] = effect();
+    };
+    const data = [deps, void 0, void 0, void 0, void 0];
+    data[index] = runner;
+    effectDepsArray[hookIndex] = data;
+  }
+};
+var useEffect = (effect, deps) => useEffectCommon(3, effect, deps);
+var useLayoutEffect = (effect, deps) => useEffectCommon(1, effect, deps);
+var useInsertionEffect = (effect, deps) => useEffectCommon(4, effect, deps);
+var useCallback = (callback, deps) => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return callback;
+  }
+  const [, node] = buildData;
+  const callbackArray = node[DOM_STASH][1][STASH_CALLBACK] ||= [];
+  const hookIndex = node[DOM_STASH][0]++;
+  const prevDeps = callbackArray[hookIndex];
+  if (isDepsChanged(prevDeps?.[1], deps)) {
+    callbackArray[hookIndex] = [callback, deps];
+  } else {
+    callback = callbackArray[hookIndex][0];
+  }
+  return callback;
+};
+var useRef = (initialValue) => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return { current: initialValue };
+  }
+  const [, node] = buildData;
+  const refArray = node[DOM_STASH][1][STASH_REF] ||= [];
+  const hookIndex = node[DOM_STASH][0]++;
+  return refArray[hookIndex] ||= { current: initialValue };
+};
+var use = (promise) => {
+  const cachedRes = resolvedPromiseValueMap.get(promise);
+  if (cachedRes) {
+    if (cachedRes.length === 2) {
+      throw cachedRes[1];
+    }
+    return cachedRes[0];
+  }
+  promise.then(
+    (res) => resolvedPromiseValueMap.set(promise, [res]),
+    (e) => resolvedPromiseValueMap.set(promise, [void 0, e])
+  );
+  throw promise;
+};
+var useMemo = (factory, deps) => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    return factory();
+  }
+  const [, node] = buildData;
+  const memoArray = node[DOM_STASH][1][STASH_MEMO] ||= [];
+  const hookIndex = node[DOM_STASH][0]++;
+  const prevDeps = memoArray[hookIndex];
+  if (isDepsChanged(prevDeps?.[1], deps)) {
+    memoArray[hookIndex] = [factory(), deps];
+  }
+  return memoArray[hookIndex][0];
+};
+var idCounter = 0;
+var useId = () => useMemo(() => `:r${(idCounter++).toString(32)}:`, []);
+var useDebugValue = (_value, _formatter) => {
+};
+var createRef = () => {
+  return { current: null };
+};
+var forwardRef = (Component) => {
+  return (props) => {
+    const { ref, ...rest } = props;
+    return Component(rest, ref);
+  };
+};
+var useImperativeHandle = (ref, createHandle, deps) => {
+  useEffect(() => {
+    ref.current = createHandle();
+    return () => {
+      ref.current = null;
+    };
+  }, deps);
+};
+var useSyncExternalStore = (subscribe, getSnapshot, getServerSnapshot) => {
+  const buildData = buildDataStack.at(-1);
+  if (!buildData) {
+    if (!getServerSnapshot) {
+      throw new Error("getServerSnapshot is required for server side rendering");
+    }
+    return getServerSnapshot();
+  }
+  const [serverSnapshotIsUsed] = useState(!!(buildData[0][4] && getServerSnapshot));
+  const [state, setState] = useState(
+    () => serverSnapshotIsUsed ? getServerSnapshot() : getSnapshot()
+  );
+  useEffect(() => {
+    if (serverSnapshotIsUsed) {
+      setState(getSnapshot());
+    }
+    return subscribe(() => {
+      setState(getSnapshot());
+    });
+  }, []);
+  return state;
+};
+export {
+  STASH_EFFECT,
+  createRef,
+  forwardRef,
+  startTransition,
+  startViewTransition,
+  use,
+  useCallback,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/index.js

@@ -0,0 +1,103 @@
+// src/jsx/index.ts
+import { Fragment, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from "./base.js";
+import { Children } from "./children.js";
+import { ErrorBoundary } from "./components.js";
+import { createContext, useContext } from "./context.js";
+import { useActionState, useOptimistic } from "./dom/hooks/index.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 { Suspense } from "./streaming.js";
+var jsx_default = {
+  version: reactAPICompatVersion,
+  memo,
+  Fragment,
+  StrictMode: Fragment,
+  isValidElement,
+  createElement: jsx,
+  cloneElement,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  useReducer,
+  useId,
+  useDebugValue,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  useInsertionEffect,
+  createRef,
+  forwardRef,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useActionState,
+  useOptimistic,
+  Suspense,
+  Children
+};
+export {
+  Children,
+  ErrorBoundary,
+  Fragment,
+  Fragment as StrictMode,
+  Suspense,
+  cloneElement,
+  createContext,
+  jsx as createElement,
+  createRef,
+  jsx_default as default,
+  forwardRef,
+  isValidElement,
+  jsx,
+  memo,
+  startTransition,
+  startViewTransition,
+  use,
+  useActionState,
+  useCallback,
+  useContext,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useOptimistic,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+  reactAPICompatVersion as version
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/intrinsic-element/common.js

@@ -0,0 +1,24 @@
+// src/jsx/intrinsic-element/common.ts
+var deDupeKeyMap = {
+  title: [],
+  script: ["src"],
+  style: ["data-href"],
+  link: ["href"],
+  meta: ["name", "httpEquiv", "charset", "itemProp"]
+};
+var domRenderers = {};
+var dataPrecedenceAttr = "data-precedence";
+var isStylesheetLinkWithPrecedence = (props) => props.rel === "stylesheet" && "precedence" in props;
+var shouldDeDupeByKey = (tagName, supportSort) => {
+  if (tagName === "link") {
+    return supportSort;
+  }
+  return deDupeKeyMap[tagName].length > 0;
+};
+export {
+  dataPrecedenceAttr,
+  deDupeKeyMap,
+  domRenderers,
+  isStylesheetLinkWithPrecedence,
+  shouldDeDupeByKey
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/intrinsic-element/components.js

@@ -0,0 +1,165 @@
+// src/jsx/intrinsic-element/components.ts
+import { raw } from "../../helper/html/index.js";
+import { JSXNode, getNameSpaceContext } from "../base.js";
+import { toArray } from "../children.js";
+import { PERMALINK } from "../constants.js";
+import { useContext } from "../context.js";
+import {
+  dataPrecedenceAttr,
+  deDupeKeyMap,
+  isStylesheetLinkWithPrecedence,
+  shouldDeDupeByKey
+} from "./common.js";
+var metaTagMap = /* @__PURE__ */ new WeakMap();
+var insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }) => {
+  if (!buffer) {
+    return;
+  }
+  const map = metaTagMap.get(context) || {};
+  metaTagMap.set(context, map);
+  const tags = map[tagName] ||= [];
+  let duped = false;
+  const deDupeKeys = deDupeKeyMap[tagName];
+  const deDupeByKey = shouldDeDupeByKey(tagName, precedence !== void 0);
+  if (deDupeByKey) {
+    LOOP: for (const [, tagProps] of tags) {
+      if (tagName === "link" && !(tagProps.rel === "stylesheet" && tagProps[dataPrecedenceAttr] !== void 0)) {
+        continue;
+      }
+      for (const key of deDupeKeys) {
+        if ((tagProps?.[key] ?? null) === props?.[key]) {
+          duped = true;
+          break LOOP;
+        }
+      }
+    }
+  }
+  if (duped) {
+    buffer[0] = buffer[0].replaceAll(tag, "");
+  } else if (deDupeByKey || tagName === "link") {
+    tags.push([tag, props, precedence]);
+  } else {
+    tags.unshift([tag, props, precedence]);
+  }
+  if (buffer[0].indexOf("</head>") !== -1) {
+    let insertTags;
+    if (tagName === "link" || precedence !== void 0) {
+      const precedences = [];
+      insertTags = tags.map(([tag2, , tagPrecedence], index) => {
+        if (tagPrecedence === void 0) {
+          return [tag2, Number.MAX_SAFE_INTEGER, index];
+        }
+        let order = precedences.indexOf(tagPrecedence);
+        if (order === -1) {
+          precedences.push(tagPrecedence);
+          order = precedences.length - 1;
+        }
+        return [tag2, order, index];
+      }).sort((a, b) => a[1] - b[1] || a[2] - b[2]).map(([tag2]) => tag2);
+    } else {
+      insertTags = tags.map(([tag2]) => tag2);
+    }
+    insertTags.forEach((tag2) => {
+      buffer[0] = buffer[0].replaceAll(tag2, "");
+    });
+    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
+  }
+};
+var returnWithoutSpecialBehavior = (tag, children, props) => raw(new JSXNode(tag, props, toArray(children ?? [])).toString());
+var documentMetadataTag = (tag, children, props, sort) => {
+  if ("itemProp" in props) {
+    return returnWithoutSpecialBehavior(tag, children, props);
+  }
+  let { precedence, blocking, ...restProps } = props;
+  precedence = sort ? precedence ?? "" : void 0;
+  if (sort) {
+    restProps[dataPrecedenceAttr] = precedence;
+  }
+  const string = new JSXNode(tag, restProps, toArray(children || [])).toString();
+  if (string instanceof Promise) {
+    return string.then(
+      (resString) => raw(string, [
+        ...resString.callbacks || [],
+        insertIntoHead(tag, resString, restProps, precedence)
+      ])
+    );
+  } else {
+    return raw(string, [insertIntoHead(tag, string, restProps, precedence)]);
+  }
+};
+var title = ({ children, ...props }) => {
+  const nameSpaceContext = getNameSpaceContext();
+  if (nameSpaceContext) {
+    const context = useContext(nameSpaceContext);
+    if (context === "svg" || context === "head") {
+      return new JSXNode(
+        "title",
+        props,
+        toArray(children ?? [])
+      );
+    }
+  }
+  return documentMetadataTag("title", children, props, false);
+};
+var script = ({
+  children,
+  ...props
+}) => {
+  const nameSpaceContext = getNameSpaceContext();
+  if (["src", "async"].some((k) => !props[k]) || nameSpaceContext && useContext(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("script", children, props);
+  }
+  return documentMetadataTag("script", children, props, false);
+};
+var style = ({
+  children,
+  ...props
+}) => {
+  if (!["href", "precedence"].every((k) => k in props)) {
+    return returnWithoutSpecialBehavior("style", children, props);
+  }
+  props["data-href"] = props.href;
+  delete props.href;
+  return documentMetadataTag("style", children, props, true);
+};
+var link = ({ children, ...props }) => {
+  if (["onLoad", "onError"].some((k) => k in props) || props.rel === "stylesheet" && (!("precedence" in props) || "disabled" in props)) {
+    return returnWithoutSpecialBehavior("link", children, props);
+  }
+  return documentMetadataTag("link", children, props, isStylesheetLinkWithPrecedence(props));
+};
+var meta = ({ children, ...props }) => {
+  const nameSpaceContext = getNameSpaceContext();
+  if (nameSpaceContext && useContext(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("meta", children, props);
+  }
+  return documentMetadataTag("meta", children, props, false);
+};
+var newJSXNode = (tag, { children, ...props }) => (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new JSXNode(tag, props, toArray(children ?? []))
+);
+var form = (props) => {
+  if (typeof props.action === "function") {
+    props.action = PERMALINK in props.action ? props.action[PERMALINK] : void 0;
+  }
+  return newJSXNode("form", props);
+};
+var formActionableElement = (tag, props) => {
+  if (typeof props.formAction === "function") {
+    props.formAction = PERMALINK in props.formAction ? props.formAction[PERMALINK] : void 0;
+  }
+  return newJSXNode(tag, props);
+};
+var input = (props) => formActionableElement("input", props);
+var button = (props) => formActionableElement("button", props);
+export {
+  button,
+  form,
+  input,
+  link,
+  meta,
+  script,
+  style,
+  title
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/jsx-dev-runtime.js

@@ -0,0 +1,18 @@
+// src/jsx/jsx-dev-runtime.ts
+import { jsxFn } from "./base.js";
+import { Fragment } from "./base.js";
+function jsxDEV(tag, props, key) {
+  let node;
+  if (!props || !("children" in props)) {
+    node = jsxFn(tag, props, []);
+  } else {
+    const children = props.children;
+    node = Array.isArray(children) ? jsxFn(tag, props, children) : jsxFn(tag, props, [children]);
+  }
+  node.key = key;
+  return node;
+}
+export {
+  Fragment,
+  jsxDEV
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/jsx/jsx-runtime.js

@@ -0,0 +1,44 @@
+// src/jsx/jsx-runtime.ts
+import { jsxDEV, Fragment } from "./jsx-dev-runtime.js";
+import { jsxDEV as jsxDEV2 } from "./jsx-dev-runtime.js";
+import { html, raw } from "../helper/html/index.js";
+import { escapeToBuffer, stringBufferToString } from "../utils/html.js";
+import { isValidAttributeName, styleObjectForEach } from "./utils.js";
+var jsxAttr = (key, v) => {
+  if (!isValidAttributeName(key)) {
+    return raw("");
+  }
+  const buffer = [`${key}="`];
+  if (key === "style" && typeof v === "object") {
+    let styleStr = "";
+    styleObjectForEach(v, (property, value) => {
+      if (value != null) {
+        styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+      }
+    });
+    escapeToBuffer(styleStr, buffer);
+    buffer[0] += '"';
+  } else if (typeof v === "string") {
+    escapeToBuffer(v, buffer);
+    buffer[0] += '"';
+  } else if (v === null || v === void 0) {
+    return raw("");
+  } else if (typeof v === "number" || v.isEscaped) {
+    buffer[0] += `${v}"`;
+  } else if (v instanceof Promise) {
+    buffer.unshift('"', v);
+  } else {
+    escapeToBuffer(v.toString(), buffer);
+    buffer[0] += '"';
+  }
+  return buffer.length === 1 ? raw(buffer[0]) : stringBufferToString(buffer, void 0);
+};
+var jsxEscape = (value) => value;
+export {
+  Fragment,
+  jsxDEV as jsx,
+  jsxAttr,
+  jsxEscape,
+  html as jsxTemplate,
+  jsxDEV2 as jsxs
+};