@tamagui/helpers-node 1.110.5 → 1.111.1

package/dist/getDefaultTamaguiOptions.native.js

@@ -19,144 +19,17 @@ __export(getDefaultTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(getDefaultTamaguiOptions_exports);
 var import_getTamaguiDefaultPath = require("./getTamaguiDefaultPath");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg), value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
-}
-function _async_to_generator(fn) {
-  return function() {
-    var self = this, args = arguments;
-    return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(void 0);
-    });
-  };
-}
-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: []
+async function getDefaultTamaguiOptions(param) {
+  var { cwd = "." } = param;
+  return {
+    platform: "native",
+    components: [
+      "tamagui"
+    ],
+    config: await (0, import_getTamaguiDefaultPath.getDefaultTamaguiConfigPath)({
+      cwd
+    })
   };
-  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 {
-      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
-    };
-  }
-}
-function getDefaultTamaguiOptions(_) {
-  return _getDefaultTamaguiOptions.apply(this, arguments);
-}
-function _getDefaultTamaguiOptions() {
-  return _getDefaultTamaguiOptions = _async_to_generator(function(param) {
-    var _param_cwd, cwd, _tmp;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _param_cwd = param.cwd, cwd = _param_cwd === void 0 ? "." : _param_cwd, _tmp = {
-            platform: "native",
-            components: [
-              "tamagui"
-            ]
-          }, [
-            4,
-            (0, import_getTamaguiDefaultPath.getDefaultTamaguiConfigPath)({
-              cwd
-            })
-          ];
-        case 1:
-          return [
-            2,
-            (_tmp.config = _state.sent(), _tmp)
-          ];
-      }
-    });
-  }), _getDefaultTamaguiOptions.apply(this, arguments);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/getDefaultTamaguiOptions.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/Users/n8/tamagui/code/core/helpers-node/src/getDefaultTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAEA,mCAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5C,SAAsBA,yBAAyB,GAI9C;SAJqBA,0BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,4BAAAA;AAAAA,qCAAf,oBAAA,SAAwC,OAI9C;oBAHCC,KAAAA;;;;8BAD6C,MAC7CA,KAAAA,MAAAA,eAAAA,SAAM,MAAA;YAKJC,UAAU;YACVC,YAAU;cAAG;;aACL;;gBAAMC,0DAA4B;cAAEH;YAAI,CAAA;;;AAHlD,iBAAA;;kBAGEI,SAAQ,OAAA,KAAA,GAAA;;;;EAEZ,CAAA,GAVsBL,0BAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["getDefaultTamaguiOptions", "cwd", "platform", "components", "getDefaultTamaguiConfigPath", "config"]
+  "mappings": ";;;;;;;;;;;;;;;AAEA;;;;;mCAA4C;AAE5C,eAAsBA,yBAAyB,OAI9C;MAJ8C,EAC7CC,MAAM,IAAG,IADoC;AAK7C,SAAO;IACLC,UAAU;IACVC,YAAY;MAAC;;IACbC,QAAQ,UAAMC,0DAA4B;MAAEJ;IAAI,CAAA;EAClD;AACF;",
+  "names": ["getDefaultTamaguiOptions", "cwd", "platform", "components", "config", "getDefaultTamaguiConfigPath"]
 }

package/dist/getTamaguiDefaultPath.native.js

@@ -18,153 +18,24 @@ __export(getTamaguiDefaultPath_exports, {
   getDefaultTamaguiConfigPath: () => getDefaultTamaguiConfigPath
 });
 module.exports = __toCommonJS(getTamaguiDefaultPath_exports);
