@hanzogui/web 2.0.0-rc.41-hanzoai.5

package/dist/esm/createComponent.mjs

@@ -0,0 +1,1013 @@
+import { composeRefs } from "@hanzogui/compose-refs";
+import { isClient, isServer, isWeb, useIsomorphicLayoutEffect } from "@hanzogui/constants";
+import { NativeMenuContext } from "@hanzogui/native";
+import { composeEventHandlers } from "@hanzogui/helpers";
+import { isEqualShallow } from "@hanzogui/is-equal-shallow";
+import React, { useMemo } from "react";
+import { devConfig, getConfig } from "./config.mjs";
+import { isDevTools } from "./constants/isDevTools.mjs";
+import { ComponentContext } from "./contexts/ComponentContext.mjs";
+import { GroupContext } from "./contexts/GroupContext.mjs";
+import { didGetVariableValue, setDidGetVariableValue } from "./createVariable.mjs";
+import { defaultComponentStateMounted } from "./defaultComponentState.mjs";
+import { getWebEvents, useEvents, wrapWithGestureDetector } from "./eventHandling.mjs";
+import { getDefaultProps } from "./helpers/getDefaultProps.mjs";
+import { resolveAnimationDriver } from "./helpers/resolveAnimationDriver.mjs";
+import { getSplitStyles, useSplitStyles } from "./helpers/getSplitStyles.mjs";
+import { log } from "./helpers/log.mjs";
+import { mergeComponentProps } from "./helpers/mergeProps.mjs";
+import { mergeRenderElementProps } from "./helpers/mergeRenderElementProps.mjs";
+import { objectIdentityKey } from "./helpers/objectIdentityKey.mjs";
+import { usePointerEvents } from "./helpers/pointerEvents.mjs";
+import { extractPseudoState, resolveEffectivePseudoTransition } from "./helpers/pseudoTransitions.mjs";
+import { setElementProps } from "./helpers/setElementProps.mjs";
+import { subscribeToContextGroup } from "./helpers/subscribeToContextGroup.mjs";
+import { themeable } from "./helpers/themeable.mjs";
+import { getStyleTags } from "./helpers/wrapStyleTags.mjs";
+import { useComponentState } from "./hooks/useComponentState.mjs";
+import { setMediaShouldUpdate, useMedia } from "./hooks/useMedia.mjs";
+import { useThemeWithState } from "./hooks/useTheme.mjs";
+import { hooks } from "./setupHooks.mjs";
+import { Slot } from "./views/Slot.mjs";
+import { getThemedChildren } from "./views/Theme.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+let time;
+let debugKeyListeners;
+let startVisualizer;
+const componentSetStates = /* @__PURE__ */new Set();
+const avoidReRenderKeys = /* @__PURE__ */new Set(["hover", "press", "pressIn", "group", "focus", "focusWithin", "media", "group"]);
+if (typeof window !== "undefined") {
+  const cancelPresses = () => {
+    componentSetStates.forEach(setState => setState(prev => {
+      if (prev.press || prev.pressIn) return {
+        ...prev,
+        press: false,
+        pressIn: false
+      };
+      return prev;
+    }));
+    componentSetStates.clear();
+  };
+  const cancelTouches = () => {
+    componentSetStates.forEach(setState => setState(prev => {
+      if (prev.press || prev.pressIn || prev.hover) return {
+        ...prev,
+        press: false,
+        pressIn: false,
+        hover: false
+      };
+      return prev;
+    }));
+    componentSetStates.clear();
+  };
+  addEventListener("mouseup", cancelPresses);
+  addEventListener("touchend", cancelTouches);
+  addEventListener("touchcancel", cancelTouches);
+  if (process.env.NODE_ENV === "development") startVisualizer = () => {
+    const devVisualizerConfig = devConfig?.visualizer;
+    if (devVisualizerConfig && !globalThis.__hanzoguiDevVisualizer) {
+      let show = function (val) {
+          clearTimeout(tm);
+          isShowing = val;
+          debugKeyListeners?.forEach(l => l(val));
+          if (!val && resizeListener) {
+            window.removeEventListener("resize", resizeListener);
+            resizeListener = null;
+          }
+        },
+        cancelShow = function () {
+          clearTimeout(tm);
+          if (resizeListener) {
+            window.removeEventListener("resize", resizeListener);
+            resizeListener = null;
+          }
+        };
+      globalThis.__hanzoguiDevVisualizer = true;
+      debugKeyListeners = /* @__PURE__ */new Set();
+      let tm;
+      let isShowing = false;
+      let resizeListener = null;
+      const options = {
+        key: "Alt",
+        delay: 800,
+        ...(typeof devVisualizerConfig === "object" ? devVisualizerConfig : {})
+      };
+      window.addEventListener("blur", () => {
+        show(false);
+      });
+      window.addEventListener("keydown", ({
+        key,
+        metaKey,
+        defaultPrevented
+      }) => {
+        clearTimeout(tm);
+        if (defaultPrevented) return;
+        if (metaKey) return;
+        if (key === options.key) {
+          if (!resizeListener) {
+            resizeListener = () => cancelShow();
+            window.addEventListener("resize", resizeListener);
+          }
+          tm = setTimeout(() => {
+            show(true);
+          }, options.delay);
+        }
+      });
+      window.addEventListener("keyup", ({
+        defaultPrevented
+      }) => {
+        if (defaultPrevented) return;
+        cancelShow();
+        if (isShowing) show(false);
+      });
+    }
+  };
+}
+const lastInteractionWasKeyboard = {
+  value: false
+};
+const lastInteractionWasTouch = {
+  value: false
+};
+if (isWeb && typeof document !== "undefined") {
+  document.addEventListener("keydown", () => {
+    if (!lastInteractionWasKeyboard.value) lastInteractionWasKeyboard.value = true;
+  });
+  document.addEventListener("mousedown", () => {
+    if (lastInteractionWasKeyboard.value) lastInteractionWasKeyboard.value = false;
+  });
+  document.addEventListener("mousemove", () => {
+    if (lastInteractionWasKeyboard.value) lastInteractionWasKeyboard.value = false;
+    lastInteractionWasTouch.value = false;
+  });
+  document.addEventListener("touchstart", () => {
+    lastInteractionWasTouch.value = true;
+  });
+}
+function createComponent(staticConfig) {
+  let config = null;
+  const {
+    Component,
+    isText,
+    isHOC
+  } = staticConfig;
+  const component = React.forwardRef((propsIn, forwardedRef) => {
+    "use no memo";
+
+    config = config || getConfig();
+    const internalID = process.env.NODE_ENV === "development" ? React.useId() : "";
+    if (process.env.NODE_ENV === "development") {
+      if (startVisualizer) {
+        startVisualizer();
+        startVisualizer = void 0;
+      }
+    }
+    if (process.env.NODE_ENV === "test") {
+      if (propsIn["data-test-renders"]) {
+        propsIn["data-test-renders"]["current"] = propsIn["data-test-renders"]["current"] ?? 0;
+        propsIn["data-test-renders"]["current"] += 1;
+      }
+    }
+    const {
+      context,
+      isReactNative
+    } = staticConfig;
+    const debugProp = propsIn["debug"];
+    const styledContextValue = context ? React.useContext(context) : void 0;
+    let overriddenContextProps = null;
+    const componentContext = React.useContext(ComponentContext);
+    const hasTextAncestor = !!(isWeb && isText ? componentContext.inText : false);
+    if (!process.env.TAMAGUI_IS_CORE_NODE && process.env.NODE_ENV === "development" && debugProp === "profile" && !time) {
+      time = require("@hanzogui/timer").timer().start();
+      globalThis["time"] = time;
+    }
+    if (process.env.NODE_ENV === "development" && !time && globalThis.time) time = globalThis.time;
+    if (process.env.NODE_ENV === "development" && time) time`non-hanzogui time (ignore)`;
+    let props = propsIn;
+    const componentName = props.componentName || staticConfig.componentName;
+    const [nextProps, overrides] = mergeComponentProps(getDefaultProps(staticConfig, props.componentName), styledContextValue, propsIn);
+    props = nextProps;
+    overriddenContextProps = overrides;
+    if (process.env.NODE_ENV === "development" && isClient) React.useEffect(() => {
+      let node;
+      let overlay = null;
+      const remove = () => {
+        if (overlay) try {
+          overlay.parentNode?.removeChild(overlay);
+          overlay = null;
+        } catch {}
+      };
+      const debugVisualizerHandler = (show = false) => {
+        node = stateRef.current.host;
+        if (!node) return;
+        if (show) {
+          if (!overlay) {
+            overlay = document.createElement("span");
+            overlay.style.inset = "0px";
+            overlay.style.zIndex = "1000000";
+            overlay.style.position = "absolute";
+            overlay.style.borderColor = "red";
+            overlay.style.borderWidth = "1px";
+            overlay.style.borderStyle = "dotted";
+          }
+          const dataAt = node.getAttribute("data-at") || "";
+          const dataIn = node.getAttribute("data-in") || "";
+          const tooltip = document.createElement("span");
+          tooltip.style.position = "absolute";
+          tooltip.style.top = "0px";
+          tooltip.style.left = "0px";
+          tooltip.style.padding = "3px";
+          tooltip.style.background = "rgba(0,0,0,0.75)";
+          tooltip.style.color = "rgba(255,255,255,1)";
+          tooltip.style.fontSize = "12px";
+          tooltip.style.lineHeight = "12px";
+          tooltip.style.fontFamily = "monospace";
+          tooltip.innerText = `${componentName || ""} ${dataAt} ${dataIn}`.trim();
+          overlay.appendChild(tooltip);
+          node.appendChild(overlay);
+        } else remove();
+      };
+      debugKeyListeners = debugKeyListeners || /* @__PURE__ */new Set();
+      debugKeyListeners.add(debugVisualizerHandler);
+      return () => {
+        remove();
+        debugKeyListeners?.delete(debugVisualizerHandler);
+      };
+    }, [componentName]);
+    const groupContextParent = React.useContext(GroupContext);
+    const animationDriver = (() => {
+      if (props.animatedBy && config) {
+        if (config.animationDrivers) return config.animationDrivers[props.animatedBy] ?? config.animations;
+        return props.animatedBy === "default" ? config.animations : null;
+      }
+      return resolveAnimationDriver(componentContext.animationDriver) ?? resolveAnimationDriver(config?.animations) ?? null;
+    })();
+    const useAnimations = animationDriver?.useAnimations;
+    const componentState = useComponentState(props, animationDriver?.isStub ? null : animationDriver, staticConfig, config);
+    const {
+      disabled,
+      groupName,
+      hasAnimationProp,
+      hasEnterStyle,
+      isAnimated,
+      isExiting,
+      isHydrated,
+      presence,
+      presenceState,
+      setState,
+      noClass,
+      state,
+      stateRef,
+      inputStyle,
+      outputStyle,
+      willBeAnimated,
+      willBeAnimatedClient,
+      startedUnhydrated
+    } = componentState;
+    if (hasAnimationProp && animationDriver?.avoidReRenders) useIsomorphicLayoutEffect(() => {
+      const pendingState = stateRef.current.nextState;
+      if (pendingState) {
+        stateRef.current.nextState = void 0;
+        componentState.setStateShallow(pendingState);
+      }
+    });
+    const allGroupContexts = useMemo(() => {
+      if (!groupName || props.passThrough) return groupContextParent;
+      const listeners = /* @__PURE__ */new Set();
+      stateRef.current.group?.listeners?.clear();
+      stateRef.current.group = {
+        listeners,
+        emit(state2) {
+          listeners.forEach(l => l(state2));
+        },
+        subscribe(cb) {
+          listeners.add(cb);
+          if (listeners.size === 1) setStateShallow({
+            hasDynGroupChildren: true
+          });
+          return () => {
+            listeners.delete(cb);
+            if (listeners.size === 0) setStateShallow({
+              hasDynGroupChildren: false
+            });
+          };
+        }
+      };
+      return {
+        ...groupContextParent,
+        [groupName]: {
+          state: {
+            pseudo: defaultComponentStateMounted
+          },
+          subscribe: listener => {
+            const dispose = stateRef.current.group?.subscribe(listener);
+            return () => {
+              dispose?.();
+            };
+          }
+        }
+      };
+    }, [stateRef, groupName, groupContextParent]);
+    let setStateShallow = componentState.setStateShallow;
+    if (process.env.NODE_ENV === "development" && time) time`use-state`;
+    const renderProp = props.render;
+    const element = isWeb ? !Component || typeof Component === "string" ? renderProp || Component : Component : Component;
+    const BaseComponent = isText ? element || "span" : element || (hasTextAncestor ? "span" : "div");
+    let elementType = BaseComponent;
+    if (animationDriver && isAnimated && animationDriver.needsCustomComponent) elementType = animationDriver[isText ? "Text" : "View"] || elementType;
+    const disableTheme = props["data-disable-theme"] || isHOC;
+    if (process.env.NODE_ENV === "development" && time) time`theme-props`;
+    const themeStateProps = {
+      componentName,
+      disable: disableTheme,
+      shallow: props.themeShallow,
+      debug: debugProp,
+      unstyled: props.unstyled
+    };
+    if ("theme" in props) themeStateProps.name = props.theme;
+    themeStateProps.needsUpdate = () => !!stateRef.current.isListeningToTheme;
+    if (process.env.NODE_ENV === "development") {
+      if (debugProp && debugProp !== "profile") {
+        const name = `${componentName || Component?.displayName || Component?.name || "[Unnamed Component]"}`;
+        const type = (hasEnterStyle ? "(hasEnter)" : " ") + (isAnimated ? "(animated)" : " ") + (isReactNative ? "(rnw)" : " ") + (noClass ? "(noClass)" : " ") + (state.press || state.pressIn ? "(PRESSED)" : " ") + (state.hover ? "(HOVERED)" : " ") + (state.focus ? "(FOCUSED)" : " ") + (state.focusWithin ? "(WITHIN FOCUSED)" : " ") + (presenceState?.isPresent === false ? "(EXIT)" : "");
+        const dataIs = propsIn["data-is"] || "";
+        const banner = `<${name} /> ${internalID} ${dataIs ? ` ${dataIs}` : ""} ${type.trim()} (hydrated: ${isHydrated}) (unmounted: ${state.unmounted})`;
+        const ch = propsIn.children;
+        let childLog = typeof ch === "string" ? ch.length > 4 ? ch.slice(0, 4) + "..." : ch : "";
+        if (childLog.length) childLog = `(children: ${childLog})`;
+        if (isWeb) {
+          console.info(`%c ${banner}`, "background: green; color: white;");
+          if (isServer) log({
+            noClass,
+            isAnimated,
+            isWeb,
+            inputStyle
+          });else {
+            console.groupEnd();
+            console.groupCollapsed(`${childLog} [inspect props, state, context \u{1F447}]`);
+            log("props in:", propsIn);
+            log("final props:", props, Object.keys(props));
+            log({
+              state,
+              staticConfig,
+              elementType,
+              themeStateProps
+            });
+            log({
+              context,
+              overriddenContextProps,
+              componentContext
+            });
+            log({
+              presence,
+              isAnimated,
+              isHOC,
+              hasAnimationProp,
+              useAnimations
+            });
+            console.groupEnd();
+          }
+        } else {
+          console.info(`
+
+------------------------------
+${banner}
+------------------------------
+`);
+          log(`children:`, props.children);
+          log({
+            overriddenContextProps,
+            styledContextValue
+          });
+          log({
+            noClass,
+            isAnimated,
+            isWeb,
+            inputStyle
+          });
+        }
+      }
+    }
+    if (process.env.NODE_ENV === "development" && time) time`pre-theme-media`;
+    const [theme, themeState] = useThemeWithState(themeStateProps);
+    if (process.env.NODE_ENV === "development" && time) time`theme`;
+    elementType = element || elementType;
+    const isStringElement = typeof elementType === "string";
+    const mediaState = useMedia(componentContext, debugProp);
+    setDidGetVariableValue(false);
+    if (process.env.NODE_ENV === "development" && time) time`media`;
+    const styleProps = {
+      mediaState,
+      noClass,
+      resolveValues: isAnimated && inputStyle !== "css" || isHOC && state.unmounted == false && hasAnimationProp ? "value" : "auto",
+      isExiting,
+      isAnimated,
+      willBeAnimated,
+      styledContext: styledContextValue
+    };
+    const themeName = themeState?.name || "";
+    if (process.env.NODE_ENV === "development" && time) time`split-styles-prepare`;
+    const splitStyles = useSplitStyles(props, staticConfig, theme, themeName, state, styleProps, null, componentContext, allGroupContexts, elementType, startedUnhydrated, debugProp, animationDriver);
+    const isPassthrough = !splitStyles;
+    let contextForOverride = staticConfig.context;
+    if (splitStyles?.overriddenContextProps) {
+      const contextForProps = staticConfig.context || staticConfig.parentStaticConfig?.context;
+      if (contextForProps) {
+        for (const key in splitStyles.overriddenContextProps) {
+          overriddenContextProps = overriddenContextProps || {};
+          overriddenContextProps[key] = splitStyles.overriddenContextProps[key];
+        }
+        if (!staticConfig.context) contextForOverride = contextForProps;
+      }
+    }
+    const groupContext = groupName ? allGroupContexts?.[groupName] || null : null;
+    if (!isPassthrough && groupContext && props.containerType !== "normal") {
+      const groupState = groupContext?.state;
+      if (groupState && groupState.layout === void 0) {
+        if (splitStyles.style?.width || splitStyles.style?.height) groupState.layout = {
+          width: fromPx(splitStyles.style.width),
+          height: fromPx(splitStyles.style.height)
+        };
+      }
+    }
+    const hasEnterExitTransition = props.transition && typeof props.transition === "object" && !Array.isArray(props.transition) && ("enter" in props.transition || "exit" in props.transition);
+    if (!isPassthrough && (hasAnimationProp || groupName) && animationDriver?.avoidReRenders && !hasEnterExitTransition) {
+      let updateGroupListeners = function () {
+        const updatedState = stateRef.current.nextState;
+        if (groupContext) {
+          const {
+            group,
+            hasDynGroupChildren,
+            unmounted,
+            transition,
+            ...childrenGroupState
+          } = updatedState;
+          notifyGroupSubscribers(groupContext, stateRef.current.group || null, childrenGroupState);
+        }
+      };
+      const ogSetStateShallow = setStateShallow;
+      stateRef.current.updateStyleListener = () => {
+        const useStyleListener = stateRef.current.useStyleListener;
+        if (!useStyleListener) {
+          const pendingState = stateRef.current.nextState;
+          if (pendingState) {
+            stateRef.current.nextState = void 0;
+            ogSetStateShallow(pendingState);
+          }
+          return;
+        }
+        const updatedState = stateRef.current.nextState || state;
+        const mediaState2 = stateRef.current.nextMedia;
+        const nextStyles = getSplitStyles(props, staticConfig, theme, themeName, updatedState, mediaState2 ? {
+          ...styleProps,
+          mediaState: mediaState2
+        } : styleProps, null, componentContext, allGroupContexts, elementType, startedUnhydrated, debugProp, animationDriver);
+        const effectiveTransition = resolveEffectivePseudoTransition(stateRef.current.prevPseudoState, updatedState, nextStyles?.pseudoTransitions, props.transition);
+        stateRef.current.prevPseudoState = extractPseudoState(updatedState);
+        useStyleListener(nextStyles?.style || {}, effectiveTransition);
+      };
+      componentContext.mediaEmitListeners = componentContext.mediaEmitListeners || /* @__PURE__ */new Set();
+      if (!stateRef.current.mediaEmitCleanup) {
+        const updateListener = next => {
+          stateRef.current.nextMedia = next;
+          stateRef.current.updateStyleListener?.();
+        };
+        componentContext.mediaEmitListeners.add(updateListener);
+        stateRef.current.mediaEmitCleanup = () => {
+          componentContext.mediaEmitListeners?.delete(updateListener);
+        };
+      }
+      componentContext.mediaEmit = componentContext.mediaEmit || (next => {
+        for (const listener of componentContext.mediaEmitListeners) listener(next);
+      });
+      stateRef.current.setStateShallow = nextOrGetNext => {
+        const prev = stateRef.current.nextState || state;
+        const next = typeof nextOrGetNext === "function" ? nextOrGetNext(prev) : nextOrGetNext;
+        if (next === prev || isEqualShallow(prev, next)) return;
+        const canAvoidReRender = Object.keys(next).every(key => avoidReRenderKeys.has(key));
+        const updatedState = {
+          ...prev,
+          ...next
+        };
+        stateRef.current.nextState = updatedState;
+        if (canAvoidReRender) {
+          if (process.env.NODE_ENV === "development" && debugProp && debugProp !== "profile") {
+            console.groupCollapsed(`[\u26A1\uFE0F] avoid setState`, componentName, next, {
+              updatedState,
+              props
+            });
+            console.info(stateRef.current.host);
+            console.groupEnd();
+          }
+          updateGroupListeners();
+          stateRef.current.updateStyleListener?.();
+        } else {
+          if (process.env.NODE_ENV === "development" && debugProp && debugProp !== "profile") console.info(`[\u{1F40C}] re-render`, {
+            canAvoidReRender,
+            next
+          });
+          ogSetStateShallow(next);
+        }
+      };
+      setStateShallow = state2 => {
+        stateRef.current.setStateShallow?.(state2);
+      };
+    }
+    if (process.env.NODE_ENV === "development" && time) time`split-styles`;
+    if (splitStyles) {
+      if (props.group && props.untilMeasured === "hide" && !stateRef.current.hasMeasured) {
+        splitStyles.style = splitStyles.style || {};
+        splitStyles.style.opacity = 0;
+      }
+      if (splitStyles.dynamicThemeAccess != null) stateRef.current.isListeningToTheme = splitStyles.dynamicThemeAccess;
+    }
+    const hasRuntimeMediaKeys = splitStyles?.hasMedia && splitStyles.hasMedia !== true;
+    const shouldListenForMedia = didGetVariableValue() || hasRuntimeMediaKeys || noClass && splitStyles?.hasMedia === true;
+    const mediaListeningKeys = hasRuntimeMediaKeys ? splitStyles.hasMedia : null;
+    if (process.env.NODE_ENV === "development" && debugProp === "verbose") console.info(`useMedia() createComponent`, shouldListenForMedia, mediaListeningKeys);
+    setMediaShouldUpdate(componentContext, shouldListenForMedia, mediaListeningKeys);
+    const {
+      viewProps: viewPropsIn,
+      pseudos,
+      style: splitStylesStyle,
+      classNames,
+      pseudoGroups,
+      mediaGroups
+    } = splitStyles || {};
+    const propsWithAnimation = props;
+    const {
+      asChild,
+      children,
+      themeShallow,
+      spaceDirection: _spaceDirection,
+      onPress,
+      onLongPress,
+      onPressIn,
+      onPressOut,
+      onHoverIn,
+      onHoverOut,
+      onMouseUp,
+      onMouseDown,
+      onMouseEnter,
+      onMouseLeave,
+      onFocus,
+      onBlur,
+      separator,
+      passThrough,
+      forceStyle: _forceStyle,
+      onClick,
+      theme: _themeProp,
+      ...nonHanzoguiProps
+    } = viewPropsIn || {};
+    let viewProps = nonHanzoguiProps;
+    if (props.forceStyle) viewProps.forceStyle = props.forceStyle;
+    if (isHOC) {
+      if (typeof _themeProp !== "undefined") viewProps.theme = _themeProp;
+      if (typeof passThrough !== "undefined") viewProps.passThrough = passThrough;
+    }
+    let animationStyles;
+    const shouldUseAnimation = (inputStyle === "css" ? willBeAnimatedClient : willBeAnimated) && useAnimations && !isHOC;
+    let animatedRef;
+    if (shouldUseAnimation) {
+      const useStyleEmitter = animationDriver?.avoidReRenders ? listener => {
+        stateRef.current.useStyleListener = listener;
+      } : void 0;
+      const effectiveTransition = resolveEffectivePseudoTransition(stateRef.current.prevPseudoState, state, splitStyles?.pseudoTransitions, props.transition);
+      if (splitStyles) splitStyles.effectiveTransition = effectiveTransition;
+      stateRef.current.prevPseudoState = extractPseudoState(state);
+      const animations = useAnimations({
+        props: propsWithAnimation,
+        style: isHydrated ? splitStylesStyle || {} : {
+          ...splitStylesStyle
+        },
+        styleState: splitStyles,
+        useStyleEmitter,
+        presence,
+        componentState: state,
+        styleProps,
+        theme,
+        themeName,
+        pseudos: pseudos || null,
+        staticConfig,
+        stateRef
+      });
+      if (animations) {
+        if (animations.ref) animatedRef = animations.ref;
+        if (isHydrated && animations) {
+          animationStyles = animations.style;
+          viewProps.style = animationStyles;
+          if (animations.className) viewProps.className = `${state.unmounted === "should-enter" ? "t_unmounted " : ""}${viewProps.className || ""} ${animations.className}`;
+        }
+      }
+      if (process.env.NODE_ENV === "development" && time) time`animations`;
+    }
+    if (process.env.NODE_ENV === "development" && props.untilMeasured && !props.group) console.warn(`You set the untilMeasured prop without setting group. This doesn't work, be sure to set untilMeasured on the parent that sets group, not the children that use the $group- prop.
+
+If you meant to do this, you can disable this warning - either change untilMeasured and group at the same time, or do group={conditional ? 'name' : undefined}`);
+    if (process.env.NODE_ENV === "development" && time) time`destructure`;
+    if (!isPassthrough && groupContext && props.containerType !== "normal") nonHanzoguiProps.onLayout = composeEventHandlers(nonHanzoguiProps.onLayout, e => {
+      const layout = e.nativeEvent.layout;
+      groupContext.state.layout = layout;
+      stateRef.current.group?.emit({
+        layout
+      });
+      if (!stateRef.current.hasMeasured && props.untilMeasured === "hide") setState(prev => ({
+        ...prev
+      }));
+      stateRef.current.hasMeasured = true;
+    });
+    viewProps = hooks.usePropsTransform?.(elementType, nonHanzoguiProps, stateRef, stateRef.current.willHydrate) || nonHanzoguiProps;
+    if (!stateRef.current.composedRef) stateRef.current.composedRef = composeRefs(x => stateRef.current.host = x, forwardedRef, setElementProps, animatedRef);
+    viewProps.ref = stateRef.current.composedRef;
+    usePointerEvents(props, viewProps);
+    if (process.env.NODE_ENV === "development") {
+      if (!isReactNative && !isText && isWeb && !isHOC) React.Children.toArray(props.children).forEach(item => {
+        if (typeof item === "string" && item !== "\n") console.error(`Unexpected text node: ${item}. A text node cannot be a child of a <${staticConfig.componentName || propsIn.tag || "View"}>.`, props);
+      });
+    }
+    if (process.env.NODE_ENV === "development" && time) time`events-hooks`;
+    const unPress = () => {
+      setStateShallow({
+        press: false,
+        pressIn: false
+      });
+    };
+    if (process.env.NODE_ENV === "development" && isWeb) useIsomorphicLayoutEffect(() => {
+      if (debugProp === "verbose") {
+        let cssStyleDeclarationToObject = function (style) {
+          const styleObject = {};
+          for (let i = 0; i < style.length; i++) {
+            let prop = style[i];
+            styleObject[prop] = style.getPropertyValue(prop);
+          }
+          return styleObject;
+        };
+        const computed = stateRef.current.host ? cssStyleDeclarationToObject(getComputedStyle(stateRef.current.host)) : {};
+        console.groupCollapsed(`Rendered > (opacity: ${computed.opacity})`);
+        console.warn(stateRef.current.host);
+        console.warn(computed);
+        console.groupEnd();
+      }
+    });
+    useIsomorphicLayoutEffect(() => {
+      if (state.unmounted === true && hasEnterStyle) {
+        setStateShallow({
+          unmounted: "should-enter"
+        });
+        return;
+      }
+      if (state.unmounted) {
+        if (inputStyle === "css") {
+          let cancelled = false;
+          requestAnimationFrame(() => {
+            if (cancelled) return;
+            requestAnimationFrame(() => {
+              if (cancelled) return;
+              setStateShallow({
+                unmounted: false
+              });
+            });
+          });
+          return () => {
+            cancelled = true;
+          };
+        }
+        setStateShallow({
+          unmounted: false
+        });
+      }
+      return () => {
+        componentSetStates.delete(setState);
+        stateRef.current.mediaEmitCleanup?.();
+      };
+    }, [state.unmounted, inputStyle]);
+    useIsomorphicLayoutEffect(() => {
+      if (disabled) return;
+      if (!pseudoGroups && !mediaGroups) return;
+      if (!allGroupContexts) return;
+      return subscribeToContextGroup({
+        groupContext: allGroupContexts,
+        setStateShallow,
+        mediaGroups,
+        pseudoGroups
+      });
+    }, [allGroupContexts, disabled, pseudoGroups ? objectIdentityKey(pseudoGroups) : 0, mediaGroups ? objectIdentityKey(mediaGroups) : 0]);
+    const groupEmitter = stateRef.current.group;
+    useIsomorphicLayoutEffect(() => {
+      if (!groupContext || !groupEmitter) return;
+      notifyGroupSubscribers(groupContext, groupEmitter, state);
+    }, [groupContext, groupEmitter, state]);
+    const runtimePressStyle = !disabled && noClass && pseudos?.pressStyle;
+    const runtimeFocusStyle = !disabled && noClass && pseudos?.focusStyle;
+    const runtimeFocusVisibleStyle = !disabled && noClass && pseudos?.focusVisibleStyle;
+    const attachFocus = Boolean(runtimePressStyle || runtimeFocusStyle || runtimeFocusVisibleStyle || onFocus || onBlur || !!componentContext.setParentFocusState);
+    const hasDynamicGroupChildren = Boolean(groupName && state.hasDynGroupChildren);
+    const attachPress = Boolean(hasDynamicGroupChildren || runtimePressStyle || onPress || onPressOut || onPressIn || onMouseDown || onMouseUp || onLongPress || onClick || pseudos?.focusVisibleStyle);
+    const runtimeHoverStyle = !disabled && noClass && pseudos?.hoverStyle;
+    const needsHoverState = Boolean(hasDynamicGroupChildren || runtimeHoverStyle);
+    const attachHover = isWeb && !!(hasDynamicGroupChildren || needsHoverState || onMouseEnter || onMouseLeave);
+    const shouldAttach = !disabled && !props.asChild && Boolean(attachFocus || attachPress || attachHover || runtimePressStyle || runtimeHoverStyle || runtimeFocusStyle);
+    const needsPressState = Boolean(hasDynamicGroupChildren || runtimePressStyle);
+    if (process.env.NODE_ENV === "development" && time) time`events-setup`;
+    if (process.env.NODE_ENV === "development" && debugProp === "verbose") log(`\u{1FAA9} events()`, {
+      runtimeFocusStyle,
+      runtimePressStyle,
+      runtimeHoverStyle,
+      runtimeFocusVisibleStyle,
+      attachPress,
+      attachFocus,
+      attachHover,
+      shouldAttach,
+      needsHoverState,
+      pseudos
+    });
+    const events = shouldAttach ? {
+      onPressOut: attachPress ? e => {
+        unPress();
+        onPressOut?.(e);
+        onMouseUp?.(e);
+      } : void 0,
+      ...((attachHover || attachPress) && {
+        onMouseEnter: e => {
+          const next = {};
+          if (needsHoverState && !lastInteractionWasTouch.value) next.hover = true;
+          if (needsPressState) {
+            if (state.pressIn) next.press = true;
+          }
+          setStateShallow(next);
+          onHoverIn?.(e);
+          onMouseEnter?.(e);
+        },
+        onMouseLeave: e => {
+          const next = {};
+          if (needsHoverState) next.hover = false;
+          if (needsPressState) {
+            next.press = false;
+            next.pressIn = false;
+          }
+          setStateShallow(next);
+          onHoverOut?.(e);
+          onMouseLeave?.(e);
+        }
+      }),
+      onPressIn: attachPress ? e => {
+        if (needsPressState) setStateShallow({
+          press: true,
+          pressIn: true
+        });
+        onPressIn?.(e);
+        onMouseDown?.(e);
+        if (isWeb) componentSetStates.add(setState);
+      } : void 0,
+      onPress: attachPress ? e => {
+        unPress();
+        onClick?.(e);
+        if (onPress || onClick) e.stopPropagation();
+        onPress?.(e);
+        onLongPress?.(e);
+      } : void 0,
+      ...(attachFocus && {
+        onFocus: e => {
+          const next = {};
+          if (componentContext.setParentFocusState) {
+            componentContext.setParentFocusState({
+              focusWithin: true
+            });
+            next.focusWithin = true;
+          }
+          if (pseudos?.focusVisibleStyle) {
+            if (lastInteractionWasKeyboard.value) next.focusVisible = true;else next.focus = true;
+          } else next.focus = true;
+          setStateShallow(next);
+          onFocus?.(e);
+        },
+        onBlur: e => {
+          if (componentContext.setParentFocusState) componentContext.setParentFocusState({
+            focusWithin: false
+          });
+          setStateShallow({
+            focus: false,
+            focusVisible: false,
+            focusWithin: false
+          });
+          onBlur?.(e);
+        }
+      })
+    } : null;
+    if (events && !isReactNative) Object.assign(viewProps, getWebEvents(events));
+    if (process.env.NODE_ENV === "development" && time) time`events`;
+    if (process.env.NODE_ENV === "development" && debugProp === "verbose") log(`events`, {
+      events,
+      attachHover,
+      attachPress
+    });
+    const propsWithHref = props;
+    const propsInWithHref = propsIn;
+    [componentName, props.testID ?? propsIn.testID ?? props.accessibilityLabel ?? propsIn.accessibilityLabel ?? (typeof propsWithHref.href === "string" ? propsWithHref.href : null) ?? (typeof propsInWithHref.href === "string" ? propsInWithHref.href : null)].filter(Boolean).join(":");
+    if (process.env.NODE_ENV === "development" && time) time`hooks`;
+    if (asChild) {
+      elementType = Slot;
+      {
+        const passEvents = getWebEvents({
+          onPress,
+          onLongPress,
+          onPressIn,
+          onPressOut,
+          onMouseUp,
+          onMouseDown,
+          onMouseEnter,
+          onMouseLeave
+        }, asChild === "web" || asChild === "except-style-web");
+        Object.assign(viewProps, passEvents);
+      }
+    }
+    if (process.env.NODE_ENV === "development" && time) time`spaced-as-child`;
+    let content;
+    if (isPassthrough) content = React.createElement(BaseComponent, {
+      style: {
+        display: "contents"
+      }
+    }, propsIn.children);else {
+      if (hooks.useChildren) content = hooks.useChildren(elementType, content || children, viewProps);
+      const isRenderPropString = typeof renderProp === "string";
+      if (renderProp && !isRenderPropString) {
+        const out = getCustomRender(renderProp, content || children, viewProps, componentState);
+        if (out) {
+          viewProps = out.viewProps;
+          elementType = out.elementType;
+        }
+      }
+      if (!content) {
+        if (isRenderPropString) viewProps.render;
+        content = React.createElement(elementType, viewProps, content || children);
+      }
+      if (process.env.NODE_ENV === "development" && time) time`use-children`;
+    }
+    const ResetPresence = animationDriver?.ResetPresence;
+    const needsReset = Boolean(
+    // not when passing down to child
+    !asChild && splitStyles && !isHOC && ResetPresence && willBeAnimated && (hasEnterStyle || presenceState));
+    const hasEverReset = stateRef.current.hasEverResetPresence;
+    if (needsReset && !hasEverReset) stateRef.current.hasEverResetPresence = true;
+    if ((needsReset || hasEverReset) && ResetPresence) content = /* @__PURE__ */jsx(ResetPresence, {
+      disabled: !needsReset,
+      children: content
+    });
+    if (process.env.NODE_ENV === "development" && time) time`create-element`;
+    if ("focusWithinStyle" in propsIn || pseudos?.focusWithinStyle) content = /* @__PURE__ */jsx(ComponentContext.Provider, {
+      ...componentContext,
+      setParentFocusState: setStateShallow,
+      children: content
+    });
+    if ("group" in props) content = /* @__PURE__ */jsx(GroupContext.Provider, {
+      value: allGroupContexts,
+      children: content
+    });
+    if (!asChild && isText && !hasTextAncestor) content = /* @__PURE__ */jsx(ComponentContext.Provider, {
+      ...componentContext,
+      inText: true,
+      children: content
+    });
+    if (process.env.NODE_ENV === "development" && time) time`group-context`;
+    content = disableTheme || !splitStyles ? content : getThemedChildren(themeState, content, themeStateProps, false, stateRef);
+    if (process.env.NODE_ENV === "development" && time) time`themed-children`;
+    if (isReactNative && !asChild) content = /* @__PURE__ */jsx("span", {
+      className: "_dsp_contents",
+      ...(!isPassthrough && isHydrated && events && getWebEvents(events)),
+      children: content
+    });
+    if (overriddenContextProps && contextForOverride) {
+      const Provider = contextForOverride.Provider;
+      for (const key in styledContextValue) if (!(key in overriddenContextProps)) overriddenContextProps[key] = styledContextValue[key];
+      content = /* @__PURE__ */jsx(Provider, {
+        __disableMergeDefaultValues: true,
+        ...overriddenContextProps,
+        children: content
+      });
+    }
+    if (process.env.NODE_ENV === "development" && time) time`context-override`;
+    if (startedUnhydrated && splitStyles) content = /* @__PURE__ */jsxs(Fragment, {
+      children: [content, !isHydrated ? getStyleTags(Object.values(splitStyles.rulesToInsert)) : null]
+    });
+    if (process.env.NODE_ENV === "development" && time) time`style-tags`;
+    if (process.env.NODE_ENV === "development") {
+      if (debugProp && debugProp !== "profile") {
+        const title = `render <${typeof elementType === "string" ? elementType : "Component"} /> (${internalID}) with props`;
+        if (!isWeb || !isClient) {
+          log(title);
+          log(`state: `, state);
+          if (isDevTools) log("viewProps", viewProps);
+          log(`final styles:`);
+          for (const key in splitStylesStyle) log(key, splitStylesStyle[key]);
+        } else {
+          console.groupCollapsed(title);
+          try {
+            log("viewProps", viewProps);
+            log("children", content);
+            if (typeof window !== "undefined") log({
+              propsIn,
+              props,
+              attachPress,
+              animationStyles,
+              classNames,
+              content,
+              elementType,
+              events,
+              isAnimated,
+              hasRuntimeMediaKeys,
+              isStringElement,
+              mediaListeningKeys,
+              pseudos,
+              shouldAttach,
+              noClass,
+              shouldListenForMedia,
+              splitStyles,
+              splitStylesStyle,
+              state,
+              stateRef,
+              staticConfig,
+              styleProps,
+              themeState,
+              viewProps,
+              willBeAnimated,
+              startedUnhydrated
+            });
+          } catch {} finally {
+            console.groupEnd();
+          }
+        }
+        if (debugProp === "break") {}
+      }
+    }
+    if (process.env.NODE_ENV === "development" && time) {
+      time`rest`;
+      if (!globalThis["willPrint"]) {
+        globalThis["willPrint"] = true;
+        setTimeout(() => {
+          delete globalThis["willPrint"];
+          time.print();
+          time = null;
+        }, 50);
+      }
+    }
+    return content;
+  });
+  function notifyGroupSubscribers(groupContext, groupEmitter, pseudo) {
+    if (!groupContext || !groupEmitter) return;
+    const nextState = {
+      ...groupContext.state,
+      pseudo
+    };
+    groupEmitter.emit(nextState);
+    groupContext.state = nextState;
+  }
+  if (staticConfig.componentName) component.displayName = staticConfig.componentName;
+  let res = component;
+  res = React.memo(res);
+  res.staticConfig = staticConfig;
+  function extendStyledConfig(extended) {
+    return {
+      ...staticConfig,
+      ...extended,
+      neverFlatten: true,
+      isHOC: true,
+      isStyledHOC: false
+    };
+  }
+  function styleable(Component2, options) {
+    let out = typeof Component2 === "function" && Component2.length === 1 ? Component2 : React.forwardRef(Component2);
+    const extendedConfig = extendStyledConfig(options?.staticConfig);
+    out = options?.disableTheme ? out : themeable(out, extendedConfig, true);
+    if (extendedConfig.memo || process.env.TAMAGUI_MEMOIZE_STYLEABLE) out = React.memo(out);
+    out.staticConfig = extendedConfig;
+    out.styleable = styleable;
+    return out;
+  }
+  res.styleable = styleable;
+  return res;
+}
+const fromPx = val => {
+  if (typeof val === "number") return val;
+  if (typeof val === "string") return +val.replace("px", "");
+  return 0;
+};
+const getCustomRender = (renderProp, content, viewProps, state) => {
+  if (typeof renderProp === "function") renderProp = getRenderElementForPlatform(renderProp(viewProps, state));
+  if (renderProp) {
+    if (typeof renderProp === "object" && React.isValidElement(renderProp)) {
+      if (getRenderElementForPlatform(renderProp)) {
+        const elementProps = renderProp.props;
+        const mergedProps = elementProps ? mergeRenderElementProps(elementProps, viewProps, content) : viewProps;
+        return {
+          elementType: renderProp.type,
+          viewProps: mergedProps
+        };
+      }
+    }
+  }
+};
+function getRenderElementForPlatform(potential) {
+  return potential;
+}
+export { componentSetStates, createComponent };
+//# sourceMappingURL=createComponent.mjs.map