@tamagui/static 1.88.13 → 1.89.0-1706308641099

package/dist/esm/extractor/ensureImportingConcat.mjs

@@ -0,0 +1,13 @@
+import * as t from "@babel/types";
+const importConcatPkg = "@tamagui/helpers";
+function ensureImportingConcat(path) {
+  const imported = path.get("body").find(x => x.isImportDeclaration() && x.node.source.value === importConcatPkg),
+    importSpecifier = t.importSpecifier(t.identifier("concatClassName"), t.identifier("concatClassName"));
+  if (!imported) {
+    path.node.body.push(t.importDeclaration([importSpecifier], t.stringLiteral(importConcatPkg)));
+    return;
+  }
+  const specifiers = imported.node.specifiers;
+  specifiers.some(x => t.isImportSpecifier(x) && t.isIdentifier(x.imported) && x.imported.name === "concatClassName") || specifiers.push(t.importSpecifier(t.identifier("concatClassName"), t.identifier("concatClassName")));
+}
+export { ensureImportingConcat };

package/dist/esm/extractor/esbuildAliasPlugin.mjs

@@ -0,0 +1,20 @@
+const esbuildAliasPlugin = config => {
+  const alias = config && Object.keys(config);
+  return {
+    name: "path-alias",
+    setup(build) {
+      if (!alias || !alias.length) return;
+      const main = (k, args) => ({
+        path: config[k].replace(/\/$/, "")
+      });
+      alias.forEach(k => {
+        build.onResolve({
+          filter: new RegExp(`^.*${k}$`)
+        }, args => main(k, args)), build.onResolve({
+          filter: new RegExp(`^.*\\/${k}\\/.*$`)
+        }, args => main(k, args));
+      });
+    }
+  };
+};
+export { esbuildAliasPlugin };

package/dist/esm/extractor/evaluateAstNode.mjs

@@ -0,0 +1,48 @@
+import * as t from "@babel/types";
+function evaluateAstNode(exprNode, evalFn, shouldPrintDebug) {
+  if (exprNode !== void 0) {
+    if (exprNode === null) return !0;
+    if (t.isJSXExpressionContainer(exprNode)) return evaluateAstNode(exprNode.expression);
+    if (t.isObjectExpression(exprNode)) {
+      const ret = {};
+      for (let idx = -1, len = exprNode.properties.length; ++idx < len;) {
+        const value = exprNode.properties[idx];
+        if (!t.isObjectProperty(value)) throw new Error("evaluateAstNode can only evaluate object properties");
+        let key;
+        if (value.computed) {
+          if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support computed keys unless an eval function is provided");
+          key = evaluateAstNode(value.key, evalFn);
+        } else if (t.isIdentifier(value.key)) key = value.key.name;else if (t.isStringLiteral(value.key) || t.isNumericLiteral(value.key)) key = value.key.value;else throw new Error("Unsupported key type: " + value.key.type);
+        if (typeof key != "string" && typeof key != "number") throw new Error("key must be either a string or a number");
+        ret[key] = evaluateAstNode(value.value, evalFn);
+      }
+      return ret;
+    }
+    if (t.isArrayExpression(exprNode)) return exprNode.elements.map(x => evaluateAstNode(x, evalFn));
+    if (t.isUnaryExpression(exprNode) && exprNode.operator === "-") {
+      const ret = evaluateAstNode(exprNode.argument, evalFn);
+      return ret == null ? null : -ret;
+    }
+    if (t.isTemplateLiteral(exprNode)) {
+      if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support template literals unless an eval function is provided");
+      let ret = "";
+      for (let idx = -1, len = exprNode.quasis.length; ++idx < len;) {
+        const quasi = exprNode.quasis[idx],
+          expr = exprNode.expressions[idx];
+        ret += quasi.value.raw, expr && (ret += evaluateAstNode(expr, evalFn));
+      }
+      return ret;
+    }
+    if (t.isNullLiteral(exprNode)) return null;
+    if (t.isNumericLiteral(exprNode) || t.isStringLiteral(exprNode) || t.isBooleanLiteral(exprNode)) return exprNode.value;
+    if (t.isBinaryExpression(exprNode)) {
+      if (exprNode.operator === "+") return evaluateAstNode(exprNode.left, evalFn) + evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "-") return evaluateAstNode(exprNode.left, evalFn) - evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "*") return evaluateAstNode(exprNode.left, evalFn) * evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "/") return evaluateAstNode(exprNode.left, evalFn) / evaluateAstNode(exprNode.right, evalFn);
+    }
+    if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support non-literal values unless an eval function is provided");
+    return evalFn(exprNode);
+  }
+}
+export { evaluateAstNode };