-var import_path = require("path"), import_fs_extra = require("fs-extra");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg), value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
-}
-function _async_to_generator(fn) {
-  return function() {
-    var self = this, args = arguments;
-    return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(void 0);
-    });
-  };
-}
-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 {
-      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
-    };
-  }
-}
-var cachedPath = "";
-function getDefaultTamaguiConfigPath(_) {
-  return _getDefaultTamaguiConfigPath.apply(this, arguments);
-}
-function _getDefaultTamaguiConfigPath() {
-  return _getDefaultTamaguiConfigPath = _async_to_generator(function(param) {
-    var _param_cwd, cwd, _param_cache, cache, defaultPaths, existing, found;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _param_cwd = param.cwd, cwd = _param_cwd === void 0 ? "." : _param_cwd, _param_cache = param.cache, cache = _param_cache === void 0 ? !0 : _param_cache, cache && cachedPath ? [
-            2,
-            cachedPath
-          ] : (defaultPaths = [
-            "tamagui.config.ts",
-            (0, import_path.join)("src", "tamagui.config.ts")
-          ].map(function(p) {
-            return (0, import_path.join)(cwd, p);
-          }), [
-            4,
-            Promise.all(defaultPaths.map(function(path) {
-              return (0, import_fs_extra.pathExists)(path);
-            }))
-          ]);
-        case 1:
-          if (existing = _state.sent().findIndex(function(x) {
-            return !!x;
-          }), found = defaultPaths[existing], !found)
-            throw new Error("No found tamagui.config.ts");
-          return cachedPath = found, [
-            2,
-            found
-          ];
-      }
-    });
-  }), _getDefaultTamaguiConfigPath.apply(this, arguments);
+var import_path = require("path"), import_fs_extra = require("fs-extra"), cachedPath = "";
+async function getDefaultTamaguiConfigPath(param) {
+  var { cwd = ".", cache = !0 } = param;
+  if (cache && cachedPath)
+    return cachedPath;
+  var defaultPaths = [
+    "tamagui.config.ts",
+    (0, import_path.join)("src", "tamagui.config.ts")
+  ].map(function(p) {
+    return (0, import_path.join)(cwd, p);
+  }), existing = (await Promise.all(defaultPaths.map(function(path) {
+    return (0, import_fs_extra.pathExists)(path);
+  }))).findIndex(function(x) {
+    return !!x;
+  }), found = defaultPaths[existing];
+  if (!found)
+    throw new Error("No found tamagui.config.ts");
+  return cachedPath = found, found;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/getTamaguiDefaultPath.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/Users/n8/tamagui/code/core/helpers-node/src/getTamaguiDefaultPath.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,kBAAqB,iBAErB,kBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3B,IAAIA,aAAa;AAEjB,SAAsBC,4BAA4B,GAOjD;SAPqBA,6BAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,+BAAAA;AAAAA,wCAAf,oBAAA,SAA2C;oBAChDC,KAAAA,cACAC,OAUMC,cAGAC,UAGAC;;;;AAVN,8BARgD,MAChDJ,KAAAA,MAAAA,eAAAA,SAAM,MAAA,YAAA,eAD0C,MAEhDC,OAAAA,QAAAA,iBAAAA,SAAQ,KAAA,cAMJA,SAASH,aACX;;YAAOA;eAGHI,eAAe;YAAC;gBAAqBG,kBAAK,OAAO,mBAAA;YAAsBC,IAAI,SAACC,GAAAA;uBAChFF,kBAAKL,KAAKO,CAAAA;cAGV;;YAAMC,QAAQC,IAAIP,aAAaI,IAAI,SAACI,MAAAA;yBAASC,4BAAWD,IAAAA;;;;AAG1D,cAJMP,WACJ,OAAA,KAAA,EACAS,UAAU,SAACC,GAAAA;mBAAM,CAAC,CAACA;cACfT,QAAQF,aAAaC,QAAAA,GACvB,CAACC;AACH,kBAAM,IAAIU,MAAO,4BAAA;AAGnBhB,8BAAaM,OACb;;YAAOA;;;;EACT,CAAA,GAzBsBL,6BAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["cachedPath", "getDefaultTamaguiConfigPath", "cwd", "cache", "defaultPaths", "existing", "found", "join", "map", "p", "Promise", "all", "path", "pathExists", "findIndex", "x", "Error"]
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;kBAAqB,iBAErB,kBAA2B,qBAEvBA,aAAa;AAEjB,eAAsBC,4BAA4B;MAAA,EAChDC,MAAM,KACNC,QAAQ,GAAI,IAFoC;AAQhD,MAAIA,SAASH;AACX,WAAOA;AAGT,MAAMI,eAAe;IAAC;QAAqBC,kBAAK,OAAO,mBAAA;IAAsBC,IAAI,SAACC,GAAAA;eAChFF,kBAAKH,KAAKK,CAAAA;MAENC,YACJ,MAAMC,QAAQC,IAAIN,aAAaE,IAAI,SAACK,MAAAA;eAASC,4BAAWD,IAAAA;OACxDE,UAAU,SAACC,GAAAA;WAAM,CAAC,CAACA;MACfC,QAAQX,aAAaI,QAAAA;AAC3B,MAAI,CAACO;AACH,UAAM,IAAIC,MAAM,4BAA4B;AAG9ChB,sBAAae,OACNA;AACT;",
+  "names": ["cachedPath", "getDefaultTamaguiConfigPath", "cwd", "cache", "defaultPaths", "join", "map", "p", "existing", "Promise", "all", "path", "pathExists", "findIndex", "x", "found", "Error"]
 }

