@tamagui/static 1.89.25 → 1.89.27-1708112217600

package/dist/esm/extractor/loadTamagui.native.js

@@ -1,148 +1,466 @@
 import { readFileSync, writeFileSync } from "fs";
 import { basename, dirname, extname, join, relative, resolve } from "path";
 import { Color, colorLog } from "@tamagui/cli-color";
-import { getDefaultTamaguiConfig } from "@tamagui/config-default";
 import esbuild from "esbuild";
 import { existsSync, pathExists, readJSON, writeFile } from "fs-extra";
 import { SHOULD_DEBUG } from "../constants";
 import { requireTamaguiCore } from "../helpers/requireTamaguiCore";
 import { minifyCSS } from "../minifyCSS";
 import { getNameToPaths, registerRequire } from "../registerRequire";
-import {
-  TamaguiProjectInfo,
-  getBundledConfig,
-  hasBundledConfigChanged,
-  loadComponents
-} from "./bundleConfig";
-import {
-  generateTamaguiStudioConfig,
-  generateTamaguiStudioConfigSync,
-  generateTamaguiThemes
-} from "./generateTamaguiStudioConfig";
+import { TamaguiProjectInfo, getBundledConfig, hasBundledConfigChanged, loadComponents } from "./bundleConfig";
+import { generateTamaguiStudioConfig, generateTamaguiStudioConfigSync, generateTamaguiThemes } from "./generateTamaguiStudioConfig";
 import { getTamaguiConfigPathFromOptionsConfig } from "./getTamaguiConfigPathFromOptionsConfig";
 import { readFile } from "fs/promises";