package/dist/esm/extractor/extractHelpers.mjs

@@ -0,0 +1,72 @@
+import { basename } from "path";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import findRoot from "find-root";
+import { memoize } from "../helpers/memoize.mjs";
+function isPresent(input) {
+  return input != null;
+}
+function isSimpleSpread(node) {
+  return t.isIdentifier(node.argument) || t.isMemberExpression(node.argument);
+}
+const attrStr = attr => attr ? attr.type === "attr" ? getNameAttr(attr.value) : attr.type === "ternary" ? `...${ternaryStr(attr.value)}` : `${attr.type}(${objToStr(attr.value)})` : "",
+  objToStr = (obj, spacer = ", ") => obj ? `{${Object.entries(obj).map(([k, v]) => `${k}:${Array.isArray(v) ? "[...]" : v && typeof v == "object" ? `${objToStr(v, ",")}` : JSON.stringify(v)}`).join(spacer)}}` : `${obj}`,
+  getNameAttr = attr => t.isJSXSpreadAttribute(attr) ? `...${attr.argument.name}` : "name" in attr ? attr.name.name : `unknown-${attr.type}`,
+  ternaryStr = x => ["ternary(", t.isIdentifier(x.test) ? x.test.name : t.isMemberExpression(x.test) ? [x.test.object.name, x.test.property.name] :
+  // @ts-ignore
+  generate(x.test).code, isFilledObj(x.consequent) ? ` ? ${objToStr(x.consequent)}` : " ? \u{1F6AB}", isFilledObj(x.alternate) ? ` : ${objToStr(x.alternate)}` : " : \u{1F6AB}", ")"].flat().join(""),
+  isFilledObj = obj => obj && Object.keys(obj).length;
+function findComponentName(scope) {
+  const componentName = "";
+  let cur = scope.path;
+  for (; cur.parentPath && !t.isProgram(cur.parentPath.parent);) cur = cur.parentPath;
+  let node = cur.parent;
+  if (t.isExportNamedDeclaration(node) && (node = node.declaration), t.isVariableDeclaration(node)) {
+    const [dec] = node.declarations;
+    if (t.isVariableDeclarator(dec) && t.isIdentifier(dec.id)) return dec.id.name;
+  }
+  return t.isFunctionDeclaration(node) ? node.id?.name : componentName;
+}
+function isValidThemeHook(props, jsxPath, n, sourcePath) {
+  if (!t.isIdentifier(n.object) || !t.isIdentifier(n.property)) return !1;
+  const binding = jsxPath.scope.getAllBindings()[n.object.name];
+  if (!binding?.path || !binding.path.isVariableDeclarator()) return !1;
+  const init = binding.path.node.init;
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useTheme") return !1;
+  const importNode = binding.scope.getBinding("useTheme")?.path.parent;
+  return !(!t.isImportDeclaration(importNode) || sourcePath && !isValidImport(props, sourcePath));
+}
+const isInsideComponentPackage = (props, moduleName) => getValidComponentsPaths(props).some(path => moduleName.startsWith(path)),
+  isComponentPackage = (props, srcName) => getValidComponentsPaths(props).some(path => srcName.startsWith(path));
+function getValidComponent(props, moduleName, componentName) {
+  if (componentName[0].toUpperCase() !== componentName[0]) return !1;
+  for (const loaded of props.allLoadedComponents) {
+    if (!loaded) continue;
+    const isInModule = moduleName === "*" || moduleName.startsWith(loaded.moduleName),
+      foundComponent = loaded.nameToInfo[componentName];
+    if (isInModule && foundComponent) return foundComponent;
+  }
+  return null;
+}
+const isValidModule = (props, moduleName) => {
+    if (typeof moduleName != "string") throw new Error("No module name");
+    const isLocal = moduleName.startsWith(".");
+    return {
+      isLocal,
+      isValid: isLocal ? isInsideComponentPackage(props, moduleName) : isComponentPackage(props, moduleName)
+    };
+  },
+  getValidImport = (props, moduleName, componentName) => {
+    const {
+      isValid,
+      isLocal
+    } = isValidModule(props, moduleName);
+    return !isValid || !componentName ? null : getValidComponent(props, isLocal ? "*" : moduleName, componentName) || null;
+  },
+  isValidImport = (props, moduleName, componentName) => componentName ? !!getValidImport(props, moduleName, componentName) : isValidModule(props, moduleName).isValid,
+  getValidComponentPackages = memoize(props => [... /* @__PURE__ */new Set(["@tamagui/core", "tamagui", ...props.components])]),
+  getValidComponentsPaths = memoize(props => getValidComponentPackages(props).flatMap(pkg => {
+    const root = findRoot(pkg);
+    return [basename(root), pkg].filter(Boolean);
+  }));
+export { attrStr, findComponentName, getValidComponent, getValidComponentsPaths, getValidImport, isComponentPackage, isInsideComponentPackage, isPresent, isSimpleSpread, isValidImport, isValidModule, isValidThemeHook, objToStr, ternaryStr };