package/dist/getTamaguiOptions.native.js

@@ -19,139 +19,11 @@ __export(getTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(getTamaguiOptions_exports);
 var import_readTamaguiOptions = require("./readTamaguiOptions");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg), value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
-}
-function _async_to_generator(fn) {
-  return function() {
-    var self = this, args = arguments;
-    return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(void 0);
-    });
-  };
-}
-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 {
-      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
-    };
-  }
-}
-function getTamaguiOptions(_) {
-  return _getTamaguiOptions.apply(this, arguments);
-}
-function _getTamaguiOptions() {
-  return _getTamaguiOptions = _async_to_generator(function(param) {
-    var _param_cwd, cwd;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _param_cwd = param.cwd, cwd = _param_cwd === void 0 ? "." : _param_cwd, [
-            4,
-            (0, import_readTamaguiOptions.readTamaguiOptions)({
-              cwd
-            })
-          ];
-        case 1:
-          return [
-            2,
-            _state.sent().options
-          ];
-      }
-    });
-  }), _getTamaguiOptions.apply(this, arguments);
+async function getTamaguiOptions(param) {
+  var { cwd = "." } = param;
+  return (await (0, import_readTamaguiOptions.readTamaguiOptions)({
+    cwd
+  })).options;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/getTamaguiOptions.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/Users/n8/tamagui/code/core/helpers-node/src/getTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,gCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnC,SAAsBA,kBAAkB,GAA+B;SAAjDA,mBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,qBAAAA;AAAAA,8BAAf,oBAAA,SAAiC,OAA+B;oBAA7BC;;;;8BAAF,MAAEA,KAAAA,MAAAA,eAAAA,SAAM,MAAA,YACtC;;gBAAMC,8CAAmB;cAAED;YAAI,CAAA;;;AAAvC,iBAAA;;YAAQ,OAAA,KAAA,EAAmCE;;;;EAC7C,CAAA,GAFsBH,mBAAAA,MAAAA,MAAAA,SAAAA;;",
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;gCAAmC;AAEnC,eAAsBA,kBAAkB,OAA+B;MAA/B,EAAEC,MAAM,IAAG,IAAX;AACtC,UAAQ,UAAMC,8CAAmB;IAAED;EAAI,CAAA,GAAIE;AAC7C;",
   "names": ["getTamaguiOptions", "cwd", "readTamaguiOptions", "options"]
 }

package/dist/readTamaguiOptions.native.js