-const getFilledOptions = (propsIn) => ({
-  // defaults
-  platform: "native",
-  config: "tamagui.config.ts",
-  components: ["tamagui"],
-  ...propsIn
-});
-async function loadTamagui(propsIn) {
-  const props = getFilledOptions(propsIn), bundleInfo = await getBundledConfig(props);
-  if (!bundleInfo)
-    return console.warn(
-      "No bundled config generated, maybe an error in bundling. Set DEBUG=tamagui and re-run to get logs."
-    ), null;
-  if (await generateThemesAndLog(props, !0), !hasBundledConfigChanged())
-    return bundleInfo;
-  if (bundleInfo) {
-    const { createTamagui } = requireTamaguiCore(props.platform), config = createTamagui(bundleInfo.tamaguiConfig), { outputCSS } = props;
-    if (outputCSS && props.platform === "web") {
-      const flush = async () => {
-        colorLog(Color.FgYellow, `    \u27A1 [tamagui] output css: ${outputCSS}
-`), await writeFile(outputCSS, css);
-      }, cssOut = config.getCSS(), css = props.disableMinifyCSS === !1 ? minifyCSS(cssOut).code : cssOut;
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve2(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve2, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _instanceof(left, right) {
+  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _object_without_properties(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return target;
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
       try {
-        await readFile(outputCSS, "utf8") === css || await flush();
-      } catch {
-        await flush();
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
       }
-    }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
   }
-  return process.env.NODE_ENV === "development" && await generateTamaguiStudioConfig(props, bundleInfo), bundleInfo;
 }
-let waiting = !1, hasLoggedOnce = !1;
-const generateThemesAndLog = async (options, force = !1) => {
-  if (!waiting && options.themeBuilder)
-    try {
-      waiting = !0, await new Promise((res) => setTimeout(res, 30));
-      const didGenerate = await generateTamaguiThemes(options, force);
-      !hasLoggedOnce && didGenerate && (hasLoggedOnce = !0, colorLog(
-        Color.FgYellow,
-        `
-    \u27A1 [tamagui] generated themes: ${relative(
-          process.cwd(),
-          options.themeBuilder.output
-        )}`
-      ));
-    } finally {
-      waiting = !1;
-    }
-}, last = {}, lastVersion = {};
+var getFilledOptions = function(propsIn) {
+  return _object_spread({
+    // defaults
+    platform: "native",
+    config: "tamagui.config.ts",
+    components: [
+      "tamagui"
+    ]
+  }, propsIn);
+};
+function loadTamagui(propsIn) {
+  return _loadTamagui.apply(this, arguments);
+}
+function _loadTamagui() {
+  return _loadTamagui = _async_to_generator(function(propsIn) {
+    var props, bundleInfo, createTamagui, config, outputCSS, flush, cssOut, css, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return props = getFilledOptions(propsIn), [
+            4,
+            getBundledConfig(props)
+          ];
+        case 1:
+          return bundleInfo = _state.sent(), bundleInfo ? [
+            4,
+            generateThemesAndLog(props, !0)
+          ] : (console.warn("No bundled config generated, maybe an error in bundling. Set DEBUG=tamagui and re-run to get logs."), [
+            2,
+            null
+          ]);
+        case 2:
+          if (_state.sent(), !hasBundledConfigChanged())
+            return [
+              2,
+              bundleInfo
+            ];
+          if (!bundleInfo)
+            return [
+              3,
+              10
+            ];
+          if (createTamagui = requireTamaguiCore(props.platform).createTamagui, config = createTamagui(bundleInfo.tamaguiConfig), outputCSS = props.outputCSS, !(outputCSS && props.platform === "web"))
+            return [
+              3,
+              10
+            ];
+          flush = function() {
+            var _ref = _async_to_generator(function() {
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    return colorLog(Color.FgYellow, "    \u27A1 [tamagui] output css: ".concat(outputCSS, `
+`)), [
+                      4,
+                      writeFile(outputCSS, css)
+                    ];
+                  case 1:
+                    return _state2.sent(), [
+                      2
+                    ];
+                }
+              });
+            });
+            return function() {
+              return _ref.apply(this, arguments);
+            };
+          }(), cssOut = config.getCSS(), css = props.disableMinifyCSS === !1 ? minifyCSS(cssOut).code : cssOut, _state.label = 3;
+        case 3:
+          return _state.trys.push([
+            3,
+            8,
+            ,
+            10
+          ]), [
+            4,
+            readFile(outputCSS, "utf8")
+          ];
+        case 4:
+          return _state.sent() !== css ? [
+            3,
+            5
+          ] : [
+            3,
+            7
+          ];
+        case 5:
+          return [
+            4,
+            flush()
+          ];
+        case 6:
+          _state.sent(), _state.label = 7;
+        case 7:
+          return [
+            3,
+            10
+          ];
+        case 8:
+          return e = _state.sent(), [
+            4,
+            flush()
+          ];
+        case 9:
+          return _state.sent(), [
+            3,
+            10
+          ];
+        case 10:
+          return process.env.NODE_ENV !== "development" ? [
+            3,
+            12
+          ] : [
+            4,
+            generateTamaguiStudioConfig(props, bundleInfo)
+          ];
+        case 11:
+          _state.sent(), _state.label = 12;
+        case 12:
+          return [
+            2,
+            bundleInfo
+          ];
+      }
+    });
+  }), _loadTamagui.apply(this, arguments);
+}
+var waiting = !1, hasLoggedOnce = !1, generateThemesAndLog = function() {
+  var _ref = _async_to_generator(function(options) {
+    var force, didGenerate, whitespaceBefore, _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (force = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : !1, waiting)
+            return [
+              2
+            ];
+          if (!options.themeBuilder)
+            return [
+              2
+            ];
+          _state.label = 1;
+        case 1:
+          return _state.trys.push([
+            1,
+            ,
+            4,
+            5
+          ]), waiting = !0, [
+            4,
+            new Promise(function(res) {
+              return setTimeout(res, 30);
+            })
+          ];
+        case 2:
+          return _state.sent(), [
+            4,
+            generateTamaguiThemes(options, force)
+          ];
+        case 3:
+          return didGenerate = _state.sent(), !hasLoggedOnce && didGenerate && (hasLoggedOnce = !0, whitespaceBefore = "    ", colorLog(Color.FgYellow, `
+`.concat(whitespaceBefore, "\u27A1 [tamagui] generated themes: ").concat(relative(process.cwd(), options.themeBuilder.output)))), [
+            3,
+            5
+          ];
+        case 4:
+          return waiting = !1, [
+            7
+          ];
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function(options) {
+    return _ref.apply(this, arguments);
+  };
+}(), last = {}, lastVersion = {};
 function loadTamaguiBuildConfigSync(tamaguiOptions) {
-  const buildFilePath = (tamaguiOptions == null ? void 0 : tamaguiOptions.buildFile) ?? "tamagui.build.ts";
+  var _tamaguiOptions_buildFile, buildFilePath = (_tamaguiOptions_buildFile = tamaguiOptions == null ? void 0 : tamaguiOptions.buildFile) !== null && _tamaguiOptions_buildFile !== void 0 ? _tamaguiOptions_buildFile : "tamagui.build.ts";
   if (existsSync(buildFilePath)) {
-    const registered = registerRequire("web");
+    var registered = registerRequire("web");
     try {
-      const out = require(buildFilePath).default;
+      var out = require(buildFilePath).default;
       if (!out)
-        throw new Error(`No default export found in ${buildFilePath}: ${out}`);
-      tamaguiOptions = {
-        ...tamaguiOptions,
-        ...out
-      };
+        throw new Error("No default export found in ".concat(buildFilePath, ": ").concat(out));
+      tamaguiOptions = _object_spread({}, tamaguiOptions, out);
     } finally {
       registered.unregister();
     }
   }
   if (!tamaguiOptions)
-    throw new Error(
-      "No tamagui build options found either via input props or at tamagui.build.ts"
-    );
-  return {
+    throw new Error("No tamagui build options found either via input props or at tamagui.build.ts");
+  return _object_spread({
     config: "tamagui.config.ts",
-    components: ["@tamagui/core"],
-    ...tamaguiOptions
-  };
+    components: [
+      "@tamagui/core"
+    ]
+  }, tamaguiOptions);
 }
-function loadTamaguiSync({
-  forceExports,
-  cacheKey,
-  ...propsIn
-}) {
-  const key = JSON.stringify(propsIn);
+function loadTamaguiSync(_param) {
+  var forceExports = _param.forceExports, cacheKey = _param.cacheKey, propsIn = _object_without_properties(_param, [
+    "forceExports",
+    "cacheKey"
+  ]), key = JSON.stringify(propsIn);
   if (last[key] && !hasBundledConfigChanged() && (!lastVersion[key] || lastVersion[key] === cacheKey))
     return last[key];
   lastVersion[key] = cacheKey || "";
-  const props = getFilledOptions(propsIn);
+  var props = getFilledOptions(propsIn);
   process.env.IS_STATIC = "is_static", process.env.TAMAGUI_IS_SERVER = "true";
-  const { unregister } = registerRequire(props.platform, {
+  var unregister = registerRequire(props.platform, {
     proxyWormImports: !!forceExports
-  });
+  }).unregister;
   try {
-    const devValueOG = globalThis.__DEV__;
+    var devValueOG = globalThis.__DEV__;
     globalThis.__DEV__ = process.env.NODE_ENV === "development";
     try {
-      let tamaguiConfig = null;
+      var tamaguiConfig = null;
       if (propsIn.config) {
-        const configPath = getTamaguiConfigPathFromOptionsConfig(propsIn.config), exp = require(configPath);
+        var configPath = getTamaguiConfigPathFromOptionsConfig(propsIn.config), exp = require(configPath);
         if (tamaguiConfig = exp.default || exp.config || exp, !tamaguiConfig || !tamaguiConfig.parsed) {
-          const confPath = require.resolve(configPath);
-          throw new Error(`Can't find valid config in ${confPath}:
+          var confPath = require.resolve(configPath);
+          throw new Error("Can't find valid config in ".concat(confPath, `:
           
-  Be sure you "export default" or "export const config" the config.`);
+  Be sure you "export default" or "export const config" the config.`));
         }
         if (tamaguiConfig) {
-          const { createTamagui } = requireTamaguiCore(props.platform);
+          var createTamagui = requireTamaguiCore(props.platform).createTamagui;
           createTamagui(tamaguiConfig);
         }
       }
-      const components = loadComponents(props, forceExports);
+      var components = loadComponents(props, forceExports);
       if (!components)
         throw new Error("No components loaded");
       process.env.DEBUG === "tamagui" && console.info("components", components), process.env.IS_STATIC = void 0, globalThis.__DEV__ = devValueOG;
-      const info = {
+      var info = {
         components,
         tamaguiConfig,
         nameToPaths: getNameToPaths()
       };
       if (tamaguiConfig) {
-        const { outputCSS } = props;
+        var outputCSS = props.outputCSS;
         if (outputCSS) {
-          const flush = () => {
-            colorLog(Color.FgYellow, `    \u27A1 [tamagui] output css: ${outputCSS}
-`), writeFileSync(outputCSS, css);
+          var flush = function() {
+            colorLog(Color.FgYellow, "    \u27A1 [tamagui] output css: ".concat(outputCSS, `
+`)), writeFileSync(outputCSS, css);
           }, css = props.disableMinifyCSS === !1 ? minifyCSS(tamaguiConfig.getCSS()).code : tamaguiConfig.getCSS();
           try {
             readFileSync(outputCSS, "utf-8") === css || flush();
@@ -152,22 +470,19 @@ function loadTamaguiSync({
         }
         generateTamaguiStudioConfigSync(props, info);
       }
-      return last[key] = {
-        ...info,
+      return last[key] = _object_spread_props(_object_spread({}, info), {
         cached: !0
-      }, info;
+      }), info;
     } catch (err) {
-      err instanceof Error ? !SHOULD_DEBUG && !forceExports ? (console.warn(
-        "Error loading tamagui.config.ts (set DEBUG=tamagui to see full stack), running tamagui without custom config"
-      ), console.info(`
+      _instanceof(err, Error) ? !SHOULD_DEBUG && !forceExports ? (console.warn("Error loading tamagui.config.ts (set DEBUG=tamagui to see full stack), running tamagui without custom config"), console.info(`
 
-    ${err.message}
+    `.concat(err.message, `
 
-`)) : SHOULD_DEBUG && console.error(err) : console.error("Error loading tamagui.config.ts", err);
-      const { createTamagui } = requireTamaguiCore(props.platform);
+`))) : SHOULD_DEBUG && console.error(err) : console.error("Error loading tamagui.config.ts", err);
+      var createTamagui1 = requireTamaguiCore(props.platform).createTamagui, getDefaultTamaguiConfig = require("@tamagui/config-default").getDefaultTamaguiConfig;
       return {
         components: [],
-        tamaguiConfig: createTamagui(getDefaultTamaguiConfig()),
+        tamaguiConfig: createTamagui1(getDefaultTamaguiConfig()),
         nameToPaths: {}
       };
     }
@@ -175,114 +490,264 @@ function loadTamaguiSync({
     unregister();
   }
 }
-async function getOptions({
-  root = process.cwd(),
-  tsconfigPath = "tsconfig.json",
-  tamaguiOptions,
-  host,
-  debug
-} = {}) {
-  const dotDir = join(root, ".tamagui");
-  let pkgJson = {};
-  try {
-    pkgJson = await readJSON(join(root, "package.json"));
-  } catch {
-  }
-  return {
-    mode: process.env.NODE_ENV === "production" ? "production" : "development",
-    root,
-    host: host || "127.0.0.1",
-    pkgJson,
-    debug,
-    tsconfigPath,
-    tamaguiOptions: {
-      platform: "native",
-      components: ["tamagui"],
-      ...tamaguiOptions,
-      config: await getDefaultTamaguiConfigPath(root, tamaguiOptions == null ? void 0 : tamaguiOptions.config)
-    },
-    paths: {
-      dotDir,
-      conf: join(dotDir, "tamagui.config.json"),
-      types: join(dotDir, "types.json")
-    }
-  };
+function getOptions() {
+  return _getOptions.apply(this, arguments);
+}
+function _getOptions() {
+  return _getOptions = _async_to_generator(function() {
+    var _ref, _ref_root, root, _ref_tsconfigPath, tsconfigPath, tamaguiOptions, host, debug, dotDir, pkgJson, err, _tmp, _tmp1, _tmp2, _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _ref = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {}, _ref_root = _ref.root, root = _ref_root === void 0 ? process.cwd() : _ref_root, _ref_tsconfigPath = _ref.tsconfigPath, tsconfigPath = _ref_tsconfigPath === void 0 ? "tsconfig.json" : _ref_tsconfigPath, tamaguiOptions = _ref.tamaguiOptions, host = _ref.host, debug = _ref.debug, dotDir = join(root, ".tamagui"), pkgJson = {}, _state.label = 1;
+        case 1:
+          return _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]), [
+            4,
+            readJSON(join(root, "package.json"))
+          ];
+        case 2:
+          return pkgJson = _state.sent(), [
+            3,
+            4
+          ];
+        case 3:
+          return err = _state.sent(), [
+            3,
+            4
+          ];
+        case 4:
+          return _tmp = {
+            mode: process.env.NODE_ENV === "production" ? "production" : "development",
+            root,
+            host: host || "127.0.0.1",
+            pkgJson,
+            debug,
+            tsconfigPath
+          }, _tmp1 = [
+            _object_spread({
+              platform: "native",
+              components: [
+                "tamagui"
+              ]
+            }, tamaguiOptions)
+          ], _tmp2 = {}, [
+            4,
+            getDefaultTamaguiConfigPath(root, tamaguiOptions == null ? void 0 : tamaguiOptions.config)
+          ];
+        case 5:
+          return [
+            2,
+            (_tmp.tamaguiOptions = _object_spread_props.apply(void 0, _tmp1.concat([
+              (_tmp2.config = _state.sent(), _tmp2)
+            ])), _tmp.paths = {
+              dotDir,
+              conf: join(dotDir, "tamagui.config.json"),
+              types: join(dotDir, "types.json")
+            }, _tmp)
+          ];
+      }
+    });
+  }), _getOptions.apply(this, arguments);
 }
 function resolveWebOrNativeSpecificEntry(entry) {
-  const workspaceRoot = resolve(), resolved = require.resolve(entry, { paths: [workspaceRoot] }), ext = extname(resolved), fileName = basename(resolved).replace(ext, ""), specificFile = join(dirname(resolved), fileName + "." + "native" + ext);
+  var workspaceRoot = resolve(), resolved = require.resolve(entry, {
+    paths: [
+      workspaceRoot
+    ]
+  }), ext = extname(resolved), fileName = basename(resolved).replace(ext, ""), specificExt = "native", specificFile = join(dirname(resolved), fileName + "." + specificExt + ext);
   return existsSync(specificFile) ? specificFile : entry;
 }
-const defaultPaths = ["tamagui.config.ts", join("src", "tamagui.config.ts")];
-let hasWarnedOnce = !1;
-async function getDefaultTamaguiConfigPath(root, configPath) {
-  const searchPaths = [
-    ...new Set(
-      [configPath, ...defaultPaths].filter(Boolean).map((p) => join(root, p))
-    )
-  ];
-  for (const path of searchPaths)
-    if (await pathExists(path))
-      return path;
-  hasWarnedOnce || (hasWarnedOnce = !0, console.warn(`Warning: couldn't find tamagui.config.ts in the following paths given configuration "${configPath}":
-    ${searchPaths.join(`
-  `)}
-  `));
+var defaultPaths = [
+  "tamagui.config.ts",
+  join("src", "tamagui.config.ts")
+], hasWarnedOnce = !1;
+function getDefaultTamaguiConfigPath(root, configPath) {
+  return _getDefaultTamaguiConfigPath.apply(this, arguments);
 }
-async function watchTamaguiConfig(tamaguiOptions) {
-  var _a;
-  const options = await getOptions({ tamaguiOptions });
-  if (!options.tamaguiOptions.config)
-    throw new Error("No config");
-  if (process.env.NODE_ENV === "production")
-    return {
-      dispose() {
+function _getDefaultTamaguiConfigPath() {
+  return _getDefaultTamaguiConfigPath = _async_to_generator(function(root, configPath) {
+    var searchPaths, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, path, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          searchPaths = _to_consumable_array(new Set([
+            configPath
+          ].concat(_to_consumable_array(defaultPaths)).filter(Boolean).map(function(p) {
+            return join(root, p);
+          }))), _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            6,
+            7,
+            8
+          ]), _iterator = searchPaths[Symbol.iterator](), _state.label = 2;
+        case 2:
+          return (_iteratorNormalCompletion = (_step = _iterator.next()).done) ? [
+            3,
+            5
+          ] : (path = _step.value, [
+            4,
+            pathExists(path)
+          ]);
+        case 3:
+          if (_state.sent())
+            return [
+              2,
+              path
+            ];
+          _state.label = 4;
+        case 4:
+          return _iteratorNormalCompletion = !0, [
+            3,
+            2
+          ];
+        case 5:
+          return [
+            3,
+            8
+          ];
+        case 6:
+          return err = _state.sent(), _didIteratorError = !0, _iteratorError = err, [
+            3,
+            8
+          ];
+        case 7:
+          try {
+            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+          } finally {
+            if (_didIteratorError)
+              throw _iteratorError;
+          }
+          return [
+            7
+          ];
+        case 8:
+          return hasWarnedOnce || (hasWarnedOnce = !0, console.warn(`Warning: couldn't find tamagui.config.ts in the following paths given configuration "`.concat(configPath, `":
+    `).concat(searchPaths.join(`
+  `), `
+  `))), [
+            2
+          ];
       }
-    };
-  const disposeConfigWatcher = await esbuildWatchFiles(
-    options.tamaguiOptions.config,
-    () => {
-      generateTamaguiStudioConfig(options.tamaguiOptions, null, !0);
-    }
-  ), themeBuilderInput = (_a = options.tamaguiOptions.themeBuilder) == null ? void 0 : _a.input;
-  let disposeThemesWatcher;
-  if (themeBuilderInput) {
-    let inputPath = themeBuilderInput;
-    try {
-      inputPath = require.resolve(themeBuilderInput);
-    } catch {
-    }
-    disposeThemesWatcher = await esbuildWatchFiles(inputPath, () => {
-      generateThemesAndLog(options.tamaguiOptions);
     });
-  }
-  return {
-    dispose() {
-      disposeConfigWatcher(), disposeThemesWatcher == null || disposeThemesWatcher();
-    }
-  };
+  }), _getDefaultTamaguiConfigPath.apply(this, arguments);
 }
-async function esbuildWatchFiles(entry, onChanged) {
-  let hasRunOnce = !1;
-  const context = await esbuild.context({
-    bundle: !0,
-    entryPoints: [entry],
-    resolveExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
-    logLevel: "silent",
-    write: !1,
-    plugins: [
-      {
-        name: "on-rebuild",
-        setup({ onEnd }) {
-          onEnd(() => {
-            hasRunOnce ? onChanged() : hasRunOnce = !0;
-          });
-        }
+function watchTamaguiConfig(tamaguiOptions) {
+  return _watchTamaguiConfig.apply(this, arguments);
+}
+function _watchTamaguiConfig() {
+  return _watchTamaguiConfig = _async_to_generator(function(tamaguiOptions) {
+    var _options_tamaguiOptions_themeBuilder, options, disposeConfigWatcher, themeBuilderInput, disposeThemesWatcher, inputPath;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            getOptions({
+              tamaguiOptions
+            })
+          ];
+        case 1:
+          if (options = _state.sent(), !options.tamaguiOptions.config)
+            throw new Error("No config");
+          return process.env.NODE_ENV === "production" ? [
+            2,
+            {
+              dispose: function() {
+              }
+            }
+          ] : [
+            4,
+            esbuildWatchFiles(options.tamaguiOptions.config, function() {
+              generateTamaguiStudioConfig(options.tamaguiOptions, null, !0);
+            })
+          ];
+        case 2:
+          if (disposeConfigWatcher = _state.sent(), themeBuilderInput = (_options_tamaguiOptions_themeBuilder = options.tamaguiOptions.themeBuilder) === null || _options_tamaguiOptions_themeBuilder === void 0 ? void 0 : _options_tamaguiOptions_themeBuilder.input, !themeBuilderInput)
+            return [
+              3,
+              4
+            ];
+          inputPath = themeBuilderInput;
+          try {
+            inputPath = require.resolve(themeBuilderInput);
+          } catch {
+          }
+          return [
+            4,
+            esbuildWatchFiles(inputPath, function() {
+              generateThemesAndLog(options.tamaguiOptions);
+            })
+          ];
+        case 3:
+          disposeThemesWatcher = _state.sent(), _state.label = 4;
+        case 4:
+          return [
+            2,
+            {
+              dispose: function() {
+                disposeConfigWatcher(), disposeThemesWatcher == null || disposeThemesWatcher();
+              }
+            }
+          ];
       }
-    ]
-  });
-  return context.watch(), () => {
-    context.dispose();
-  };
+    });
+  }), _watchTamaguiConfig.apply(this, arguments);
+}
+function esbuildWatchFiles(entry, onChanged) {
+  return _esbuildWatchFiles.apply(this, arguments);
+}
+function _esbuildWatchFiles() {
+  return _esbuildWatchFiles = _async_to_generator(function(entry, onChanged) {
+    var hasRunOnce, context;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return hasRunOnce = !1, [
+            4,
+            esbuild.context({
+              bundle: !0,
+              entryPoints: [
+                entry
+              ],
+              resolveExtensions: [
+                ".ts",
+                ".tsx",
+                ".js",
+                ".jsx",
+                ".mjs"
+              ],
+              logLevel: "silent",
+              write: !1,
+              plugins: [
+                {
+                  name: "on-rebuild",
+                  setup: function(param) {
+                    var onEnd = param.onEnd;
+                    onEnd(function() {
+                      hasRunOnce ? onChanged() : hasRunOnce = !0;
+                    });
+                  }
+                }
+              ]
+            })
+          ];
+        case 1:
+          return context = _state.sent(), context.watch(), [
+            2,
+            function() {
+              context.dispose();
+            }
+          ];
+      }
+    });
+  }), _esbuildWatchFiles.apply(this, arguments);
 }
 export {
   TamaguiProjectInfo,