package/dist/esm/extractor/extractMediaStyle.mjs

@@ -0,0 +1,93 @@
+import * as t from "@babel/types";
+import { createMediaStyle } from "@tamagui/core";
+import { requireTamaguiCore } from "../helpers/requireTamaguiCore.mjs";
+import { isPresent, isValidImport } from "./extractHelpers.mjs";
+function extractMediaStyle(props, ternary, jsxPath, tamaguiConfig, sourcePath, importance = 0, shouldPrintDebug = !1) {
+  const {
+      getStylesAtomic,
+      mediaObjectToString
+    } = requireTamaguiCore("web"),
+    mt = getMediaQueryTernary(props, ternary, jsxPath, sourcePath);
+  if (!mt) return null;
+  const {
+    key
+  } = mt;
+  if (!tamaguiConfig.media[key]) return console.error(`Media query "${key}" not found: ${Object.keys(tamaguiConfig.media)}`), null;
+  const getStyleObj = (styleObj, negate = !1) => styleObj ? {
+      styleObj,
+      negate
+    } : null,
+    styleOpts = [getStyleObj(ternary.consequent, !1), getStyleObj(ternary.alternate, !0)].filter(isPresent);
+  if (shouldPrintDebug && !styleOpts.length) return console.info("  media query, no styles?"), null;
+  const mediaKeyPrecendence = Object.keys(tamaguiConfig.media).reduce((acc, cur, i) => (acc[cur] = new Array(importance + 1).fill(":root").join(""), acc), {});
+  let mediaStyles = [];
+  for (const {
+    styleObj,
+    negate
+  } of styleOpts) {
+    const singleMediaStyles = getStylesAtomic(styleObj).map(style => {
+      const mediaStyle = createMediaStyle(style, key, tamaguiConfig.media, !0, negate),
+        className = `.${mediaStyle.identifier}`;
+      return {
+        ...mediaStyle,
+        className
+      };
+    });
+    shouldPrintDebug === "verbose" && console.info("  media styles:", importance, styleObj, singleMediaStyles.map(x => x.identifier).join(", ")), mediaStyles = [...mediaStyles, ...singleMediaStyles];
+  }
+  return ternary.remove(), {
+    mediaStyles,
+    ternaryWithoutMedia: mt.ternaryWithoutMedia
+  };
+}
+function getMediaQueryTernary(props, ternary, jsxPath, sourcePath) {
+  if (t.isLogicalExpression(ternary.test) && ternary.test.operator === "&&") {
+    const mediaLeft = getMediaInfoFromExpression(props, ternary.test.left, jsxPath, sourcePath, ternary.inlineMediaQuery);
+    if (mediaLeft) return {
+      ...mediaLeft,
+      ternaryWithoutMedia: {
+        ...ternary,
+        test: ternary.test.right
+      }
+    };
+  }
+  const result = getMediaInfoFromExpression(props, ternary.test, jsxPath, sourcePath, ternary.inlineMediaQuery);
+  return result ? {
+    ...result,
+    ternaryWithoutMedia: null
+  } : null;
+}
+function getMediaInfoFromExpression(props, test, jsxPath, sourcePath, inlineMediaQuery) {
+  if (inlineMediaQuery) return {
+    key: inlineMediaQuery,
+    bindingName: inlineMediaQuery
+  };
+  if (t.isMemberExpression(test) && t.isIdentifier(test.object) && t.isIdentifier(test.property)) {
+    const name = test.object.name,
+      key = test.property.name,
+      binding = jsxPath.scope.getAllBindings()[name];
+    if (!binding) return !1;
+    const bindingNode = binding.path?.node;
+    return !t.isVariableDeclarator(bindingNode) || !bindingNode.init || !isValidMediaCall(props, jsxPath, bindingNode.init, sourcePath) ? !1 : {
+      key,
+      bindingName: name
+    };
+  }
+  if (t.isIdentifier(test)) {
+    const key = test.name,
+      node = jsxPath.scope.getBinding(test.name)?.path?.node;
+    return !t.isVariableDeclarator(node) || !node.init || !isValidMediaCall(props, jsxPath, node.init, sourcePath) ? !1 : {
+      key,
+      bindingName: key
+    };
+  }
+  return null;
+}
+function isValidMediaCall(props, jsxPath, init, sourcePath) {
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useMedia") return !1;
+  const mediaBinding = jsxPath.scope.getAllBindings().useMedia;
+  if (!mediaBinding) return !1;
+  const useMediaImport = mediaBinding.path.parent;
+  return !(!t.isImportDeclaration(useMediaImport) || !isValidImport(props, sourcePath));
+}
+export { extractMediaStyle, isValidMediaCall };

