@tamagui/core 1.0.0-beta.187 → 1.0.0-beta.2

package/dist/jsx/helpers/addStylesUsingClassname.js

@@ -1,26 +1,24 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { useInsertionEffect } from "react";
+import { useInsertionEffect, useLayoutEffect } from "react";
 import { getStylesAtomic } from "./getStylesAtomic";
-import { insertStyleRule } from "./insertStyleRule";
+import { insertStyleRule, updateInsertedCache } from "./insertStyleRule";
 let added = /* @__PURE__ */ new Set();
+const effect = useInsertionEffect || useLayoutEffect;
 function useStylesAsClassname(styles, disable = false, debug = false) {
-  if (!useInsertionEffect) {
-    return addStylesUsingClassname(disable ? styles : [], debug);
-  } else {
-    const insertions = [];
-    const className = addStylesUsingClassname(disable ? [] : styles, debug, (identifier, rules) => {
-      for (const rule of rules) {
-        insertions.push({ identifier, rule });
-      }
-    });
-    useInsertionEffect(() => {
-      for (const { identifier, rule } of insertions) {
-        insertStyleRule(identifier, rule);
-      }
-    });
-    return className;
-  }
+  const insertions = [];
+  const className = addStylesUsingClassname(disable ? [] : styles, debug, (identifier, rules) => {
+    for (const rule of rules) {
+      insertions.push({ identifier, rule });
+      updateInsertedCache(identifier, rule);
+    }
+  });
+  effect(() => {
+    for (const { identifier, rule } of insertions) {
+      insertStyleRule(identifier, rule);
+    }
+  }, [className]);
+  return className;
 }
 __name(useStylesAsClassname, "useStylesAsClassname");
 function addStylesUsingClassname(styles, debug = false, onAdd) {

package/dist/jsx/helpers/createPropMapper.js

@@ -4,63 +4,67 @@ import { getConfig } from "../conf";
 import { isWeb } from "../constants/platform";
 import { isVariable } from "../createVariable";
 import { isObj } from "./isObj";
-const createPropMapper = /* @__PURE__ */ __name((c) => {
-  const variants = c.variants || {};
-  function getVariantFunction(variant, key, value) {
-    for (const cat in tokenCategories) {
-      if (key in tokenCategories[cat]) {
-        const spreadVariant = variant[`...${cat}`];
-        if (spreadVariant) {
-          return spreadVariant;
-        }
+function getVariantFunction(variant, key, value) {
+  if (typeof variant === "function") {
+    return variant;
+  }
+  for (const cat in tokenCategories) {
+    if (key in tokenCategories[cat]) {
+      const spreadVariant = variant[`...${cat}`];
+      if (spreadVariant) {
+        return spreadVariant;
       }
     }
-    let fn;
-    if (typeof value === "number") {
-      fn = variant[":number"];
-    } else if (typeof value === "string") {
-      fn = variant[":string"];
-    } else if (value === true || value === false) {
-      fn = variant[":boolean"];
-    }
-    fn = fn || variant[value];
-    return fn || variant["..."] || variant["...size"];
   }
-  __name(getVariantFunction, "getVariantFunction");
-  const defaultProps = c.defaultProps || {};
-  return (key, value, theme, props, staticConfig, returnVariablesAs = !!props.animation ? "value" : "auto", avoidDefaultProps = false) => {
+  let fn;
+  if (typeof value === "number") {
+    fn = variant[":number"];
+  } else if (typeof value === "string") {
+    fn = variant[":string"];
+  } else if (value === true || value === false) {
+    fn = variant[":boolean"];
+  }
+  fn = fn || variant[value];
+  return fn || variant["..."] || variant["...size"];
+}
+__name(getVariantFunction, "getVariantFunction");
+const createPropMapper = /* @__PURE__ */ __name((staticConfig) => {
+  const variants = staticConfig.variants || {};
+  const defaultProps = staticConfig.defaultProps || {};
+  return (key, value, theme, props, returnVariablesAs = !!props.animation ? "value" : "auto", avoidDefaultProps = false) => {
     const conf = getConfig();
     if (!conf) {
       console.trace("no conf! err");
       return;
     }
-    let fontFamily = props.fontFamily || defaultProps.fontFamily || "$body";
+    const fontFamily = props.fontFamily || defaultProps.fontFamily || "$body";
     const variant = variants && variants[key];
     if (variant && value !== void 0) {
       let variantValue = getVariantFunction(variant, key, value);
-      if (!variantValue) {
-        return value;
-      }
-      if (typeof variantValue === "function") {
-        variantValue = variantValue(value, {
-          tokens: conf.tokensParsed,
-          theme,
-          props: avoidDefaultProps ? props : new Proxy(props, {
-            get(target, key2) {
-              if (Reflect.has(target, key2)) {
-                return Reflect.get(target, key2);
+      if (variantValue) {
+        if (typeof variantValue === "function") {
+          const fn = variantValue;
+          variantValue = fn(value, {
+            fonts: conf.fontsParsed,
+            tokens: conf.tokensParsed,
+            theme,
+            props: avoidDefaultProps ? props : new Proxy(props, {
+              get(target, key2) {
+                if (Reflect.has(target, key2)) {
+                  return Reflect.get(target, key2);
+                }
+                if (defaultProps) {
+                  return Reflect.get(defaultProps, key2);
+                }
               }
-              if (staticConfig.defaultProps) {
-                return Reflect.get(staticConfig.defaultProps, key2);
-              }
-            }
-          })
-        });
-      }
-      if (isObj(variantValue)) {
-        variantValue = resolveTokens(variantValue, conf, theme, fontFamily, returnVariablesAs);
+            })
+          });
+        }
+        if (isObj(variantValue)) {
+          variantValue = resolveTokens(variantValue, conf, theme, fontFamily, returnVariablesAs);
+        }
+        return variantValue;
       }
-      return variantValue;
     }
     let shouldReturn = false;
     if (conf.shorthands[key]) {
@@ -108,34 +112,28 @@ const resolveTokens = /* @__PURE__ */ __name((input, conf, theme, fontFamily, re
   }
   return res;
 }, "resolveTokens");
-const getToken = /* @__PURE__ */ __name((key, value, { tokensParsed }, theme, fontFamily = "$body", resolveAs) => {
-  var _a, _b, _c, _d, _e;
+const fontShorthand = {
+  fontSize: "size",
+  fontWeight: "weight"
+};
+const getToken = /* @__PURE__ */ __name((key, value, { tokensParsed, fontsParsed }, theme, fontFamily = "$body", resolveAs) => {
+  var _a, _b, _c;
   let valOrVar;
   let hasSet = false;
-  const valueName = value[0] === "$" ? value.slice(1) : value;
-  if (valueName in theme) {
-    valOrVar = theme[valueName];
+  if (value in theme) {
+    valOrVar = theme[value];
     hasSet = true;
   } else {
     switch (key) {
       case "fontFamily":
-        valOrVar = ((_a = tokensParsed.font[value]) == null ? void 0 : _a.family) || value;
+        valOrVar = ((_a = fontsParsed[value]) == null ? void 0 : _a.family) || value;
         hasSet = true;
         break;
       case "fontSize":
-        valOrVar = ((_b = tokensParsed.font[fontFamily]) == null ? void 0 : _b.size[value]) || value;
-        hasSet = true;
-        break;
       case "lineHeight":
-        valOrVar = ((_c = tokensParsed.font[fontFamily]) == null ? void 0 : _c.lineHeight[value]) || value;
-        hasSet = true;
-        break;
       case "letterSpacing":
-        valOrVar = ((_d = tokensParsed.font[fontFamily]) == null ? void 0 : _d.letterSpacing[value]) || value;
-        hasSet = true;
-        break;
       case "fontWeight":
-        valOrVar = ((_e = tokensParsed.font[fontFamily]) == null ? void 0 : _e.weight[value]) || value;
+        valOrVar = ((_c = (_b = fontsParsed[fontFamily]) == null ? void 0 : _b[fontShorthand[key] || key]) == null ? void 0 : _c[value]) || value;
         hasSet = true;
         break;
     }
@@ -161,7 +159,7 @@ const getToken = /* @__PURE__ */ __name((key, value, { tokensParsed }, theme, fo
   }
   if (process.env.NODE_ENV === "development") {
     if (value && value[0] === "$") {
-      console.warn(`\u26A0\uFE0F Missing token in theme:`, value, theme);
+      console.warn(`\u26A0\uFE0F Missing token:`, key, value, fontFamily, theme, fontsParsed);
       return null;
     }
   }

package/dist/jsx/helpers/createShallowUpdate.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function createShallowUpdate(setter) {
+  return (next) => {
+    setter((prev) => {
+      for (const key in next) {
+        if (prev[key] !== next[key]) {
+          return { ...prev, ...next };
+        }
+      }
+      return prev;
+    });
+  };
+}
+__name(createShallowUpdate, "createShallowUpdate");
+export {
+  createShallowUpdate
+};

package/dist/jsx/helpers/createTamaguiProvider.js

@@ -10,7 +10,6 @@ function createTamaguiProvider({
 }) {
   return /* @__PURE__ */ __name(function TamaguiProvider({
     injectCSS,
-    fallback,
     children,
     ...themePropsProvider
   }) {
@@ -26,7 +25,7 @@ function createTamaguiProvider({
         };
       }, []);
     }
-    return <ButtonInsideButtonContext.Provider value={false}><TextAncestorProvider><ThemeProvider {...themeProps} {...themePropsProvider}><React.Suspense fallback={fallback || null}>{children}</React.Suspense></ThemeProvider></TextAncestorProvider></ButtonInsideButtonContext.Provider>;
+    return <ButtonInsideButtonContext.Provider value={false}><TextAncestorProvider><ThemeProvider {...themeProps} {...themePropsProvider}>{children}</ThemeProvider></TextAncestorProvider></ButtonInsideButtonContext.Provider>;
   }, "TamaguiProvider");
 }
 __name(createTamaguiProvider, "createTamaguiProvider");

package/dist/jsx/helpers/extendStaticConfig.js

@@ -2,12 +2,9 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { stylePropsView } from "@tamagui/helpers";
 import { createPropMapper } from "./createPropMapper";
-function extendStaticConfig(parent, config = {}) {
+function extendStaticConfig(config, parent) {
   var _a;
-  if (!parent) {
-    throw new Error("no parent");
-  }
-  if (!("staticConfig" in parent)) {
+  if (!parent || !("staticConfig" in parent)) {
     return parseStaticConfig(config);
   }
   const variants = {
@@ -38,9 +35,15 @@ function extendStaticConfig(parent, config = {}) {
       ...parent.staticConfig.validStyles,
       ...config.validStyles
     } : parent.staticConfig.validStyles || stylePropsView,
+    defaultVariants: {
+      ...parent.staticConfig.defaultVariants,
+      ...config.defaultVariants
+    },
     defaultProps: {
       ...parent.staticConfig.defaultProps,
-      ...config.defaultProps
+      ...parent.staticConfig.defaultVariants,
+      ...config.defaultProps,
+      ...config.defaultVariants
     }
   });
 }

package/dist/jsx/helpers/fixNativeShadow.native.js

@@ -18,8 +18,8 @@ function fixNativeShadow(props) {
   if ((c[0] === "r" || c[0] === "h") && c[3] === "a") {
     const [_, type, _1, _2, _3, a] = c.match(matchRgbaHsla) || [];
     if (typeof a !== "string") {
-      console.warn("invalid", c, type);
-      return;
+      console.trace("invalid", c, type);
+      throw new Error(`invalid style`);
     }
     props.shadowColor = `${type.replace("a", "")}(${_1},${_2},${_3})`;
     props.shadowOpacity = +a;

package/dist/jsx/helpers/getSize.js

@@ -0,0 +1,12 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { getTokens } from "../conf";
+const getSize = /* @__PURE__ */ __name((size, sizeUpOrDownBy = 0) => {
+  const sizes = getTokens().size;
+  const sizeNames = Object.keys(sizes);
+  const key = sizeNames[Math.max(0, sizeNames.indexOf(String(size || "$4")) + sizeUpOrDownBy)];
+  return sizes[key] || sizes["$4"];
+}, "getSize");
+export {
+  getSize
+};

package/dist/jsx/helpers/getSplitStyles.js

@@ -7,34 +7,31 @@ import {
   validPseudoKeys,
   validStyles
 } from "@tamagui/helpers";
-import { isWeb } from "../constants/platform";
+import { useInsertionEffect } from "react";
+import { getConfig } from "../conf";
+import { isClient, isWeb, useIsomorphicLayoutEffect } from "../constants/platform";
 import { mediaQueryConfig, mediaState } from "../hooks/useMedia";
 import { createMediaStyle } from "./createMediaStyle";
 import { fixNativeShadow } from "./fixNativeShadow";
 import { getStylesAtomic } from "./getStylesAtomic";
-import { insertStyleRule, insertedTransforms, updateInserted } from "./insertStyleRule";
-const skipKeys = {
+import {
+  insertStyleRule,
+  insertedTransforms,
+  updateInserted,
+  updateInsertedCache
+} from "./insertStyleRule";
+const skipProps = {
   animation: true,
-  animated: true,
-  children: true,
-  key: true,
-  ref: true
+  animateOnly: true,
+  debug: true
 };
-function normalizeStyleObject(style) {
-  var _a, _b;
-  if (typeof style.flex === "number") {
-    const val = style.flex;
-    delete style.flex;
-    style.flexGrow = (_a = style.flexGrow) != null ? _a : val;
-    style.flexShrink = (_b = style.flexShrink) != null ? _b : 1;
-  }
-  if (!isWeb) {
-    fixNativeShadow(style);
-  }
-}
-__name(normalizeStyleObject, "normalizeStyleObject");
+let conf;
 const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state, defaultClassNames) => {
-  var _a, _b, _c;
+  var _a;
+  if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+    console.log("  \xBB getSplitStyles", { props, state, defaultClassNames });
+  }
+  conf = conf || getConfig();
   const validStyleProps = staticConfig.isText ? stylePropsText : validStyles;
   const viewProps = {};
   const style = {};
@@ -43,23 +40,51 @@ const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state
   };
   const pseudos = {};
   const medias = {};
+  const rulesToInsert = [];
+  function addStyle(prop, rule) {
+    rulesToInsert.push([prop, rule]);
+    updateInsertedCache(prop, rule);
+  }
+  __name(addStyle, "addStyle");
   let cur = null;
   let transforms = {};
   function mergeClassName(key, val) {
-    if (!val)
+    if (!val) {
       return;
+    }
     if (val.startsWith("_transform-")) {
       const isMediaOrPseudo = key !== "transform";
       const isMedia = isMediaOrPseudo && key[11] === "_";
-      const isPsuedo = isMediaOrPseudo && !isMedia;
+      const isPsuedo = isMediaOrPseudo && key[11] === "0" || key.endsWith("Style");
       const namespace = isMedia ? key.split("_")[2] : isPsuedo ? key.split("-")[1] : "transform";
-      if (!insertedTransforms[val]) {
-        updateInserted();
+      let transform = insertedTransforms[val];
+      if (isClient) {
+        if (!transform) {
+          updateInserted();
+          transform = insertedTransforms[val];
+        }
+        if (!transform) {
+          if (isWeb && val[0] !== "_") {
+            transform = val;
+          } else {
+            console.trace("?", key, val, cur, props, state);
+          }
+        }
+        if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+          console.log("  \xBB getSplitStyles mergeClassName transform", { key, val, namespace, transform, insertedTransforms });
+        }
+        if (process.env.NODE_ENV === "development") {
+          if (!transform) {
+            console.trace("NO TRANSFORM?", { key, val, transform });
+          }
+        }
       }
-      const transform = insertedTransforms[val];
       transforms[namespace] = transforms[namespace] || ["", ""];
-      transforms[namespace][0] += val.replace("_transform", "");
-      transforms[namespace][1] += transform;
+      const identifier = val.replace("_transform", "");
+      transforms[namespace][0] += identifier;
+      if (transform) {
+        transforms[namespace][1] += transform;
+      }
     } else {
       classNames[key] = val;
     }
@@ -69,17 +94,21 @@ const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state
     if (!cur)
       return;
     normalizeStyleObject(cur);
+    if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+      console.log("  \xBB getSplitStyles push", cur, state);
+    }
     if (isWeb && !state.noClassNames) {
       const atomic = getStylesAtomic(cur);
       for (const atomicStyle of atomic) {
         if (!state.noClassNames) {
+          addStyle(atomicStyle.identifier, atomicStyle.rules[0]);
           mergeClassName(atomicStyle.property, atomicStyle.identifier);
-          insertStyleRule(atomicStyle.identifier, atomicStyle.rules[0]);
         } else {
           style[atomicStyle.property] = atomicStyle.value;
         }
       }
-    } else {
+    }
+    if (!isWeb || state.noClassNames || state.resolveVariablesAs === "value" || state.resolveVariablesAs === "both") {
       for (const key in cur) {
         if (key in stylePropsTransform) {
           mergeTransform(style, key, cur[key]);
@@ -92,30 +121,40 @@ const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state
   }
   __name(push, "push");
   for (const keyInit in props) {
+    if (skipProps[keyInit]) {
+      continue;
+    }
     const valInit = props[keyInit];
-    if (skipKeys[keyInit]) {
-      viewProps[keyInit] = valInit;
+    if (keyInit === "style" || keyInit.startsWith("_style")) {
+      push();
+      cur = valInit;
+      push();
       continue;
     }
     if (keyInit === "className" || validStyleProps[keyInit] && valInit && valInit[0] === "_") {
       push();
       mergeClassName(keyInit, valInit);
-      if (cur) {
-        if (cur[keyInit])
-          console.warn("just want to see how used");
-        delete cur[keyInit];
-      }
       continue;
     }
+    if (state.keepVariantsAsProps && staticConfig.defaultVariants && keyInit in staticConfig.defaultVariants) {
+      viewProps[keyInit] = valInit;
+    }
     let isMedia = keyInit[0] === "$";
     let isPseudo = validPseudoKeys[keyInit];
-    const out = isMedia || isPseudo ? true : staticConfig.propMapper(keyInit, valInit, theme, props, staticConfig, state.resolveVariablesAs);
+    if (!isMedia && !isPseudo && !((_a = staticConfig.variants) == null ? void 0 : _a[keyInit]) && !validStyleProps[keyInit] && !conf.shorthands[keyInit]) {
+      viewProps[keyInit] = valInit;
+      continue;
+    }
+    const out = isMedia || isPseudo ? true : staticConfig.propMapper(keyInit, valInit, theme, state.fallbackProps || props, state.resolveVariablesAs);
     const expanded = out === true || !out ? [[keyInit, valInit]] : Object.entries(out);
+    if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+      console.log("  \xBB getSplitStyles", keyInit, expanded);
+    }
     for (const [key, val] of expanded) {
       if (val === void 0) {
         continue;
       }
-      if (val && val[0] === "_") {
+      if (key !== "target" && val && val[0] === "_") {
         mergeClassName(key, val);
         continue;
       }
@@ -131,48 +170,46 @@ const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state
           continue;
         }
         pseudos[key] = pseudos[key] || {};
-        pseudos[key] = getSubStyle(val, staticConfig, theme, props, state.resolveVariablesAs, true);
+        pseudos[key] = getSubStyle(val, staticConfig, theme, props, state, true);
         if (isWeb && !state.noClassNames) {
           const pseudoStyles = getStylesAtomic({ [key]: pseudos[key] });
-          if ((_b = (_a = pseudoStyles[0]) == null ? void 0 : _a.identifier) == null ? void 0 : _b.includes("undefined")) {
-            console.warn("undefined bug?", (_c = pseudoStyles[0]) == null ? void 0 : _c.identifier);
-          }
           for (const style2 of pseudoStyles) {
+            addStyle(style2.identifier, style2.rules[0]);
             mergeClassName(`${style2.property}-${key}`, style2.identifier);
-            insertStyleRule(style2.identifier, style2.rules[0]);
           }
         }
         continue;
       }
       if (isMedia) {
-        const mediaKey = key.slice(1);
-        if (!mediaQueryConfig[mediaKey]) {
-          viewProps[key] = valInit;
+        const mediaKey = key;
+        const mediaKeyShort = mediaKey.slice(1);
+        if (!mediaQueryConfig[mediaKeyShort]) {
+          viewProps[key] = val;
           continue;
         }
-        const mediaStyle = getSubStyle(valInit, staticConfig, theme, props, state.resolveVariablesAs, true);
-        if (isWeb) {
+        const mediaStyle = getSubStyle(val, staticConfig, theme, props, state);
+        if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+          console.log("  \xBB getSplitStyles mediaStyle", mediaKey, mediaStyle, props);
+        }
+        const shouldDoClasses = isWeb && !state.noClassNames;
+        if (shouldDoClasses) {
           const mediaStyles = getStylesAtomic(mediaStyle);
           for (const style2 of mediaStyles) {
-            const out2 = createMediaStyle(style2, mediaKey, mediaQueryConfig);
+            const out2 = createMediaStyle(style2, mediaKeyShort, mediaQueryConfig);
+            addStyle(out2.identifier, out2.styleRule);
             mergeClassName(`${out2.identifier}-${mediaKey}`, out2.identifier);
-            insertStyleRule(out2.identifier, out2.styleRule);
-          }
-          if (mediaState[mediaKey]) {
-            Object.assign(medias, mediaStyle);
           }
         } else {
           if (mediaState[mediaKey]) {
-            Object.assign(style, mediaStyle);
+            push();
+            if (process.env.NODE_ENV === "development" && props["debug"]) {
+              console.log("apply media style", mediaKey, mediaState);
+            }
+            Object.assign(shouldDoClasses ? medias : style, mediaStyle);
           }
         }
         continue;
       }
-      if (key === "style" || key.startsWith("_style")) {
-        push();
-        Object.assign(style, val);
-        continue;
-      }
       if (!isWeb && key === "pointerEvents") {
         viewProps[key] = val;
         continue;
@@ -195,26 +232,49 @@ const getSplitStyles = /* @__PURE__ */ __name((props, staticConfig, theme, state
     for (const namespace in transforms) {
       const [hash, val] = transforms[namespace];
       const identifier = `_transform${hash}`;
-      if (!insertedTransforms[identifier]) {
-        const rule = `.${identifier} { transform: ${val}; }`;
-        insertStyleRule(identifier, rule);
+      if (isClient) {
+        if (!insertedTransforms[identifier]) {
+          const rule = `.${identifier} { transform: ${val}; }`;
+          addStyle(identifier, rule);
+        }
       }
       classNames[namespace] = identifier;
     }
   }
+  if (process.env.NODE_ENV === "development" && props["debug"] === "verbose") {
+    console.log("  \xBB getSplitStyles out", { style, pseudos, medias, classNames, viewProps, state });
+  }
   return {
     viewProps,
     style,
     medias,
     pseudos,
-    classNames
+    classNames,
+    rulesToInsert
   };
 }, "getSplitStyles");
-const getSubStyle = /* @__PURE__ */ __name((styleIn, staticConfig, theme, props, resolveVariablesAs, avoidDefaultProps) => {
+const insertSplitStyles = /* @__PURE__ */ __name((...args) => {
+  const res = getSplitStyles(...args);
+  for (const [prop, rule] of res.rulesToInsert) {
+    insertStyleRule(prop, rule);
+  }
+  return res;
+}, "insertSplitStyles");
+const effect = useInsertionEffect || useIsomorphicLayoutEffect;
+const useSplitStyles = /* @__PURE__ */ __name((...args) => {
+  const res = getSplitStyles(...args);
+  effect(() => {
+    for (const [prop, rule] of res.rulesToInsert) {
+      insertStyleRule(prop, rule);
+    }
+  });
+  return res;
+}, "useSplitStyles");
+const getSubStyle = /* @__PURE__ */ __name((styleIn, staticConfig, theme, props, state, avoidDefaultProps) => {
   const styleOut = {};
   for (const key in styleIn) {
     const val = styleIn[key];
-    const out = staticConfig.propMapper(key, val, theme, props, staticConfig, resolveVariablesAs, avoidDefaultProps);
+    const out = staticConfig.propMapper(key, val, theme, state.fallbackProps || props, state.resolveVariablesAs, avoidDefaultProps);
     const expanded = out === true || !out ? [[key, val]] : Object.entries(out);
     for (const [skey, sval] of expanded) {
       if (skey in stylePropsTransform) {
@@ -227,6 +287,31 @@ const getSubStyle = /* @__PURE__ */ __name((styleIn, staticConfig, theme, props,
   normalizeStyleObject(styleOut);
   return styleOut;
 }, "getSubStyle");
+function normalizeStyleObject(style) {
+  var _a, _b;
+  if (style.padding) {
+    const val = style.padding;
+    delete style.padding;
+    style.paddingLeft = val;
+    style.paddingTop = val;
+    style.paddingRight = val;
+    style.paddingBottom = val;
+  }
+  if (typeof style.flex === "number") {
+    const val = style.flex;
+    delete style.flex;
+    style.flexGrow = (_a = style.flexGrow) != null ? _a : val;
+    style.flexShrink = (_b = style.flexShrink) != null ? _b : 1;
+  }
+  if (!isWeb) {
+    fixNativeShadow(style);
+  }
+}
+__name(normalizeStyleObject, "normalizeStyleObject");
 export {
-  getSplitStyles
+  getSplitStyles,
+  getSubStyle,
+  insertSplitStyles,
+  normalizeStyleObject,
+  useSplitStyles
 };