@tamagui/static 1.0.0-alpha.8 → 1.0.0-beta.179

package/dist/{extractor → esm/extractor}/createExtractor.js

@@ -2,9 +2,14 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
-import * as CoreNode from "@tamagui/core-node";
-import { stylePropsTransform } from "@tamagui/helpers";
+import {
+  getSplitStyles,
+  mediaQueryConfig,
+  pseudos,
+  rnw
+} from "@tamagui/core-node";
 import { difference, pick } from "lodash";
+import { FAILED_EVAL } from "../constants";
 import { createEvaluator, createSafeEvaluator } from "./createEvaluator";
 import { evaluateAstNode } from "./evaluateAstNode";
 import { attrStr, findComponentName, isInsideTamagui, isPresent, objToStr } from "./extractHelpers";
@@ -12,10 +17,10 @@ import { findTopmostFunction } from "./findTopmostFunction";
 import { getStaticBindingsForScope } from "./getStaticBindingsForScope";
 import { literalToAst } from "./literalToAst";
 import { loadTamagui } from "./loadTamagui";
+import { logLines } from "./logLines";
 import { normalizeTernaries } from "./normalizeTernaries";
 import { removeUnusedHooks } from "./removeUnusedHooks";
-const { mediaQueryConfig, postProcessStyles, pseudos } = CoreNode;
-const FAILED_EVAL = Symbol("failed_style_eval");
+import { validHTMLAttributes } from "./validHTMLAttributes";
 const UNTOUCHED_PROPS = {
   key: true,
   style: true,
@@ -47,11 +52,18 @@ function createExtractor() {
       sourcePath = "",
       onExtractTag,
       getFlattenedNode,
+      disable,
       disableExtraction,
       disableExtractInlineMedia,
+      disableExtractVariables,
       disableDebugAttr,
+      prefixLogs,
+      excludeProps,
       ...props
     }) => {
+      if (disable) {
+        return null;
+      }
       if (sourcePath === "") {
         throw new Error(`Must provide a source file name`);
       }
@@ -65,8 +77,13 @@ function createExtractor() {
       loadedTamaguiConfig = tamaguiConfig;
       const defaultTheme = tamaguiConfig.themes[Object.keys(tamaguiConfig.themes)[0]];
       const body = fileOrPath.type === "Program" ? fileOrPath.get("body") : fileOrPath.program.body;
-      const isInternalImport = /* @__PURE__ */ __name((importStr) => isInsideTamagui(sourcePath) && importStr[0] === ".", "isInternalImport");
-      const validComponents = Object.keys(components).filter((key) => key[0].toUpperCase() === key[0] && !!components[key]?.staticConfig).reduce((obj, name) => {
+      const isInternalImport = /* @__PURE__ */ __name((importStr) => {
+        return isInsideTamagui(sourcePath) && importStr[0] === ".";
+      }, "isInternalImport");
+      const validComponents = Object.keys(components).filter((key) => {
+        var _a;
+        return key[0].toUpperCase() === key[0] && !!((_a = components[key]) == null ? void 0 : _a.staticConfig);
+      }).reduce((obj, name) => {
         obj[name] = components[name];
         return obj;
       }, {});
@@ -93,7 +110,7 @@ function createExtractor() {
         return null;
       }
       let couldntParse = false;
-      const modifiedComponents = new Set();
+      const modifiedComponents = /* @__PURE__ */ new Set();
       const bindingCache = {};
       const callTraverse = /* @__PURE__ */ __name((a) => {
         return fileOrPath.type === "File" ? traverse(fileOrPath, a) : fileOrPath.traverse(a);
@@ -102,7 +119,8 @@ function createExtractor() {
       const res = {
         flattened: 0,
         optimized: 0,
-        modified: 0
+        modified: 0,
+        found: 0
       };
       callTraverse({
         Program: {
@@ -111,11 +129,12 @@ function createExtractor() {
           }
         },
         JSXElement(traversePath) {
+          var _a, _b, _c, _d, _e;
           const node = traversePath.node.openingElement;
           const ogAttributes = node.attributes;
           const componentName = findComponentName(traversePath.scope);
           const closingElement = traversePath.node.closingElement;
-          if (t.isJSXMemberExpression(closingElement?.name) || !t.isJSXIdentifier(node.name)) {
+          if (t.isJSXMemberExpression(closingElement == null ? void 0 : closingElement.name) || !t.isJSXIdentifier(node.name)) {
             return;
           }
           const binding = traversePath.scope.getBinding(node.name.name);
@@ -136,6 +155,7 @@ function createExtractor() {
             return;
           }
           const originalNodeName = node.name.name;
+          res.found++;
           if (shouldPrintDebug) {
             console.log(`
 <${originalNodeName} />`);
@@ -143,21 +163,28 @@ function createExtractor() {
           const filePath = sourcePath.replace(process.cwd(), ".");
           const lineNumbers = node.loc ? node.loc.start.line + (node.loc.start.line !== node.loc.end.line ? `-${node.loc.end.line}` : "") : "";
           if (shouldAddDebugProp && !disableDebugAttr) {
-            const preName = componentName ? `${componentName}:` : "";
+            const preName = componentName ? `${componentName}.` : "";
             res.modified++;
-            node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier("data-is"), t.stringLiteral(`  ${preName}${node.name.name}   ${filePath.replace("./", "")}:${lineNumbers}  `)));
+            node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier("data-is"), t.stringLiteral(`${preName}${node.name.name}@${filePath.replace("./", "")}:${lineNumbers}`)));
+          }
+          const shouldLog = !hasLogged;
+          if (shouldLog) {
+            const prefix = "      |";
+            console.log(prefixLogs || prefix, "                          total \xB7 optimized \xB7 flattened ");
+            hasLogged = true;
           }
           if (disableExtraction) {
-            if (!hasLogged) {
-              console.log("\u{1F95A} Tamagui disableExtraction set: no CSS or optimizations will be run");
-              hasLogged = true;
-            }
             return;
           }
           const { staticConfig } = component;
           const isTextView = staticConfig.isText || false;
-          const validStyles = staticConfig?.validStyles ?? {};
-          let tagName = staticConfig.defaultProps?.tag ?? (isTextView ? "span" : "div");
+          const validStyles = (_a = staticConfig == null ? void 0 : staticConfig.validStyles) != null ? _a : {};
+          function isValidStyleKey(name) {
+            var _a2;
+            return !!(!!validStyles[name] || !!pseudos[name] || ((_a2 = staticConfig.variants) == null ? void 0 : _a2[name]) || tamaguiConfig.shorthands[name] || (name[0] === "$" ? !!mediaQueryConfig[name.slice(1)] : false));
+          }
+          __name(isValidStyleKey, "isValidStyleKey");
+          let tagName = (_c = (_b = staticConfig.defaultProps) == null ? void 0 : _b.tag) != null ? _c : isTextView ? "span" : "div";
           traversePath.get("openingElement").get("attributes").forEach((path) => {
             const attr = path.node;
             if (t.isJSXSpreadAttribute(attr))
@@ -170,23 +197,14 @@ function createExtractor() {
             tagName = val.value;
           });
           const flatNode = getFlattenedNode({ isTextView, tag: tagName });
-          const deoptProps = new Set([
-            ...props.deoptProps ?? [],
-            ...staticConfig.deoptProps ?? []
+          const inlineProps = /* @__PURE__ */ new Set([
+            ...props.inlineProps || [],
+            ...staticConfig.inlineProps || []
+          ]);
+          const deoptProps = /* @__PURE__ */ new Set([
+            ...props.deoptProps || [],
+            ...staticConfig.deoptProps || []
           ]);
-          const excludeProps = new Set(props.excludeProps ?? []);
-          const isExcludedProp = /* @__PURE__ */ __name((name) => {
-            const res2 = excludeProps.has(name);
-            if (res2 && shouldPrintDebug)
-              console.log(`  excluding ${name}`);
-            return res2;
-          }, "isExcludedProp");
-          const isDeoptedProp = /* @__PURE__ */ __name((name) => {
-            const res2 = deoptProps.has(name);
-            if (res2 && shouldPrintDebug)
-              console.log(`  deopting ${name}`);
-            return res2;
-          }, "isDeoptedProp");
           const staticNamespace = getStaticBindingsForScope(traversePath.scope, importsWhitelist, sourcePath, bindingCache, shouldPrintDebug);
           const attemptEval = !evaluateVars ? evaluateAstNode : createEvaluator({
             tamaguiConfig,
@@ -199,9 +217,6 @@ function createExtractor() {
           if (shouldPrintDebug) {
             console.log("  staticNamespace", Object.keys(staticNamespace).join(", "));
           }
-          const hasDeopt = /* @__PURE__ */ __name((obj) => {
-            return Object.keys(obj).some(isDeoptedProp);
-          }, "hasDeopt");
           const flattenedAttrs = [];
           traversePath.get("openingElement").get("attributes").forEach((path) => {
             const attr = path.node;
@@ -219,7 +234,7 @@ function createExtractor() {
               flattenedAttrs.push(attr);
               return;
             }
-            if (typeof arg !== "undefined") {
+            if (arg !== void 0) {
               try {
                 if (typeof arg !== "object" || arg == null) {
                   if (shouldPrintDebug) {
@@ -248,15 +263,25 @@ function createExtractor() {
           node.attributes = flattenedAttrs;
           if (staticConfig.defaultProps) {
             for (const key in staticConfig.defaultProps) {
+              if (isValidStyleKey(key)) {
+                continue;
+              }
               const serialize = require("babel-literal-to-ast");
               const val = staticConfig.defaultProps[key];
-              node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier(key), typeof val === "string" ? t.stringLiteral(val) : t.jsxExpressionContainer(serialize(val))));
+              try {
+                const serializedDefaultProp = serialize(val);
+                node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier(key), typeof val === "string" ? t.stringLiteral(val) : t.jsxExpressionContainer(serializedDefaultProp)));
+              } catch (err) {
+                console.warn(`\u26A0\uFE0F Error evaluating default prop for component ${node.name.name}, prop ${key}
+ error: ${err}
+ value:`, val, "\n defaultProps:", staticConfig.defaultProps);
+              }
             }
           }
           let attrs = [];
           let shouldDeopt = false;
           let inlinePropCount = 0;
-          let isFlattened = false;
+          let hasSetOptimized = false;
           attrs = traversePath.get("openingElement").get("attributes").flatMap((path) => {
             try {
               const res2 = evaluateAttribute(path);
@@ -265,83 +290,19 @@ function createExtractor() {
               }
               return res2;
             } catch (err) {
-              console.log("Error extracting attribute", err.message, err.stack);
-              console.log("node", path.node);
+              if (shouldPrintDebug) {
+                console.log("Error extracting attribute", err.message, err.stack);
+                console.log("node", path.node);
+              }
               return {
                 type: "attr",
                 value: path.node
               };
             }
           }).flat(4).filter(isPresent);
-          function isStaticAttributeName(name) {
-            return !!(!!validStyles[name] || staticConfig.validPropsExtra?.[name] || !!pseudos[name] || staticConfig.variants?.[name] || tamaguiConfig.shorthands[name] || (name[0] === "$" ? !!mediaQueryConfig[name.slice(1)] : false));
-          }
-          __name(isStaticAttributeName, "isStaticAttributeName");
-          function isExtractable(obj) {
-            return t.isObjectExpression(obj) && obj.properties.every((prop) => {
-              if (!t.isObjectProperty(prop)) {
-                console.log("not object prop", prop);
-                return false;
-              }
-              const propName = prop.key["name"];
-              if (!isStaticAttributeName(propName) && propName !== "tag") {
-                if (shouldPrintDebug) {
-                  console.log("  not a valid style prop!", propName);
-                }
-                return false;
-              }
-              return true;
-            });
-          }
-          __name(isExtractable, "isExtractable");
-          function createTernariesFromObjectProperties(test, side, ternaryPartial = {}) {
-            if (!side) {
-              return null;
-            }
-            if (!isExtractable(side)) {
-              throw new Error("not extractable");
-            }
-            return side.properties.flatMap((property) => {
-              if (!t.isObjectProperty(property)) {
-                throw new Error("expected object property");
-              }
-              if (t.isConditionalExpression(property.value)) {
-                const [truthy, falsy] = [
-                  t.objectExpression([t.objectProperty(property.key, property.value.consequent)]),
-                  t.objectExpression([t.objectProperty(property.key, property.value.alternate)])
-                ].map((x) => attemptEval(x));
-                return [
-                  createTernary({
-                    remove() {
-                    },
-                    ...ternaryPartial,
-                    test: t.logicalExpression("&&", test, property.value.test),
-                    consequent: truthy,
-                    alternate: null
-                  }),
-                  createTernary({
-                    ...ternaryPartial,
-                    test: t.logicalExpression("&&", test, t.unaryExpression("!", property.value.test)),
-                    consequent: falsy,
-                    alternate: null,
-                    remove() {
-                    }
-                  })
-                ];
-              }
-              const obj = t.objectExpression([t.objectProperty(property.key, property.value)]);
-              const consequent = attemptEval(obj);
-              return createTernary({
-                remove() {
-                },
-                ...ternaryPartial,
-                test,
-                consequent,
-                alternate: null
-              });
-            });
+          if (shouldPrintDebug) {
+            console.log("  - attrs (before):\n", logLines(attrs.map(attrStr).join(", ")));
           }
-          __name(createTernariesFromObjectProperties, "createTernariesFromObjectProperties");
           function evaluateAttribute(path) {
             const attribute = path.node;
             const attr = { type: "attr", value: attribute };
@@ -368,24 +329,41 @@ function createExtractor() {
               }
             }
             if (t.isJSXSpreadAttribute(attribute) || !attribute.name || typeof attribute.name.name !== "string") {
+              if (shouldPrintDebug) {
+                console.log("  ! inlining, spread attr");
+              }
               inlinePropCount++;
               return attr;
             }
             const name = attribute.name.name;
-            if (isExcludedProp(name)) {
+            if (excludeProps == null ? void 0 : excludeProps.has(name)) {
+              if (shouldPrintDebug) {
+                console.log("  excluding prop", name);
+              }
               return null;
             }
-            if (isDeoptedProp(name)) {
+            if (inlineProps.has(name)) {
+              inlinePropCount++;
               if (shouldPrintDebug) {
-                console.log("  ! inlining, deopt prop", name);
+                console.log("  ! inlining, inline prop", name);
               }
+              return attr;
+            }
+            if (deoptProps.has(name)) {
+              shouldDeopt = true;
               inlinePropCount++;
+              if (shouldPrintDebug) {
+                console.log("  ! inlining, deopted prop", name);
+              }
               return attr;
             }
             if (UNTOUCHED_PROPS[name]) {
               return attr;
             }
-            if (name[0] === "$" && t.isJSXExpressionContainer(attribute?.value)) {
+            if (name.startsWith("data-")) {
+              return attr;
+            }
+            if (name[0] === "$" && t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
               if (disableExtractInlineMedia) {
                 return attr;
               }
@@ -406,7 +384,7 @@ function createExtractor() {
               }
             }
             const [value, valuePath] = (() => {
-              if (t.isJSXExpressionContainer(attribute?.value)) {
+              if (t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
                 return [attribute.value.expression, path.get("value")];
               } else {
                 return [attribute.value, path.get("value")];
@@ -428,24 +406,65 @@ function createExtractor() {
                 value: path.node
               };
             }
+            if (disableExtractVariables) {
+              if (value) {
+                if (value.type === "StringLiteral" && value.value[0] === "$") {
+                  if (shouldPrintDebug) {
+                    console.log(`  ! inlining, native disable extract: ${name} =`, value.value);
+                  }
+                  inlinePropCount++;
+                  return attr;
+                }
+              }
+            }
             const styleValue = attemptEvalSafe(value);
-            if (!isStaticAttributeName(name)) {
+            if (!isValidStyleKey(name)) {
               let keys = [name];
+              let out = null;
               if (staticConfig.propMapper) {
-                const out = staticConfig.propMapper(name, styleValue, defaultTheme, staticConfig.defaultProps);
+                out = staticConfig.propMapper(name, styleValue, defaultTheme, staticConfig.defaultProps, staticConfig);
                 if (out) {
+                  out = rnw.createDOMProps(isTextView ? "span" : "div", out);
+                  delete out.className;
                   keys = Object.keys(out);
                 }
               }
-              if (keys.some((k) => !isStaticAttributeName(k) && k !== "tag")) {
-                if (shouldPrintDebug) {
-                  console.log("  ! inlining, not static attribute name", name);
+              const attributes = keys.map((key) => {
+                const val = out[key];
+                if (!isValidStyleKey(key)) {
+                  if (validHTMLAttributes[key]) {
+                    return {
+                      type: "attr",
+                      value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(literalToAst(val)))
+                    };
+                  }
+                  if (shouldPrintDebug) {
+                    console.log("  ! inlining, non-static", key);
+                  }
+                  inlinePropCount++;
                 }
-                inlinePropCount++;
+                return {
+                  type: "style",
+                  value: { [name]: styleValue },
+                  name,
+                  attr: path.node
+                };
+              });
+              if (inlinePropCount) {
                 return attr;
               }
+              return attributes;
             }
             if (styleValue !== FAILED_EVAL) {
+              if (shouldPrintDebug) {
+                console.log(`  style: ${name} =`, styleValue);
+              }
+              if (!(name in staticConfig.defaultProps)) {
+                if (!hasSetOptimized) {
+                  res.optimized++;
+                  hasSetOptimized = true;
+                }
+              }
               return {
                 type: "style",
                 value: { [name]: styleValue },
@@ -454,6 +473,9 @@ function createExtractor() {
               };
             }
             if (t.isBinaryExpression(value)) {
+              if (shouldPrintDebug) {
+                console.log(` binary expression ${name} = `, value);
+              }
               const { operator, left, right } = value;
               const lVal = attemptEvalSafe(left);
               const rVal = attemptEvalSafe(right);
@@ -478,16 +500,25 @@ function createExtractor() {
             }
             const staticConditional = getStaticConditional(value);
             if (staticConditional) {
+              if (shouldPrintDebug) {
+                console.log(` static conditional ${name} = `, value);
+              }
               return { type: "ternary", value: staticConditional };
             }
             const staticLogical = getStaticLogical(value);
             if (staticLogical) {
+              if (shouldPrintDebug) {
+                console.log(` static ternary ${name} = `, value);
+              }
               return { type: "ternary", value: staticLogical };
             }
             if (shouldPrintDebug) {
               console.log("  ! inline prop via no match", name, value.type);
             }
             inlinePropCount++;
+            if (shouldPrintDebug) {
+              console.log(` inlining ${name} = `, value);
+            }
             return attr;
             function addBinaryConditional(operator, staticExpr, cond) {
               if (getStaticConditional(cond)) {
@@ -562,13 +593,98 @@ function createExtractor() {
             __name(getStaticLogical, "getStaticLogical");
           }
           __name(evaluateAttribute, "evaluateAttribute");
-          if (shouldPrintDebug) {
-            console.log("  - attrs (before): ", attrs.map(attrStr).join(", "));
+          function isExtractable(obj) {
+            return t.isObjectExpression(obj) && obj.properties.every((prop) => {
+              if (!t.isObjectProperty(prop)) {
+                console.log("not object prop", prop);
+                return false;
+              }
+              const propName = prop.key["name"];
+              if (!isValidStyleKey(propName) && propName !== "tag") {
+                if (shouldPrintDebug) {
+                  console.log("  not a valid style prop!", propName);
+                }
+                return false;
+              }
+              return true;
+            });
+          }
+          __name(isExtractable, "isExtractable");
+          function createTernariesFromObjectProperties(test, side, ternaryPartial = {}) {
+            if (!side) {
+              return null;
+            }
+            if (!isExtractable(side)) {
+              throw new Error("not extractable");
+            }
+            return side.properties.flatMap((property) => {
+              if (!t.isObjectProperty(property)) {
+                throw new Error("expected object property");
+              }
+              if (t.isIdentifier(property.key)) {
+                const key = property.key.name;
+                const mediaQueryKey = key.slice(1);
+                const isMediaQuery = key[0] === "$" && mediaQueryConfig[mediaQueryKey];
+                if (isMediaQuery) {
+                  if (t.isExpression(property.value)) {
+                    const ternaries2 = createTernariesFromObjectProperties(t.stringLiteral(mediaQueryKey), property.value, {
+                      inlineMediaQuery: mediaQueryKey
+                    });
+                    if (ternaries2) {
+                      return ternaries2.map((value) => ({
+                        ...ternaryPartial,
+                        ...value,
+                        test: t.logicalExpression("&&", value.test, test)
+                      }));
+                    } else {
+                      console.log("\u26A0\uFE0F no ternaries?", property);
+                    }
+                  } else {
+                    console.log("\u26A0\uFE0F not expression", property);
+                  }
+                }
+              }
+              if (t.isConditionalExpression(property.value)) {
+                const [truthy, falsy] = [
+                  t.objectExpression([t.objectProperty(property.key, property.value.consequent)]),
+                  t.objectExpression([t.objectProperty(property.key, property.value.alternate)])
+                ].map((x) => attemptEval(x));
+                return [
+                  createTernary({
+                    remove() {
+                    },
+                    ...ternaryPartial,
+                    test: t.logicalExpression("&&", test, property.value.test),
+                    consequent: truthy,
+                    alternate: null
+                  }),
+                  createTernary({
+                    ...ternaryPartial,
+                    test: t.logicalExpression("&&", test, t.unaryExpression("!", property.value.test)),
+                    consequent: falsy,
+                    alternate: null,
+                    remove() {
+                    }
+                  })
+                ];
+              }
+              const obj = t.objectExpression([t.objectProperty(property.key, property.value)]);
+              const consequent = attemptEval(obj);
+              return createTernary({
+                remove() {
+                },
+                ...ternaryPartial,
+                test,
+                consequent,
+                alternate: null
+              });
+            });
           }
+          __name(createTernariesFromObjectProperties, "createTernariesFromObjectProperties");
           node.attributes = attrs.filter(isAttr).map((x) => x.value);
-          if (couldntParse) {
+          if (couldntParse || shouldDeopt) {
             if (shouldPrintDebug) {
-              console.log(`  cancel:`, { couldntParse, shouldDeopt });
+              console.log(`  avoid optimizing:`, { couldntParse, shouldDeopt });
             }
             node.attributes = ogAttributes;
             return;
@@ -635,101 +751,187 @@ function createExtractor() {
           const hasSpread = node.attributes.some((x) => t.isJSXSpreadAttribute(x));
           const hasOnlyStringChildren = !hasSpread && (node.selfClosing || traversePath.node.children && traversePath.node.children.every((x) => x.type === "JSXText"));
           const shouldFlatten = !shouldDeopt && inlinePropCount === 0 && !hasSpread && staticConfig.neverFlatten !== true && (staticConfig.neverFlatten === "jsx" ? hasOnlyStringChildren : true);
+          if (shouldFlatten && staticConfig.defaultProps) {
+            const defaultStyleAttrs = Object.keys(staticConfig.defaultProps).flatMap((key) => {
+              if (!isValidStyleKey(key)) {
+                return;
+              }
+              try {
+                const serialize = require("babel-literal-to-ast");
+                const val = staticConfig.defaultProps[key];
+                const value = serialize(val);
+                const name = tamaguiConfig.shorthands[key] || key;
+                return {
+                  type: "style",
+                  name,
+                  value
+                };
+              } catch (err) {
+                console.warn(`\u26A0\uFE0F Error evaluating default style for component, prop ${key}
+ error: ${err}`);
+                shouldDeopt = true;
+              }
+            });
+            if (defaultStyleAttrs.length) {
+              attrs = [...defaultStyleAttrs, ...attrs];
+            }
+          }
+          if (shouldDeopt) {
+            node.attributes = ogAttributes;
+            return;
+          }
+          const ensureOverridden = {};
           if (!shouldFlatten) {
-            attrs = attrs.reduce((acc, cur) => {
+            for (const cur of attrs) {
               if (cur.type === "style") {
                 for (const key in cur.value) {
-                  const shouldEnsureOverridden = !!staticConfig.ensureOverriddenProp?.[key];
+                  const shouldEnsureOverridden = !!((_d = staticConfig.ensureOverriddenProp) == null ? void 0 : _d[key]);
                   const isSetInAttrsAlready = attrs.some((x) => x.type === "attr" && x.value.type === "JSXAttribute" && x.value.name.name === key);
                   if (!isSetInAttrsAlready) {
-                    const isVariant = !!staticConfig.variants?.[cur.name || ""];
+                    const isVariant = !!((_e = staticConfig.variants) == null ? void 0 : _e[cur.name || ""]);
                     if (isVariant || shouldEnsureOverridden) {
-                      acc.push({
-                        type: "attr",
-                        value: cur.attr || t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.nullLiteral()))
-                      });
+                      ensureOverridden[key] = true;
                     }
                   }
                 }
               }
-              acc.push(cur);
-              return acc;
-            }, []);
+            }
           }
           if (shouldPrintDebug) {
-            console.log("  - attrs (flattened):  ", attrs.map(attrStr).join(", "));
+            console.log("  - attrs (flattened): \n", logLines(attrs.map(attrStr).join(", ")));
+            console.log("  - ensureOverriden:", Object.keys(ensureOverridden).join(", "));
           }
           attrs = attrs.reduce((acc, cur) => {
-            if (cur.type !== "attr" || !t.isJSXAttribute(cur.value) || typeof cur.value.name.name !== "string") {
-              if (cur.type === "style") {
-                const key = Object.keys(cur.value)[0];
-                if (!validStyles[key] && !pseudos[key]) {
-                  if (shouldPrintDebug) {
-                    console.log(" \u274C excluding", key);
-                  }
-                  return acc;
+            if (!cur) {
+              return acc;
+            }
+            if (shouldFlatten && cur.type === "attr" && !t.isJSXSpreadAttribute(cur.value) && cur.value.name.name === "tag") {
+              return acc;
+            }
+            if (cur.type !== "style") {
+              acc.push(cur);
+              return acc;
+            }
+            let key = Object.keys(cur.value)[0];
+            const value = cur.value[key];
+            const fullKey = tamaguiConfig.shorthands[key];
+            if (fullKey) {
+              cur.value = { [fullKey]: value };
+              key = fullKey;
+            }
+            if (disableExtractVariables) {
+              if (value[0] === "$") {
+                if (shouldPrintDebug) {
+                  console.log(`   keeping variable inline: ${key} =`, value);
                 }
+                acc.push({
+                  type: "attr",
+                  value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.stringLiteral(value)))
+                });
+                return acc;
               }
             }
             acc.push(cur);
             return acc;
           }, []);
           if (shouldPrintDebug) {
-            console.log("  - attrs (evaluated styles):  ", attrs.map(attrStr).join(", "));
+            console.log("  - attrs (expanded): \n", logLines(attrs.map(attrStr).join(", ")));
           }
           let prev = null;
+          function mergeStyles(prev2, next) {
+            for (const key in next) {
+              if (pseudos[key]) {
+                prev2[key] = prev2[key] || {};
+                Object.assign(prev2[key], next[key]);
+              } else {
+                prev2[key] = next[key];
+              }
+            }
+          }
+          __name(mergeStyles, "mergeStyles");
           attrs = attrs.reduce((acc, cur) => {
             if (cur.type === "style") {
-              if (prev?.type === "style") {
-                Object.assign(prev.value, cur.value);
+              const key = Object.keys(cur.value)[0];
+              const value = cur.value[key];
+              const shouldKeepOriginalAttr = !shouldFlatten && !validStyles[key] && !pseudos[key] && !key.startsWith("data-");
+              if (shouldKeepOriginalAttr) {
+                if (shouldPrintDebug) {
+                  console.log("     - keeping as non-style", key);
+                }
+                prev = cur;
+                acc.push({
+                  type: "attr",
+                  value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(typeof value === "string" ? t.stringLiteral(value) : literalToAst(value)))
+                });
+                acc.push(cur);
+                return acc;
+              }
+              if (ensureOverridden[key]) {
+                acc.push({
+                  type: "attr",
+                  value: cur.attr || t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.nullLiteral()))
+                });
+              }
+              if ((prev == null ? void 0 : prev.type) === "style") {
+                mergeStyles(prev.value, cur.value);
                 return acc;
               }
             }
-            acc.push(cur);
             prev = cur;
+            acc.push(cur);
             return acc;
           }, []);
           if (shouldPrintDebug) {
-            console.log("  - attrs (combined \u{1F500}):  ", attrs.map(attrStr).join(", "));
+            console.log("  - attrs (combined \u{1F500}): \n", logLines(attrs.map(attrStr).join(", ")));
           }
-          const getStyles = /* @__PURE__ */ __name((props2) => {
+          const getStyles = /* @__PURE__ */ __name((props2, debugName = "") => {
             if (!props2)
               return;
-            if (!!excludeProps.size) {
+            if (!Object.keys(props2).length)
+              return;
+            if (excludeProps && !!excludeProps.size) {
               for (const key in props2) {
-                if (isExcludedProp(key))
+                if (excludeProps.has(key)) {
                   delete props2[key];
+                }
               }
             }
-            const out = postProcessStyles(props2, staticConfig, defaultTheme);
-            const next = out?.style ?? props2;
-            if (shouldPrintDebug) {
-              console.log("    >> getStyles: ", objToStr(props2), "==>>", objToStr(next));
-              console.log("    >>     style: ", objToStr(out.style));
-              console.log("    >>     viewp: ", objToStr(out.viewProps));
+            const out = getSplitStyles(props2, staticConfig, defaultTheme, {
+              noClassNames: true
+            });
+            const outStyle = {
+              ...out.style,
+              ...out.pseudos
+            };
+            if (shouldPrintDebug === "verbose") {
+              console.log(`       getStyles ${debugName} (props):
+`, logLines(objToStr(props2)));
+              console.log(`       getStyles ${debugName} (out.viewProps):
+`, logLines(objToStr(out.viewProps)));
+              console.log(`       getStyles ${debugName} (out.style):
+`, logLines(objToStr(outStyle || {}), true));
             }
-            if (staticConfig.validStyles) {
-              for (const key in next) {
+            for (const key in outStyle) {
+              if (staticConfig.validStyles) {
                 if (!staticConfig.validStyles[key] && !pseudos[key]) {
-                  delete next[key];
+                  delete outStyle[key];
                 }
               }
             }
-            return next;
+            return outStyle;
           }, "getStyles");
-          if (shouldPrintDebug) {
-            console.log("  staticConfig.defaultProps", staticConfig.defaultProps);
-          }
           const completeStylesProcessed = getStyles({
             ...staticConfig.defaultProps,
             ...completeStaticProps
-          });
-          const stylesToAddToInitialGroup = difference(Object.keys(completeStylesProcessed), Object.keys(completeStaticProps));
+          }, "completeStylesProcessed");
+          if (!completeStylesProcessed) {
+            throw new Error(`Impossible, no styles`);
+          }
+          const stylesToAddToInitialGroup = shouldFlatten ? difference(Object.keys(completeStylesProcessed), Object.keys(completeStaticProps)) : [];
           if (stylesToAddToInitialGroup.length) {
             const toAdd = pick(completeStylesProcessed, ...stylesToAddToInitialGroup);
             const firstGroup = attrs.find((x) => x.type === "style");
             if (shouldPrintDebug) {
-              console.log("    stylesToAddToInitialGroup", stylesToAddToInitialGroup.join(", "));
               console.log("    toAdd", objToStr(toAdd));
             }
             if (!firstGroup) {
@@ -739,49 +941,64 @@ function createExtractor() {
             }
           }
           if (shouldPrintDebug) {
-            console.log("    completeStaticProps", objToStr(completeStaticProps));
-            console.log("    completeStylesProcessed", objToStr(completeStylesProcessed));
+            console.log("   -- stylesToAddToInitialGroup", stylesToAddToInitialGroup.join(", "), { shouldFlatten });
+            console.log("   -- completeStaticProps:\n", logLines(objToStr(completeStaticProps)));
+            console.log("   -- completeStylesProcessed:\n", logLines(objToStr(completeStylesProcessed)));
           }
+          let getStyleError = null;
           for (const attr of attrs) {
             try {
+              if (shouldPrintDebug)
+                console.log("  *", attrStr(attr));
               switch (attr.type) {
                 case "ternary":
-                  const a = getStyles(attr.value.alternate);
-                  const c = getStyles(attr.value.consequent);
-                  attr.value.alternate = a;
-                  attr.value.consequent = c;
-                  if (shouldPrintDebug) {
+                  const a = getStyles(attr.value.alternate, "ternary.alternate");
+                  const c = getStyles(attr.value.consequent, "ternary.consequent");
+                  if (a)
+                    attr.value.alternate = a;
+                  if (c)
+                    attr.value.consequent = c;
+                  if (shouldPrintDebug)
                     console.log("     => tern ", attrStr(attr));
-                  }
-                  break;
+                  continue;
                 case "style":
-                  const next = {};
-                  for (const key in attr.value) {
-                    if (key in stylePropsTransform) {
-                      next["transform"] = completeStylesProcessed["transform"];
-                    } else {
-                      next[key] = completeStylesProcessed[key] ?? attr.value[key];
-                    }
+                  const styles = getStyles(attr.value, "style");
+                  if (styles) {
+                    attr.value = Object.fromEntries(Object.keys(styles).map((k) => [k, completeStylesProcessed[k]]));
+                  } else {
+                    console.warn("?????????");
                   }
-                  attr.value = next;
-                  break;
+                  continue;
               }
             } catch (err) {
-              if (shouldPrintDebug) {
-                console.log(" postprocessing error, deopt", err);
-                node.attributes = ogAttributes;
-                return node;
+              getStyleError = err;
+            }
+          }
+          if (getStyleError) {
+            console.log(" \u26A0\uFE0F postprocessing error, deopt", getStyleError);
+            node.attributes = ogAttributes;
+            return node;
+          }
+          const existingStyleKeys = /* @__PURE__ */ new Set();
+          for (let i = attrs.length - 1; i >= 0; i--) {
+            const attr = attrs[i];
+            if (attr.type === "style") {
+              for (const key in attr.value) {
+                if (existingStyleKeys.has(key)) {
+                  delete attr.value[key];
+                } else {
+                  existingStyleKeys.add(key);
+                }
               }
             }
           }
           if (shouldPrintDebug) {
-            console.log("  - attrs (after): ", attrs.map(attrStr).join(", "));
+            console.log("  - attrs (after):\n", logLines(attrs.map(attrStr).join(", ")));
           }
           if (shouldFlatten) {
             if (shouldPrintDebug) {
               console.log("  [\u2705] flattening", originalNodeName, flatNode);
             }
-            isFlattened = true;
             node.name.name = flatNode;
             res.flattened++;
             if (closingElement) {
@@ -789,10 +1006,9 @@ function createExtractor() {
             }
           }
           if (shouldPrintDebug) {
-            console.log("  [\u274A] inline props ", inlinePropCount, shouldDeopt ? " deopted" : "", hasSpread ? " spread" : "", "!flatten", staticConfig.neverFlatten);
-            console.log("  - attrs (end): ", attrs.map(attrStr).join(", "));
+            console.log(` \u274A\u274A inline props (${inlinePropCount}):`, shouldDeopt ? " deopted" : "", hasSpread ? " has spread" : "", staticConfig.neverFlatten ? "neverFlatten" : "");
+            console.log("  - attrs (end):\n", logLines(attrs.map(attrStr).join(", ")));
           }
-          res.optimized++;
           onExtractTag({
             attrs,
             node,
@@ -801,7 +1017,7 @@ function createExtractor() {
             attemptEval,
             jsxPath: traversePath,
             originalNodeName,
-            isFlattened,
+            isFlattened: shouldFlatten,
             programPath
           });
         }
@@ -821,7 +1037,6 @@ function createExtractor() {
 }
 __name(createExtractor, "createExtractor");
 export {
-  FAILED_EVAL,
   createExtractor
 };
 //# sourceMappingURL=createExtractor.js.map