package/dist/esm/extractor/extractToClassNames.mjs

@@ -0,0 +1,237 @@
+import * as path from "path";
+import { basename } from "path";
+import * as util from "util";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import { concatClassName } from "@tamagui/helpers";
+import { requireTamaguiCore } from "../helpers/requireTamaguiCore.mjs";
+import { babelParse } from "./babelParse.mjs";
+import { buildClassName } from "./buildClassName.mjs";
+import { ensureImportingConcat } from "./ensureImportingConcat.mjs";
+import { isSimpleSpread } from "./extractHelpers.mjs";
+import { extractMediaStyle } from "./extractMediaStyle.mjs";
+import { getPrefixLogs } from "./getPrefixLogs.mjs";
+import { hoistClassNames } from "./hoistClassNames.mjs";
+import { logLines } from "./logLines.mjs";
+import { getFontFamilyClassNameFromProps } from "./propsToFontFamilyCache.mjs";
+import { timer } from "./timer.mjs";
+const mergeStyleGroups = {
+  shadowOpacity: !0,
+  shadowRadius: !0,
+  shadowColor: !0,
+  shadowOffset: !0
+};
+async function extractToClassNames({
+  extractor,
+  source,
+  sourcePath,
+  options,
+  shouldPrintDebug
+}) {
+  const tm = timer(),
+    {
+      getStylesAtomic
+    } = requireTamaguiCore("web");
+  if (sourcePath?.includes("node_modules")) return null;
+  if (shouldPrintDebug && console.warn(`--- ${sourcePath} --- 
+
+`), typeof source != "string") throw new Error("`source` must be a string of javascript");
+  if (sourcePath && !path.isAbsolute(sourcePath)) throw new Error("`sourcePath` must be an absolute path to a .js file, got: " + sourcePath);
+  /.[tj]sx?$/i.test(sourcePath || "") || console.warn(`${sourcePath?.slice(0, 100)} - bad filename.`), !options.disableExtraction && !options._disableLoadTamagui && (await extractor.loadTamagui(options));
+  const shouldLogTiming = options.logTimings ?? !0,
+    start = Date.now(),
+    mem = process.env.TAMAGUI_SHOW_MEMORY_USAGE && shouldLogTiming ? process.memoryUsage() : null;
+  let ast;
+  try {
+    ast = babelParse(source, sourcePath);
+  } catch (err) {
+    throw console.error("babel parse error:", sourcePath?.slice(0, 100)), err;
+  }
+  tm.mark("babel-parse", shouldPrintDebug === "verbose");
+  const cssMap = /* @__PURE__ */new Map(),
+    existingHoists = {};
+  let hasFlattened = !1;
+  const res = await extractor.parse(ast, {
+    shouldPrintDebug,
+    ...options,
+    sourcePath,
+    extractStyledDefinitions: !0,
+    onStyleRule(identifier, rules) {
+      const css = rules.join(";");
+      shouldPrintDebug && console.info(`adding styled() rule: .${identifier} ${css}`), cssMap.set(`.${identifier}`, {
+        css,
+        commentTexts: []
+      });
+    },
+    getFlattenedNode: ({
+      tag
+    }) => (hasFlattened = !0, tag),
+    onExtractTag: ({
+      parserProps,
+      attrs,
+      node,
+      attemptEval,
+      jsxPath,
+      originalNodeName,
+      filePath,
+      lineNumbers,
+      programPath,
+      isFlattened,
+      config,
+      completeProps,
+      staticConfig
+    }) => {
+      if (staticConfig.acceptsClassName === !1) {
+        shouldPrintDebug && console.info("bail, acceptsClassName is false");
+        return;
+      }
+      const didFlattenThisTag = hasFlattened;
+      hasFlattened = !1;
+      let finalClassNames = [];
+      const finalAttrs = [];
+      let finalStyles = [],
+        viewStyles = {};
+      for (const attr of attrs) attr.type === "style" && (viewStyles = {
+        ...viewStyles,
+        ...attr.value
+      });
+      const ensureNeededPrevStyle = style => {
+          if (!Object.keys(style).some(key => mergeStyleGroups[key])) return style;
+          for (const k in mergeStyleGroups) k in viewStyles && (style[k] = style[k] ?? viewStyles[k]);
+          return style;
+        },
+        addStyles = style => {
+          if (!style) return [];
+          const styleWithPrev = ensureNeededPrevStyle(style),
+            res2 = getStylesAtomic(styleWithPrev);
+          return res2.length && (finalStyles = [...finalStyles, ...res2]), res2;
+        };
+      let lastMediaImportance = 1;
+      for (const attr of attrs) switch (attr.type) {
+        case "style":
+          {
+            if (isFlattened) {
+              const styles2 = addStyles(attr.value),
+                newFontFamily = getFontFamilyClassNameFromProps(attr.value) || "",
+                newClassNames = concatClassName(styles2.map(x => x.identifier).join(" ") + newFontFamily),
+                existing = finalClassNames.find(x => x.type == "StringLiteral");
+              if (existing) {
+                let previous = existing.value;
+                newFontFamily && (shouldPrintDebug && console.info(` newFontFamily: ${newFontFamily}`), previous = previous.replace(/font_[a-z]+/i, "")), existing.value = `${previous} ${newClassNames}`;
+              } else finalClassNames = [...finalClassNames, t.stringLiteral(newClassNames)];
+            } else {
+              const styles2 = getStylesAtomic(attr.value);
+              finalStyles = [...finalStyles, ...styles2];
+              for (const style of styles2) {
+                const prop = style.pseudo ? `${style.property}-${style.pseudo}` : style.property;
+                finalAttrs.push(t.jsxAttribute(t.jsxIdentifier(prop), t.stringLiteral(style.identifier)));
+              }
+            }
+            break;
+          }
+        case "attr":
+          {
+            const val = attr.value;
+            if (t.isJSXSpreadAttribute(val)) isSimpleSpread(val) && finalClassNames.push(t.logicalExpression("&&", val.argument, t.memberExpression(val.argument, t.identifier("className"))));else if (val.name.name === "className") {
+              const value = val.value;
+              if (value) try {
+                const evaluatedValue = attemptEval(value);
+                finalClassNames.push(t.stringLiteral(evaluatedValue));
+              } catch {
+                finalClassNames.push(value.expression);
+              }
+              continue;
+            }
+            finalAttrs.push(val);
+            break;
+          }
+        case "ternary":
+          {
+            const mediaExtraction = extractMediaStyle(parserProps, attr.value, jsxPath, extractor.getTamagui(), sourcePath || "", lastMediaImportance, shouldPrintDebug);
+            if (shouldPrintDebug && mediaExtraction && console.info("ternary (mediaStyles)", mediaExtraction.ternaryWithoutMedia?.inlineMediaQuery ?? "", mediaExtraction.mediaStyles.map(x => x.identifier).join(".")), !mediaExtraction) {
+              addTernaryStyle(attr.value, addStyles(attr.value.consequent), addStyles(attr.value.alternate));
+              continue;
+            }
+            lastMediaImportance++, mediaExtraction.mediaStyles && (finalStyles = [...finalStyles, ...mediaExtraction.mediaStyles]), mediaExtraction.ternaryWithoutMedia ? addTernaryStyle(mediaExtraction.ternaryWithoutMedia, mediaExtraction.mediaStyles, []) : finalClassNames = [...finalClassNames, ...mediaExtraction.mediaStyles.map(x => t.stringLiteral(x.identifier))];
+            break;
+          }
+      }
+      function addTernaryStyle(ternary, a, b) {
+        const cCN = a.map(x => x.identifier).join(" "),
+          aCN = b.map(x => x.identifier).join(" ");
+        a.length && b.length ? finalClassNames.push(t.conditionalExpression(ternary.test, t.stringLiteral(cCN), t.stringLiteral(aCN))) : finalClassNames.push(t.conditionalExpression(ternary.test, t.stringLiteral(" " + cCN), t.stringLiteral(" " + aCN)));
+      }
+      if (shouldPrintDebug && console.info(`  finalClassNames
+`, logLines(finalClassNames.map(x => x.value).join(" "))), node.attributes = finalAttrs, finalClassNames.length) {
+        const extraClassNames = (() => {
+            let value = "";
+            return isFlattened && (process.env.TAMAGUI_DEBUG_OPTIMIZATIONS && (value += "is_tamagui_flattened"), staticConfig.componentName && (value += ` is_${staticConfig.componentName}`)), value;
+          })(),
+          names = buildClassName(finalClassNames, extraClassNames),
+          nameExpr = names ? hoistClassNames(jsxPath, existingHoists, names) : null;
+        let expr = nameExpr;
+        if (nameExpr && !t.isIdentifier(nameExpr) && didFlattenThisTag) {
+          ensureImportingConcat(programPath);
+          const simpleSpreads = attrs.filter(x => x.type === "attr" && t.isJSXSpreadAttribute(x.value) && isSimpleSpread(x.value));
+          expr = t.callExpression(t.identifier("concatClassName"), [expr, ...simpleSpreads.map(val => val.value.argument)]);
+        }
+        node.attributes.push(t.jsxAttribute(t.jsxIdentifier("className"), t.jsxExpressionContainer(expr)));
+      }
+      const comment = util.format("/* %s:%s (%s) */", filePath, lineNumbers, originalNodeName);
+      for (const {
+        identifier,
+        rules
+      } of finalStyles) {
+        const className = `.${identifier}`;
+        if (cssMap.has(className)) {
+          if (comment) {
+            const val = cssMap.get(className);
+            val.commentTexts.push(comment), cssMap.set(className, val);
+          }
+        } else rules.length && cssMap.set(className, {
+          css: rules.join(`
+`),
+          commentTexts: [comment]
+        });
+      }
+    }
+  });
+  if (!res || !res.modified && !res.optimized && !res.flattened && !res.styled) return shouldPrintDebug && console.info("no res or none modified", res), null;
+  const styles = Array.from(cssMap.values()).map(x => x.css).join(`
+`).trim(),
+    result = generate(ast, {
+      concise: !1,
+      filename: sourcePath,
+      // this makes the debug output terrible, and i think sourcemap works already
+      retainLines: !1,
+      sourceFileName: sourcePath,
+      sourceMaps: !0
+    }, source);
+  if (shouldPrintDebug && (console.info(`
+ -------- output code ------- 
+
+`, result.code.split(`
+`).filter(x => !x.startsWith("//")).join(`
+`)), console.info(`
+ -------- output style -------- 
+
+`, styles)), shouldLogTiming) {
+    const memUsed = mem ? Math.round((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204 * 10) / 10 : 0,
+      path2 = basename(sourcePath || "").replace(/\.[jt]sx?$/, "").slice(0, 22).trim().padStart(24),
+      numOptimized = `${res.optimized + res.styled}`.padStart(3),
+      numFound = `${res.found + res.styled}`.padStart(3),
+      numFlattened = `${res.flattened}`.padStart(3),
+      memory = memUsed ? ` ${memUsed}MB` : "",
+      timingStr = `${Date.now() - start}ms`.padStart(6),
+      pre = getPrefixLogs(options),
+      memStr = memory ? `(${memory})` : "";
+    console.info(`${pre} ${path2}   \xB7  ${numFound} found   \xB7  ${numOptimized} opt   \xB7  ${numFlattened} flat  ${timingStr} ${memStr}`);
+  }
+  return {
+    ast,
+    styles,
+    js: result.code,
+    map: result.map
+  };
+}
+export { extractToClassNames };

package/dist/esm/extractor/findTopmostFunction.mjs

@@ -0,0 +1,10 @@
+function findTopmostFunction(jsxPath) {
+  const isFunction = path => path.isArrowFunctionExpression() || path.isFunctionDeclaration() || path.isFunctionExpression();
+  let compFn = jsxPath.findParent(isFunction);
+  for (; compFn;) {
+    const parent = compFn.findParent(isFunction);
+    if (parent) compFn = parent;else break;
+  }
+  return compFn || null;
+}
+export { findTopmostFunction };

package/dist/esm/extractor/generateTamaguiStudioConfig.mjs

@@ -0,0 +1,108 @@
+import { dirname, join } from "path";
+import { generateThemes, writeGeneratedThemes } from "@tamagui/generate-themes";
+import fs, { readFile } from "fs-extra";
+import { requireTamaguiCore } from "../helpers/requireTamaguiCore.mjs";
+import { getBundledConfig } from "./bundleConfig.mjs";
+const tamaguiDir = join(process.cwd(), ".tamagui"),
+  confFile = join(tamaguiDir, "tamagui.config.json");
+async function generateTamaguiStudioConfig(tamaguiOptions, configIn, rebuild = !1) {
+  try {
+    const config = configIn ?? (await getBundledConfig(tamaguiOptions, rebuild));
+    if (!config) return;
+    const out = transformConfig(config, tamaguiOptions.platform);
+    await fs.ensureDir(dirname(confFile)), await fs.writeJSON(confFile, out, {
+      spaces: 2
+    });
+  } catch (err) {
+    (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) && console.warn("generateTamaguiStudioConfig error", err);
+  }
+}
+function generateTamaguiStudioConfigSync(_tamaguiOptions, config) {
+  try {
+    fs.ensureDirSync(dirname(confFile)), fs.writeJSONSync(confFile, transformConfig(config, _tamaguiOptions.platform), {
+      spaces: 2
+    });
+  } catch (err) {
+    (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) && console.warn("generateTamaguiStudioConfig error", err);
+  }
+}
+async function generateTamaguiThemes(tamaguiOptions, force = !1) {
+  if (!tamaguiOptions.themeBuilder) return;
+  const {
+      input,
+      output
+    } = tamaguiOptions.themeBuilder,
+    inPath = resolveRelativePath(input),
+    outPath = resolveRelativePath(output),
+    generatedOutput = await generateThemes(inPath),
+    hasChanged = force || (await (async () => {
+      try {
+        if (!(await fs.pathExists(join(tamaguiDir, "theme-builder.json")))) return !0;
+        if (!generatedOutput) return !1;
+        const next = generatedOutput.generated,
+          current = await readFile(outPath, "utf-8");
+        return next !== current;
+      } catch {}
+      return !0;
+    })());
+  return hasChanged && (await writeGeneratedThemes(tamaguiDir, outPath, generatedOutput)), hasChanged;
+}
+const resolveRelativePath = inputPath => inputPath.startsWith(".") ? join(process.cwd(), inputPath) : require.resolve(inputPath);
+function cloneDeepSafe(x, excludeKeys = {}) {
+  return x && (Array.isArray(x) ? x.map(_ => cloneDeepSafe(_)) : typeof x == "function" ? "Function" : typeof x != "object" ? x : "$$typeof" in x ? "Component" : Object.fromEntries(Object.entries(x).flatMap(([k, v]) => excludeKeys[k] ? [] : [[k, cloneDeepSafe(v)]])));
+}
+function transformConfig(config, platform) {
+  if (!config) return null;
+  const {
+      getVariableValue
+    } = requireTamaguiCore(platform),
+    next = cloneDeepSafe(config, {
+      validStyles: !0
+    }),
+    {
+      components,
+      nameToPaths,
+      tamaguiConfig
+    } = next,
+    {
+      themes,
+      tokens
+    } = tamaguiConfig;
+  for (const key in themes) {
+    const theme = themes[key];
+    theme.id = key;
+    for (const tkey in theme) theme[tkey] = getVariableValue(theme[tkey]);
+  }
+  for (const key in tokens) {
+    const token = {
+      ...tokens[key]
+    };
+    for (const tkey in token) token[tkey] = getVariableValue(token[tkey]);
+  }
+  for (const component of components) for (const _ in component.nameToInfo) {
+    const compDefinition = {
+      ...component.nameToInfo[_]
+    };
+    component.nameToInfo[_] = compDefinition;
+    const {
+      parentStaticConfig,
+      ...rest
+    } = compDefinition.staticConfig;
+    compDefinition.staticConfig = rest;
+  }
+  next.nameToPaths = {};
+  for (const key in nameToPaths) next.nameToPaths[key] = [...nameToPaths[key]];
+  const {
+    fontsParsed,
+    getCSS,
+    tokensParsed,
+    themeConfig,
+    ...cleanedConfig
+  } = next.tamaguiConfig;
+  return {
+    components,
+    nameToPaths,
+    tamaguiConfig: cleanedConfig
+  };
+}
+export { generateTamaguiStudioConfig, generateTamaguiStudioConfigSync, generateTamaguiThemes };

package/dist/esm/extractor/generatedUid.mjs

@@ -0,0 +1,12 @@
+import * as t from "@babel/types";
+function generateUid(scope, name) {
+  if (typeof scope != "object") throw "generateUid expects a scope object as its first parameter";
+  if (!(typeof name == "string" && name !== "")) throw "generateUid expects a valid name as its second parameter";
+  name = t.toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, "");
+  let uid,
+    i = 0;
+  do i > 1 ? uid = name + i : uid = name, i++; while (scope.hasLabel(uid) || scope.hasBinding(uid) || scope.hasGlobal(uid) || scope.hasReference(uid));
+  const program = scope.getProgramParent();
+  return program.references[uid] = !0, program.uids[uid] = !0, uid;
+}
+export { generateUid };