@@ -19,223 +19,37 @@ __export(readTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(readTamaguiOptions_exports);
 var import_path = require("path"), import_fs_extra = require("fs-extra"), import_getDefaultTamaguiOptions = require("./getDefaultTamaguiOptions");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+async function readTamaguiOptions(param) {
+  var { cwd = "." } = param, filePath = (0, import_path.join)(cwd, "tamagui.json");
+  if (!await (0, import_fs_extra.pathExists)(filePath))
+    return {
+      exists: !1,
+      options: await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
+        cwd
+      })
+    };
   try {
-    var info = gen[key](arg), value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
-}
-function _async_to_generator(fn) {
-  return function() {
-    var self = this, args = arguments;
-    return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+    var options = await (0, import_fs_extra.readJSON)(filePath);
+    if (!Array.isArray(options.components))
+      throw new Error("Invalid components: not string[]");
+    return {
+      exists: !0,
+      options: {
+        ...!options.config && await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
+          cwd
+        }),
+        ...options
       }
-      _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 _object_spread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
-    typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-    }))), ownKeys.forEach(function(key) {
-      _define_property(target, key, source[key]);
-    });
-  }
-  return target;
-}
-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 {
-      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
+  } catch (err) {
+    return console.error(`Error reading tamagui.json: ${err.message} ${err.stack}`), {
+      exists: !1,
+      options: await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
+        cwd
+      })
     };
   }
 }
-function readTamaguiOptions(_) {
-  return _readTamaguiOptions.apply(this, arguments);
-}
-function _readTamaguiOptions() {
-  return _readTamaguiOptions = _async_to_generator(function(param) {
-    var _param_cwd, cwd, filePath, _tmp, options, _tmp1, _tmp2, _tmp3, err, _tmp4;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _param_cwd = param.cwd, cwd = _param_cwd === void 0 ? "." : _param_cwd, filePath = (0, import_path.join)(cwd, "tamagui.json"), [
-            4,
-            (0, import_fs_extra.pathExists)(filePath)
-          ];
-        case 1:
-          return _state.sent() ? [
-            3,
-            3
-          ] : (_tmp = {
-            exists: !1
-          }, [
-            4,
-            (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
-              cwd
-            })
-          ]);
-        case 2:
-          return [
-            2,
-            (_tmp.options = _state.sent(), _tmp)
-          ];
-        case 3:
-          return _state.trys.push([
-            3,
-            7,
-            ,
-            9
-          ]), [
-            4,
-            (0, import_fs_extra.readJSON)(filePath)
-          ];
-        case 4:
-          if (options = _state.sent(), !Array.isArray(options.components))
-            throw new Error("Invalid components: not string[]");
-          return _tmp1 = {
-            exists: !0
-          }, _tmp2 = [
-            {}
-          ], _tmp3 = !options.config, _tmp3 ? [
-            4,
-            (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
-              cwd
-            })
-          ] : [
-            3,
-            6
-          ];
-        case 5:
-          _tmp3 = _state.sent(), _state.label = 6;
-        case 6:
-          return [
-            2,
-            (_tmp1.options = _object_spread.apply(void 0, _tmp2.concat([
-              _tmp3,
-              options
-            ])), _tmp1)
-          ];
-        case 7:
-          return err = _state.sent(), console.error("Error reading tamagui.json: ".concat(err.message, " ").concat(err.stack)), _tmp4 = {
-            exists: !1
-          }, [
-            4,
-            (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({
-              cwd
-            })
-          ];
-        case 8:
-          return [
-            2,
-            (_tmp4.options = _state.sent(), _tmp4)
-          ];
-        case 9:
-          return [
-            2
-          ];
-      }
-    });
-  }), _readTamaguiOptions.apply(this, arguments);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   readTamaguiOptions

