@tamagui/core 1.12.2 → 1.13.0

package/dist/cjs/createComponent.js

@@ -0,0 +1,991 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createComponent_exports = {};
+__export(createComponent_exports, {
+  Spacer: () => Spacer,
+  Unspaced: () => Unspaced,
+  createComponent: () => createComponent,
+  defaultComponentState: () => defaultComponentState,
+  mouseUps: () => mouseUps,
+  spacedChildren: () => spacedChildren
+});
+module.exports = __toCommonJS(createComponent_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_compose_refs = require("@tamagui/compose-refs");
+var import_constants = require("@tamagui/constants");
+var import_helpers = require("@tamagui/helpers");
+var import_react_native_use_responder_events = require("@tamagui/react-native-use-responder-events");
+var import_react = __toESM(require("react"));
+var import_config = require("./config");
+var import_constants2 = require("./constants/constants");
+var import_FontLanguageContext = require("./contexts/FontLanguageContext");
+var import_TextAncestorContext = require("./contexts/TextAncestorContext");
+var import_createVariable = require("./createVariable");
+var import_extendStaticConfig = require("./helpers/extendStaticConfig");
+var import_getRect = require("./helpers/getRect");
+var import_getSplitStyles = require("./helpers/getSplitStyles");
+var import_insertStyleRule = require("./helpers/insertStyleRule");
+var import_mergeProps = require("./helpers/mergeProps");
+var import_proxyThemeVariables = require("./helpers/proxyThemeVariables");
+var import_useShallowSetState = require("./helpers/useShallowSetState");
+var import_useElementLayout = require("./hooks/useElementLayout");
+var import_useMedia = require("./hooks/useMedia");
+var import_useServerHooks = require("./hooks/useServerHooks");
+var import_useTheme = require("./hooks/useTheme");
+var import_Pressability = require("./vendor/Pressability");
+var import_Slot = require("./views/Slot");
+var import_Theme = require("./views/Theme");
+process.env.TAMAGUI_TARGET;
+const defaultComponentState = {
+  hover: false,
+  press: false,
+  pressIn: false,
+  focus: false,
+  unmounted: true
+};
+const defaultComponentStateMounted = {
+  ...defaultComponentState,
+  unmounted: false
+};
+let tamaguiConfig;
+let AnimatedText;
+let AnimatedView;
+let initialTheme;
+const mouseUps = /* @__PURE__ */ new Set();
+if (typeof document !== "undefined") {
+  const cancelTouches = () => {
+    mouseUps.forEach((x) => x());
+    mouseUps.clear();
+  };
+  addEventListener("mouseup", cancelTouches);
+  addEventListener("touchend", cancelTouches);
+  addEventListener("touchcancel", cancelTouches);
+}
+function mergeShorthands({ defaultProps }, { shorthands }) {
+  for (const key of Object.keys(defaultProps)) {
+    defaultProps[shorthands[key] || key] = defaultProps[key];
+  }
+}
+let BaseText;
+let BaseView;
+if (process.env.TAMAGUI_TARGET === "native") {
+  const native = require("react-native");
+  BaseText = native.Text || native.default.Text;
+  BaseView = native.View || native.default.View;
+}
+function createComponent(configIn, ParentComponent) {
+  const staticConfig = (() => {
+    const next = (0, import_extendStaticConfig.extendStaticConfig)(configIn, ParentComponent);
+    if ("parsed" in next) {
+      return next;
+    } else {
+      return (0, import_extendStaticConfig.parseStaticConfig)(next);
+    }
+  })();
+  const defaultComponentClassName = `is_${staticConfig.componentName}`;
+  let tamaguiDefaultProps;
+  let defaultTag;
+  const component = (0, import_react.forwardRef)((propsIn, forwardedRef) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (process.env.NODE_ENV === "test") {
+      if (propsIn["data-test-renders"]) {
+        (_a = propsIn["data-test-renders"])["current"] ?? (_a["current"] = 0);
+        propsIn["data-test-renders"]["current"] += 1;
+      }
+    }
+    let props;
+    if (tamaguiDefaultProps && !propsIn.asChild) {
+      props = (0, import_mergeProps.mergeProps)(tamaguiDefaultProps, propsIn)[0];
+    } else {
+      props = propsIn;
+    }
+    const debugProp = props["debug"];
+    const { Component, isText, isZStack } = staticConfig;
+    const componentName = props.componentName || staticConfig.componentName;
+    const componentClassName = props.asChild ? "" : props.componentName ? `is_${props.componentName}` : defaultComponentClassName;
+    const animationsConfig = tamaguiConfig.animations;
+    const useAnimations = animationsConfig == null ? void 0 : animationsConfig.useAnimations;
+    const avoidClassesWhileAnimating = animationsConfig.isReactNative;
+    const hasEnterStyle = !!props.enterStyle;
+    const needsMount = Boolean(
+      (import_constants.isWeb ? import_constants.isClient : true) && (hasEnterStyle || props.animation)
+    );
+    const states = (0, import_useServerHooks.useServerState)(
+      needsMount ? defaultComponentState : defaultComponentStateMounted
+    );
+    const state = propsIn.forceStyle ? { ...states[0], [propsIn.forceStyle]: true } : states[0];
+    const setState = states[1];
+    const setStateShallow = (0, import_useShallowSetState.useShallowSetState)(setState, true, debugProp, componentName);
+    const stateRef = (0, import_react.useRef)(
+      void 0
+    );
+    stateRef.current ?? (stateRef.current = {});
+    const isAnimated = (() => {
+      const next = !!(useAnimations && props.animation);
+      if (next && !stateRef.current.hasAnimated) {
+        stateRef.current.hasAnimated = true;
+      }
+      return next || stateRef.current.hasAnimated;
+    })();
+    const usePresence = (_b = tamaguiConfig.animations) == null ? void 0 : _b.usePresence;
+    const presence = !import_constants.isRSC && isAnimated ? usePresence() : null;
+    if (isAnimated && presence) {
+      const presenceState = presence[2];
+      if (presenceState) {
+        if (state.unmounted && presenceState.enterVariant) {
+          props[presenceState.enterVariant] = true;
+        }
+        if (!presenceState.isPresent && presenceState.exitVariant) {
+          props[presenceState.exitVariant] = true;
+        }
+      }
+    }
+    const isReactNative = Boolean(
+      staticConfig.isReactNative || isAnimated && tamaguiConfig.animations.isReactNative
+    );
+    if (process.env.NODE_ENV === "development") {
+      if (debugProp) {
+        const name = `${componentName || (Component == null ? void 0 : Component.displayName) || (Component == null ? void 0 : Component.name) || "[Unnamed Component]"}`;
+        const type = isReactNative ? "(rnw)" : "";
+        const dataIs = propsIn["data-is"] || "";
+        const banner = `${name}${dataIs ? ` ${dataIs}` : ""} ${type}`;
+        console.group(`%c ${banner}`, "background: yellow;");
+        if (!import_constants.isServer) {
+          console.log("state", state);
+        }
+      }
+    }
+    const shouldAvoidClasses = !import_constants.isWeb || !!(props.animation && avoidClassesWhileAnimating) || !staticConfig.acceptsClassName;
+    const shouldForcePseudo = !!propsIn.forceStyle;
+    const noClassNames = shouldAvoidClasses || shouldForcePseudo;
+    const themeState = (0, import_useTheme.useThemeWithState)({
+      name: props.theme,
+      componentName,
+      reset: props.reset,
+      inverse: props.themeInverse,
+      // @ts-expect-error
+      disable: props["data-themeable"],
+      debug: props.debug,
+      shouldUpdate: () => !!stateRef.current.didAccessThemeVariableValue
+    });
+    const hasTextAncestor = !!(import_constants.isWeb && isText ? (0, import_react.useContext)(import_TextAncestorContext.TextAncestorContext) : false);
+    const languageContext = import_constants.isRSC ? null : (0, import_react.useContext)(import_FontLanguageContext.FontLanguageContext);
+    const isDisabled = props.disabled ?? ((_c = props.accessibilityState) == null ? void 0 : _c.disabled);
+    const isTaggable = !Component || typeof Component === "string";
+    const element = import_constants.isWeb ? isTaggable ? props.tag || defaultTag || Component : Component : Component;
+    const BaseTextComponent = BaseText || element || "span";
+    const BaseViewComponent = BaseView || element || (hasTextAncestor ? "span" : "div");
+    let elementType = isText ? (isAnimated ? AnimatedText : null) || BaseTextComponent : (isAnimated ? AnimatedView : null) || BaseViewComponent;
+    elementType = Component || elementType;
+    const isStringElement = typeof elementType === "string";
+    const isExiting = (presence == null ? void 0 : presence[0]) === false;
+    const mediaState = (0, import_useMedia.useMedia)(
+      // @ts-ignore, we just pass a stable object so we can get it later with
+      // should match to the one used in `setMediaShouldUpdate` below
+      stateRef,
+      debugProp ? { props, staticConfig } : null
+    );
+    (0, import_createVariable.setDidGetVariableValue)(false);
+    const splitStyles = (0, import_getSplitStyles.useSplitStyles)(
+      props,
+      staticConfig,
+      themeState.theme,
+      {
+        ...state,
+        mediaState,
+        noClassNames,
+        dynamicStylesInline: noClassNames,
+        hasTextAncestor,
+        resolveVariablesAs: "auto",
+        isExiting
+      },
+      null,
+      languageContext || void 0,
+      elementType,
+      debugProp
+    );
+    const isMediaSpaced = Array.isArray(splitStyles.hasMedia);
+    const shouldListenForMedia = (0, import_createVariable.didGetVariableValue)() || isMediaSpaced || noClassNames && splitStyles.hasMedia === true;
+    (0, import_useMedia.setMediaShouldUpdate)(stateRef, {
+      enabled: shouldListenForMedia,
+      keys: noClassNames && isMediaSpaced ? splitStyles.hasMedia : null
+    });
+    const hostRef = (0, import_useServerHooks.useServerRef)(null);
+    const isAnimatedReactNativeWeb = isAnimated && avoidClassesWhileAnimating;
+    if (process.env.NODE_ENV === "development") {
+      if (!process.env.TAMAGUI_TARGET) {
+        console.error(
+          `No process.env.TAMAGUI_TARGET set, please set it to "native" or "web".`
+        );
+      }
+      if (debugProp) {
+        console.groupCollapsed("props");
+        console.log("props in", propsIn, "mapped to", props, "in order", Object.keys(props));
+        console.log("splitStyles", splitStyles);
+        console.log("shouldListenForMedia", shouldListenForMedia);
+        console.log("className", Object.values(splitStyles.classNames));
+        if (import_constants.isClient) {
+          console.log("ref", hostRef, "(click to view)");
+        }
+        console.groupEnd();
+        if (debugProp === "break") {
+          debugger;
+        }
+      }
+    }
+    const {
+      viewProps: viewPropsIn,
+      pseudos,
+      style: splitStylesStyle,
+      classNames,
+      space
+    } = splitStyles;
+    const propsWithAnimation = props;
+    let animationStyles;
+    if (!import_constants.isRSC && isAnimated && useAnimations) {
+      const animations = useAnimations({
+        props: propsWithAnimation,
+        style: splitStylesStyle,
+        presence,
+        state,
+        pseudos: pseudos || null,
+        onDidAnimate: props.onDidAnimate,
+        hostRef,
+        staticConfig
+      });
+      if (animations) {
+        animationStyles = animations.style;
+      }
+    }
+    const {
+      hitSlop,
+      asChild,
+      children,
+      onPress,
+      onPressIn,
+      onPressOut,
+      onHoverIn,
+      onHoverOut,
+      themeShallow,
+      spaceDirection: _spaceDirection,
+      disabled: disabledProp,
+      onMouseUp,
+      onMouseDown,
+      onMouseEnter,
+      onMouseLeave,
+      hrefAttrs,
+      separator,
+      // ignore from here on out
+      forceStyle: _forceStyle,
+      // @ts-ignore  for next/link compat etc
+      onClick,
+      theme: _themeProp,
+      // @ts-ignore
+      defaultVariants,
+      ...nonTamaguiProps
+    } = viewPropsIn;
+    const disabled = props.accessibilityState != null && props.accessibilityState.disabled === true || props.accessibilityDisabled;
+    let viewProps;
+    if (process.env.TAMAGUI_TARGET === "web" && !isReactNative) {
+      const {
+        // event props
+        onMoveShouldSetResponder,
+        onMoveShouldSetResponderCapture,
+        onResponderEnd,
+        onResponderGrant,
+        onResponderMove,
+        onResponderReject,
+        onResponderRelease,
+        onResponderStart,
+        onResponderTerminate,
+        onResponderTerminationRequest,
+        onScrollShouldSetResponder,
+        onScrollShouldSetResponderCapture,
+        onSelectionChangeShouldSetResponder,
+        onSelectionChangeShouldSetResponderCapture,
+        onStartShouldSetResponder,
+        onStartShouldSetResponderCapture,
+        // android
+        collapsable,
+        focusable,
+        // deprecated,
+        accessible,
+        accessibilityDisabled,
+        onLayout,
+        ...webProps
+      } = nonTamaguiProps;
+      viewProps = webProps;
+      if (!import_constants.isRSC) {
+        usePlatformMethods(hostRef);
+        (0, import_useElementLayout.useElementLayout)(hostRef, onLayout);
+        (0, import_react_native_use_responder_events.useResponderEvents)(hostRef, {
+          onMoveShouldSetResponder,
+          onMoveShouldSetResponderCapture,
+          onResponderEnd,
+          onResponderGrant,
+          onResponderMove,
+          onResponderReject,
+          onResponderRelease,
+          onResponderStart,
+          onResponderTerminate,
+          onResponderTerminationRequest,
+          onScrollShouldSetResponder,
+          onScrollShouldSetResponderCapture,
+          onSelectionChangeShouldSetResponder,
+          onSelectionChangeShouldSetResponderCapture,
+          onStartShouldSetResponder,
+          onStartShouldSetResponderCapture
+        });
+      }
+      if (props.href !== void 0 && hrefAttrs !== void 0) {
+        const { download, rel, target } = hrefAttrs;
+        if (download != null) {
+          viewProps.download = download;
+        }
+        if (rel != null) {
+          viewProps.rel = rel;
+        }
+        if (typeof target === "string") {
+          viewProps.target = target.charAt(0) !== "_" ? `_${target}` : target;
+        }
+      }
+      const _focusable = focusable !== void 0 ? focusable : accessible;
+      const role = viewProps.role;
+      if (_focusable === false) {
+        viewProps.tabIndex = "-1";
+      }
+      if (
+        // These native elements are focusable by default
+        elementType === "a" || elementType === "button" || elementType === "input" || elementType === "select" || elementType === "textarea"
+      ) {
+        if (_focusable === false || accessibilityDisabled === true) {
+          viewProps.tabIndex = "-1";
+        }
+      } else if (
+        // These roles are made focusable by default
+        role === "button" || role === "checkbox" || role === "link" || role === "radio" || role === "textbox" || role === "switch"
+      ) {
+        if (_focusable !== false) {
+          viewProps.tabIndex = "0";
+        }
+      }
+      if (_focusable === true) {
+        viewProps.tabIndex = "0";
+      }
+    } else {
+      viewProps = nonTamaguiProps;
+    }
+    viewProps.ref = (0, import_compose_refs.useComposedRefs)(hostRef, forwardedRef);
+    if (process.env.NODE_ENV === "development" && !isText && import_constants.isWeb) {
+      import_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 <View>.`
+          );
+        }
+      });
+    }
+    const unPress = (0, import_react.useCallback)(() => {
+      setStateShallow({
+        press: false,
+        pressIn: false
+      });
+    }, [setStateShallow]);
+    if (import_constants.isWeb) {
+      (0, import_react.useEffect)(() => {
+        return () => {
+          mouseUps.delete(unPress);
+        };
+      }, []);
+    }
+    const shouldSetMounted = needsMount && state.unmounted;
+    (0, import_react.useEffect)(() => {
+      if (!shouldSetMounted)
+        return;
+      if (state.unmounted === true && needsMount) {
+        setStateShallow({
+          unmounted: false
+        });
+        return;
+      }
+      setStateShallow({
+        unmounted: false
+      });
+    }, [shouldSetMounted, state.unmounted]);
+    let styles;
+    if (isStringElement && shouldAvoidClasses && !shouldForcePseudo) {
+      styles = {
+        ...animationStyles ?? splitStylesStyle
+      };
+    } else {
+      styles = [animationStyles ?? splitStylesStyle];
+      if (shouldForcePseudo) {
+        const next = {};
+        styles.forEach((style) => Object.assign(next, style));
+        Object.assign(splitStyles.style, next);
+      }
+    }
+    let fontFamily = isText ? splitStyles.fontFamily || staticConfig.defaultProps.fontFamily : null;
+    if (fontFamily && fontFamily[0] === "$") {
+      fontFamily = fontFamily.slice(1);
+    }
+    const fontFamilyClassName = fontFamily ? `font_${fontFamily}` : "";
+    const classList = [
+      hasEnterStyle && (state.unmounted && needsMount || !import_constants.isClient) ? "t_will-mount" : "",
+      componentName ? componentClassName : "",
+      fontFamilyClassName,
+      classNames ? Object.values(classNames).join(" ") : ""
+    ];
+    const className = classList.join(" ");
+    if (process.env.TAMAGUI_TARGET === "web") {
+      const style = animationStyles ?? splitStyles.style;
+      if (isAnimatedReactNativeWeb) {
+        viewProps.style = style;
+      } else if (isReactNative) {
+        const rnwStyle = { $$css: true };
+        for (const name of className.split(" ")) {
+          rnwStyle[name] = name;
+        }
+        viewProps.style = [rnwStyle, ...Array.isArray(style) ? style : [style]];
+        if (process.env.NODE_ENV === "development") {
+          Object.keys(viewProps).forEach((key) => {
+            if (key.startsWith("data-")) {
+              viewProps.dataSet ?? (viewProps.dataSet = {});
+              viewProps.dataSet[key.replace("data-", "")] = viewProps[key];
+              delete viewProps[key];
+            }
+          });
+        }
+      } else {
+        viewProps.className = className;
+        viewProps.style = style;
+      }
+    }
+    if (process.env.TAMAGUI_TARGET === "native") {
+      if (splitStyles.fontFamily) {
+        const faceInfo = (_d = tamaguiConfig.fontsParsed[splitStyles.fontFamily]) == null ? void 0 : _d.face;
+        if (faceInfo) {
+          const [weight, style] = (() => {
+            var _a2, _b2;
+            let weight2;
+            let style2;
+            for (let i = styles.length; i >= 0; i--) {
+              weight2 ?? (weight2 = (_a2 = styles[i]) == null ? void 0 : _a2.fontWeight);
+              style2 ?? (style2 = (_b2 = styles[i]) == null ? void 0 : _b2.fontStyle);
+            }
+            return [weight2 || "400", style2 || "normal"];
+          })();
+          const overrideFace = (_f = (_e = faceInfo[weight]) == null ? void 0 : _e[style]) == null ? void 0 : _f.val;
+          if (overrideFace) {
+            for (const style2 of styles) {
+              if (style2 == null ? void 0 : style2.fontFamily) {
+                style2.fontFamily = overrideFace;
+                style2.fontWeight = void 0;
+                style2.fontStyle = void 0;
+              }
+            }
+          }
+        }
+      }
+      viewProps.style = styles;
+    }
+    const runtimePressStyle = !disabled && noClassNames && (pseudos == null ? void 0 : pseudos.pressStyle);
+    const attachPress = Boolean(
+      runtimePressStyle || onPress || onPressOut || onPressIn || onClick
+    );
+    const runtimeHoverStyle = !disabled && noClassNames && (pseudos == null ? void 0 : pseudos.hoverStyle);
+    const isHoverable = import_constants.isWeb && !!(runtimeHoverStyle || onHoverIn || onHoverOut || onMouseEnter || onMouseLeave);
+    const handlesPressEvents = !(import_constants.isWeb || asChild);
+    const shouldAttach = Boolean(
+      attachPress || isHoverable || noClassNames && "pressStyle" in props || import_constants.isWeb && noClassNames && "hoverStyle" in props
+    );
+    const events = shouldAttach && !import_constants.isRSC && !isDisabled && !asChild ? {
+      onPressOut: attachPress ? (e) => {
+        unPress();
+        onPressOut == null ? void 0 : onPressOut(e);
+        onMouseUp == null ? void 0 : onMouseUp(e);
+      } : void 0,
+      ...isHoverable && {
+        onMouseEnter: isHoverable ? (e) => {
+          const next = {};
+          if (isHoverable) {
+            next.hover = true;
+          }
+          if (state.pressIn) {
+            next.press = true;
+          }
+          if (isHoverable || state.pressIn) {
+            setStateShallow(next);
+          }
+          onHoverIn == null ? void 0 : onHoverIn(e);
+          onMouseEnter == null ? void 0 : onMouseEnter(e);
+        } : void 0,
+        onMouseLeave: isHoverable ? (e) => {
+          const next = {};
+          mouseUps.add(unPress);
+          if (isHoverable) {
+            next.hover = false;
+          }
+          if (state.pressIn) {
+            next.press = false;
+            next.pressIn = false;
+          }
+          if (Object.keys(next).length) {
+            setStateShallow(next);
+          }
+          onHoverOut == null ? void 0 : onHoverOut(e);
+          onMouseLeave == null ? void 0 : onMouseLeave(e);
+        } : void 0
+      },
+      onPressIn: attachPress ? (e) => {
+        setStateShallow({
+          press: true,
+          pressIn: true,
+          hover: false
+        });
+        onPressIn == null ? void 0 : onPressIn(e);
+        onMouseDown == null ? void 0 : onMouseDown(e);
+        if (import_constants.isWeb) {
+          mouseUps.add(unPress);
+        }
+      } : void 0,
+      onPress: attachPress ? (e) => {
+        unPress();
+        onClick == null ? void 0 : onClick(e);
+        onPress == null ? void 0 : onPress(e);
+      } : void 0,
+      // replicating TouchableWithoutFeedback
+      ...!import_constants.isWeb && {
+        cancelable: !props.rejectResponderTermination,
+        disabled: isDisabled,
+        hitSlop: props.hitSlop,
+        delayLongPress: props.delayLongPress,
+        delayPressIn: props.delayPressIn,
+        delayPressOut: props.delayPressOut,
+        focusable: viewProps.focusable ?? true,
+        minPressDuration: 0
+      }
+    } : null;
+    if (process.env.TAMAGUI_TARGET === "native") {
+      const attachFocus = !!(pseudos == null ? void 0 : pseudos.focusStyle);
+      if (attachFocus) {
+        viewProps.onFocus = (0, import_Slot.mergeEvent)(viewProps.onFocus, () => {
+          setStateShallow({ focus: true });
+        });
+        viewProps.onBlur = (0, import_Slot.mergeEvent)(viewProps.onBlur, () => {
+          setStateShallow({ focus: false });
+        });
+      }
+      const pressability = (0, import_Pressability.usePressability)(events ? { ...events, hitSlop } : {});
+      if (attachPress && events) {
+        for (const key in pressability) {
+          const og = props[key];
+          const val = pressability[key];
+          viewProps[key] = og && !dontComposePressabilityKeys[key] ? (0, import_helpers.composeEventHandlers)(og, val) : val;
+        }
+      }
+    }
+    const shouldReset = !!(themeShallow && themeState.isNewTheme);
+    if (shouldReset) {
+      stateRef.current.themeShallow = true;
+    }
+    let content = !children || asChild ? children : spacedChildren({
+      separator,
+      children,
+      space,
+      direction: props.spaceDirection || "both",
+      isZStack,
+      debug: debugProp
+    });
+    if (asChild) {
+      elementType = import_Slot.Slot;
+      viewProps = {
+        ...viewProps,
+        onPress,
+        onPressIn,
+        onPressOut
+      };
+    }
+    content = (0, import_react.createElement)(elementType, viewProps, content);
+    content = (0, import_Theme.useThemedChildren)(themeState, content, {
+      shallow: stateRef.current.themeShallow
+    });
+    if (process.env.TAMAGUI_TARGET === "web") {
+      if (events || isAnimatedReactNativeWeb) {
+        content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "span",
+          {
+            className: `${isAnimatedReactNativeWeb ? className : ""}  _dsp_contents`,
+            ...events && {
+              onMouseEnter: events.onMouseEnter,
+              onMouseLeave: events.onMouseLeave,
+              onClick: events.onPress,
+              onMouseDown: events.onPressIn,
+              onMouseUp: events.onPressOut,
+              onTouchStart: events.onPressIn,
+              onTouchEnd: events.onPressOut
+            },
+            children: content
+          }
+        );
+      }
+    }
+    if (process.env.NODE_ENV === "development" && process.env.DEBUG !== "tamagui") {
+      if (debugProp) {
+        const element2 = typeof elementType === "string" ? elementType : "Component";
+        console.groupCollapsed(`render <${element2} /> with props`, viewProps);
+        for (const key in viewProps) {
+          console.log(key, viewProps[key]);
+        }
+        console.log("children", content);
+        console.groupEnd();
+        if (typeof window !== "undefined") {
+          console.log({ state, themeState, isAnimated, isAnimatedReactNativeWeb, tamaguiDefaultProps, viewProps, splitStyles, animationStyles, handlesPressEvents, isStringElement, classNamesIn: (_g = props.className) == null ? void 0 : _g.split(" "), classNamesOut: (_h = viewProps.className) == null ? void 0 : _h.split(" "), events, shouldAttach, styles, pseudos, content, shouldAvoidClasses, avoidClasses: avoidClassesWhileAnimating, animation: props.animation, style: splitStylesStyle, staticConfig, tamaguiConfig, shouldForcePseudo, classNamesFull: Object.fromEntries(Object.entries(classNames).map(([k, v]) => [v, (0, import_insertStyleRule.getAllSelectors)()[v]])) });
+        }
+        console.groupEnd();
+      }
+    }
+    return content;
+  });
+  if (staticConfig.componentName) {
+    component.displayName = staticConfig.componentName;
+  }
+  (0, import_config.onConfiguredOnce)((conf) => {
+    if (!tamaguiConfig) {
+      tamaguiConfig = conf;
+      if (tamaguiConfig.animations) {
+        AnimatedText = tamaguiConfig.animations.Text;
+        AnimatedView = tamaguiConfig.animations.View;
+      }
+      if (!initialTheme) {
+        const next = conf.themes[Object.keys(conf.themes)[0]];
+        initialTheme = (0, import_proxyThemeVariables.proxyThemeVariables)(next);
+        if (process.env.NODE_ENV === "development") {
+          if (!initialTheme) {
+            console.log("Warning: Missing theme");
+          }
+        }
+      }
+    }
+    mergeShorthands(staticConfig, tamaguiConfig);
+    let defaultPropsIn = staticConfig.defaultProps || {};
+    const parentNames = [...staticConfig.parentNames || [], staticConfig.componentName];
+    if (tamaguiConfig.defaultProps && parentNames && staticConfig.componentName) {
+      defaultPropsIn = mergeConfigDefaultProps(
+        staticConfig.componentName,
+        defaultPropsIn,
+        tamaguiConfig.defaultProps,
+        parentNames,
+        tamaguiConfig
+      );
+    }
+    const debug = defaultPropsIn["debug"];
+    const [ourProps, ourClassNames] = (0, import_mergeProps.mergeProps)(defaultPropsIn, {});
+    if (ourProps.tag) {
+      defaultTag = ourProps.tag;
+    }
+    const noClassNames = !staticConfig.acceptsClassName;
+    const { name, variants, defaultVariants, ...restProps } = ourProps;
+    const [defaults, defaultsClassnames] = (0, import_mergeProps.mergeProps)(component.defaultProps, {
+      ...defaultVariants,
+      ...restProps
+    });
+    if (!import_constants.isWeb) {
+      for (const key in staticConfig.defaultProps) {
+        const val = staticConfig.defaultProps[key];
+        if (import_helpers.validPseudoKeys[key])
+          continue;
+        defaults[key] = val;
+      }
+    }
+    tamaguiDefaultProps = defaults;
+    if (process.env.NODE_ENV === "development" && debug) {
+      if (process.env.IS_STATIC !== "is_static") {
+        console.log(`\u{1F41B} [${staticConfig.componentName || "Component"}]`, {
+          staticConfig,
+          tamaguiDefaultProps,
+          defaults,
+          defaultPropsIn,
+          defaultPropsKeyOrder: Object.keys(staticConfig.defaultProps),
+          defaultPropsInKeyOrder: Object.keys(defaultPropsIn).map((k) => [
+            k,
+            defaultPropsIn[k]
+          ]),
+          ourProps,
+          ourClassNames,
+          defaultsClassnames,
+          defaultTag,
+          noClassNames
+        });
+      }
+    }
+  });
+  let res = component;
+  if (configIn.memo) {
+    res = (0, import_react.memo)(res);
+  }
+  res.staticConfig = {
+    validStyles: staticConfig.validStyles || import_helpers.stylePropsView,
+    ...staticConfig
+  };
+  res.extractable = (Component, conf) => {
+    Component.staticConfig = (0, import_extendStaticConfig.extendStaticConfig)(
+      {
+        Component,
+        ...conf,
+        neverFlatten: true,
+        defaultProps: {
+          ...Component.defaultProps,
+          ...conf == null ? void 0 : conf.defaultProps
+        }
+      },
+      res
+    );
+    return Component;
+  };
+  return res;
+}
+const Unspaced = (props) => {
+  return props.children;
+};
+Unspaced["isUnspaced"] = true;
+const Spacer = createComponent({
+  acceptsClassName: true,
+  memo: true,
+  componentName: "Spacer",
+  validStyles: import_helpers.validStyles,
+  defaultProps: {
+    ...import_constants2.stackDefaultStyles,
+    // avoid nesting issues
+    tag: "span",
+    size: true,
+    pointerEvents: "none"
+  },
+  variants: {
+    size: {
+      "...size": (size, { tokens }) => {
+        size = size === true ? "$true" : size;
+        const sizePx = tokens.space[size] ?? size;
+        return {
+          width: sizePx,
+          height: sizePx,
+          minWidth: sizePx,
+          minHeight: sizePx
+        };
+      }
+    },
+    flex: {
+      true: {
+        flexGrow: 1
+      }
+    },
+    direction: {
+      horizontal: {
+        height: 0,
+        minHeight: 0
+      },
+      vertical: {
+        width: 0,
+        minWidth: 0
+      },
+      both: {}
+    }
+  }
+});
+function spacedChildren(props) {
+  var _a, _b, _c;
+  const { isZStack, children, space, direction, spaceFlex, separator } = props;
+  const hasSpace = !!(space || spaceFlex);
+  const hasSeparator = !(separator === void 0 || separator === null);
+  if (!(hasSpace || hasSeparator || isZStack)) {
+    return children;
+  }
+  const childrenList = import_react.Children.toArray(children);
+  const len = childrenList.length;
+  if (len <= 1 && !isZStack && !((_b = (_a = childrenList[0]) == null ? void 0 : _a["type"]) == null ? void 0 : _b["shouldForwardSpace"])) {
+    return childrenList;
+  }
+  const final = [];
+  for (let [index, child] of childrenList.entries()) {
+    const isEmpty = child === null || child === void 0 || Array.isArray(child) && child.length === 0;
+    if (!isEmpty && import_react.default.isValidElement(child) && ((_c = child.type) == null ? void 0 : _c["shouldForwardSpace"])) {
+      child = import_react.default.cloneElement(child, {
+        space,
+        spaceFlex,
+        separator,
+        key: child.key
+      });
+    }
+    if (isEmpty || !child || child["key"] && !isZStack) {
+      final.push(child);
+    } else {
+      final.push(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Fragment, { children: isZStack ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AbsoluteFill, { children: child }) : child }, index)
+      );
+    }
+    if (isUnspaced(child) && index === 0)
+      continue;
+    if (isZStack)
+      continue;
+    const next = childrenList[index + 1];
+    if (next && !isUnspaced(next)) {
+      if (separator) {
+        if (hasSpace) {
+          final.push(
+            createSpacer({
+              key: `_${index}_00tmgui`,
+              direction,
+              space,
+              spaceFlex
+            })
+          );
+        }
+        final.push(
+          import_react.default.isValidElement(separator) ? import_react.default.cloneElement(separator, { key: `sep_${index}` }) : separator
+        );
+        if (hasSpace) {
+          final.push(
+            createSpacer({
+              key: `_${index}01tmgui`,
+              direction,
+              space,
+              spaceFlex
+            })
+          );
+        }
+      } else {
+        final.push(
+          createSpacer({
+            key: `_${index}02tmgui`,
+            direction,
+            space,
+            spaceFlex
+          })
+        );
+      }
+    }
+  }
+  if (process.env.NODE_ENV === "development") {
+    if (props.debug) {
+      console.log(`  Spaced children`, final, props);
+    }
+  }
+  return final;
+}
+function createSpacer({ key, direction, space, spaceFlex }) {
+  return (
+    // @ts-ignore this one blew up but the types seem better
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      Spacer,
+      {
+        size: space,
+        direction,
+        ...typeof spaceFlex !== "undefined" && {
+          flex: spaceFlex === true ? 1 : spaceFlex === false ? 0 : spaceFlex
+        }
+      },
+      key
+    )
+  );
+}
+function isUnspaced(child) {
+  var _a, _b;
+  return ((_a = child == null ? void 0 : child["type"]) == null ? void 0 : _a["isVisuallyHidden"]) || ((_b = child == null ? void 0 : child["type"]) == null ? void 0 : _b["isUnspaced"]);
+}
+const DefaultProps = /* @__PURE__ */ new Map();
+function mergeConfigDefaultProps(name, props, configDefaults, parentNames, conf) {
+  const len = parentNames.length;
+  let prev;
+  for (let i = 0; i < len; i++) {
+    const n = parentNames[i];
+    if (!n)
+      continue;
+    if (DefaultProps.has(n)) {
+      prev = DefaultProps.get(n);
+      continue;
+    }
+    const props2 = configDefaults[n];
+    if (!props2) {
+      if (prev) {
+        DefaultProps.set(n, prev);
+      }
+      continue;
+    }
+    prev = (0, import_mergeProps.mergeProps)(prev || {}, props2, false, conf.inverseShorthands)[0];
+    DefaultProps.set(n, prev);
+  }
+  const ourDefaultsMerged = DefaultProps.get(name);
+  if (ourDefaultsMerged) {
+    return (0, import_mergeProps.mergeProps)(props, ourDefaultsMerged, false, conf.inverseShorthands)[0];
+  }
+  return props;
+}
+function usePlatformMethods(hostRef) {
+  (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    const node = hostRef.current;
+    if (!node)
+      return;
+    node.measure = (callback) => (0, import_useElementLayout.measureLayout)(node, null, callback);
+    node.measureLayout = (relativeToNode, success) => (0, import_useElementLayout.measureLayout)(node, relativeToNode, success);
+    node.measureInWindow = (callback) => {
+      if (!node)
+        return;
+      setTimeout(() => {
+        const { height, left, top, width } = (0, import_getRect.getRect)(node);
+        callback(left, top, width, height);
+      }, 0);
+    };
+  }, [hostRef]);
+}
+const AbsoluteFill = createComponent({
+  componentName: "AbsoluteFill",
+  defaultProps: {
+    ...import_constants2.stackDefaultStyles,
+    flexDirection: "column",
+    position: "absolute",
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    pointerEvents: "box-none"
+  }
+});
+const dontComposePressabilityKeys = {
+  onClick: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Spacer,
+  Unspaced,
+  createComponent,
+  defaultComponentState,
+  mouseUps,
+  spacedChildren
+});
+//# sourceMappingURL=createComponent.js.map