package/dist/esm/extractor/getPrefixLogs.mjs

@@ -0,0 +1,4 @@
+function getPrefixLogs(options) {
+  return options?.prefixLogs ?? ` ${options?.platform || "web"}  | `;
+}
+export { getPrefixLogs };

package/dist/esm/extractor/getPropValueFromAttributes.mjs

@@ -0,0 +1,31 @@
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import { accessSafe } from "./accessSafe.mjs";
+function getPropValueFromAttributes(propName, attrs) {
+  let propIndex = -1,
+    jsxAttr = null;
+  for (let idx = -1, len = attrs.length; ++idx < len;) {
+    const attr = attrs[idx];
+    if (t.isJSXAttribute(attr) && attr.name && attr.name.name === propName) {
+      propIndex = idx, jsxAttr = attr;
+      break;
+    }
+  }
+  if (!jsxAttr || jsxAttr.value == null) return null;
+  let propValue = jsxAttr.value;
+  if (t.isJSXExpressionContainer(propValue) && (propValue = propValue.expression), t.isJSXEmptyExpression(propValue)) return console.error("encountered JSXEmptyExpression"), null;
+  const applicableSpreads = attrs.filter(
+  // 1. idx is greater than propValue prop index
+  // 2. attr is a spread operator
+  (attr, idx) => {
+    if (t.isJSXSpreadAttribute(attr)) {
+      if (t.isIdentifier(attr.argument) || t.isMemberExpression(attr.argument)) return idx > propIndex;
+      if (t.isLogicalExpression(attr.argument)) return !1;
+      throw new Error(`unsupported spread of type "${attr.argument.type}": ${// @ts-ignore
+      generate(attr).code}`);
+    }
+    return !1;
+  }).map(attr => attr.argument);
+  return applicableSpreads.length > 0 && (propValue = applicableSpreads.reduce((acc, val) => t.logicalExpression("||", accessSafe(val, propName), acc), propValue)), propValue;
+}
+export { getPropValueFromAttributes };