package/dist/readTamaguiOptions.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/Users/n8/tamagui/code/core/helpers-node/src/readTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,kBAAqB,iBAGrB,kBAAqC,qBAErC,kCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzC,SAAsBA,mBAAmB,GAA8B;SAAjDA,oBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,sBAAAA;AAAAA,+BAAf,oBAAA,SAAkC,OAA8B;oBAA5BC,KACnCC,UAAAA,MAUEC,SAAAA,OAAAA,OAAAA,OAaCC,KAAAA;;;;8BAxB8B,MAAEH,KAAAA,MAAAA,eAAAA,SAAM,MAAA,YACzCC,eAAWG,kBAAKJ,KAAK,cAAA,GAErB;;gBAAMK,4BAAWJ,QAAAA;;;iBAAjB,OAAA,KAAA,IAAF;;;;YAEAK,QAAQ;aACC;;gBAAMC,0DAAyB;cAAEP;YAAI,CAAA;;;AAFhD,iBAAA;;kBAEEE,UAAS,OAAA,KAAA,GAAA;;;;;;;;cAKM;;gBAAMM,0BAASP,QAAAA;;;AAEhC,cAFMC,UAAW,OAAA,KAAA,GAEb,CAACO,MAAMC,QAAQR,QAAQS,UAAU;AACnC,kBAAM,IAAIC,MAAO,kCAAA;;YAIjBN,QAAQ;;;qBAEF,CAACJ,QAAQW,gBAAW;;gBAAMN,0DAAyB;cAAEP;YAAI,CAAA;cAAzD;;;;;kBAAoB,OAAA,KAAA;;AAH5B,iBAAA;;mBAEEE,UAAS,eAAA,MAAA,QAAA,MAAA,OAAA;;cAEJA;;;;AAGAC,uBAAAA,OAAAA,KAAAA,GACPW,QAAQC,MAAO,+BAA6CZ,OAAfA,IAAIa,SAAQ,GAAA,EAAa,OAAVb,IAAIc,KAAK,CAAA;YAGnEX,QAAQ;aACC;;gBAAMC,0DAAyB;cAAEP;YAAI,CAAA;;;AAFhD,iBAAA;;mBAEEE,UAAS,OAAA,KAAA,GAAA;;;;;;;;EAGf,CAAA,GAhCsBH,oBAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["readTamaguiOptions", "cwd", "filePath", "options", "err", "join", "pathExists", "exists", "getDefaultTamaguiOptions", "readJSON", "Array", "isArray", "components", "Error", "config", "console", "error", "message", "stack"]
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;kBAAqB,iBAGrB,kBAAqC,qBAErC,kCAAyC;AAEzC,eAAsBA,mBAAmB,OAA8B;MAA9B,EAAEC,MAAM,IAAG,IAAX,OACjCC,eAAWC,kBAAKF,KAAK,cAAA;AAE3B,MAAI,CAAE,UAAMG,4BAAWF,QAAAA;AACrB,WAAO;MACLG,QAAQ;MACRC,SAAS,UAAMC,0DAAyB;QAAEN;MAAI,CAAA;IAChD;AAGF,MAAI;AACF,QAAMK,UAAW,UAAME,0BAASN,QAAAA;AAEhC,QAAI,CAACO,MAAMC,QAAQJ,QAAQK,UAAU;AACnC,YAAM,IAAIC,MAAM,kCAAkC;AAGpD,WAAO;MACLP,QAAQ;MACRC,SAAS;QACP,GAAI,CAACA,QAAQO,UAAW,UAAMN,0DAAyB;UAAEN;QAAI,CAAA;QAC7D,GAAGK;MACL;IACF;EACF,SAASQ,KAAU;AACjBC,mBAAQC,MAAM,+BAA+BF,IAAIG,OAAO,IAAIH,IAAII,KAAK,EAAE,GAEhE;MACLb,QAAQ;MACRC,SAAS,UAAMC,0DAAyB;QAAEN;MAAI,CAAA;IAChD;EACF;AACF;",
+  "names": ["readTamaguiOptions", "cwd", "filePath", "join", "pathExists", "exists", "options", "getDefaultTamaguiOptions", "readJSON", "Array", "isArray", "components", "Error", "config", "err", "console", "error", "message", "stack"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/helpers-node",
-  "version": "1.110.5",
+  "version": "1.111.1",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "./dist",
@@ -16,10 +16,10 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/types": "1.110.5"
+    "@tamagui/types": "1.111.1"
   },
   "devDependencies": {
-    "@tamagui/build": "1.110.5",
+    "@tamagui/build": "1.111.1",
     "fs-extra": "^11.2.0"
   },
   "publishConfig": {