@tamagui/helpers-node 1.89.25 → 1.89.27-1708112217600

package/dist/getDefaultTamaguiOptions.native.js

@@ -19,14 +19,149 @@ __export(getDefaultTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(getDefaultTamaguiOptions_exports);
 var import_getTamaguiDefaultPath = require("./getTamaguiDefaultPath");
-async function getDefaultTamaguiOptions({
-  cwd = "."
-}) {
-  return {
-    platform: "native",
-    components: ["tamagui"],
-    config: await (0, import_getTamaguiDefaultPath.getDefaultTamaguiConfigPath)({ cwd })
+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 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/getDefaultTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mCAA4C;AAE5C,eAAsB,yBAAyB;AAAA,EAC7C,MAAM;AACR,GAE4B;AAC1B,SAAO;AAAA,IACL,UAAU;AAAA,IACV,YAAY,CAAC,SAAS;AAAA,IACtB,QAAQ,UAAM,0DAA4B,EAAE,IAAI,CAAC;AAAA,EACnD;AACF;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/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"]
 }

package/dist/getTamaguiDefaultPath.native.js

@@ -19,19 +19,157 @@ __export(getTamaguiDefaultPath_exports, {
 });
 module.exports = __toCommonJS(getTamaguiDefaultPath_exports);
 var import_path = require("path"), import_fs_extra = require("fs-extra");
-let cachedPath = "";
-async function getDefaultTamaguiConfigPath({
-  cwd = ".",
-  cache = !0
-}) {
-  if (cache && cachedPath)
-    return cachedPath;
-  const defaultPaths = ["tamagui.config.ts", (0, import_path.join)("src", "tamagui.config.ts")].map(
-    (p) => (0, import_path.join)(cwd, p)
-  ), existing = (await Promise.all(defaultPaths.map((path) => (0, import_fs_extra.pathExists)(path)))).findIndex((x) => !!x), found = defaultPaths[existing];
-  if (!found)
-    throw new Error("No found tamagui.config.ts");
-  return cachedPath = found, found;
+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);
 }
 // 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/getTamaguiDefaultPath.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB,iBAErB,kBAA2B;AAE3B,IAAI,aAAa;AAEjB,eAAsB,4BAA4B;AAAA,EAChD,MAAM;AAAA,EACN,QAAQ;AACV,GAIG;AACD,MAAI,SAAS;AACX,WAAO;AAGT,QAAM,eAAe,CAAC,yBAAqB,kBAAK,OAAO,mBAAmB,CAAC,EAAE;AAAA,IAAI,CAAC,UAChF,kBAAK,KAAK,CAAC;AAAA,EACb,GACM,YACJ,MAAM,QAAQ,IAAI,aAAa,IAAI,CAAC,aAAS,4BAAW,IAAI,CAAC,CAAC,GAC9D,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAChB,QAAQ,aAAa,QAAQ;AACnC,MAAI,CAAC;AACH,UAAM,IAAI,MAAM,4BAA4B;AAG9C,sBAAa,OACN;AACT;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/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,OAOjD;oBANCC,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"]
 }

package/dist/getTamaguiOptions.native.js

@@ -19,8 +19,144 @@ __export(getTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(getTamaguiOptions_exports);
 var import_readTamaguiOptions = require("./readTamaguiOptions");
-async function getTamaguiOptions({ cwd = "." }) {
-  return (await (0, import_readTamaguiOptions.readTamaguiOptions)({ cwd })).options;
+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);
 }
 // 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/getTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAAmC;AAEnC,eAAsB,kBAAkB,EAAE,MAAM,IAAI,GAAqB;AACvE,UAAQ,UAAM,8CAAmB,EAAE,IAAI,CAAC,GAAG;AAC7C;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/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;;",
+  "names": ["getTamaguiOptions", "cwd", "readTamaguiOptions", "options"]
 }

package/dist/index.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/index.ts"],
-  "mappings": ";;;;;;;;;;;;AAAA;AAAA;AAAA,wBAAc,iCAAd;AACA,wBAAc,oCADd;AAEA,wBAAc,gCAFd;",
+  "sources": ["../src/Users/n8/tamagui/packages/helpers-node/src/index.ts"],
+  "mappings": ";;;;;;;;;;;;AAAA;;wBAAc,iCAAd;AACA,wBAAc,oCADd;AAEA,wBAAc,gCAFd;",
   "names": []
 }

package/dist/readTamaguiOptions.native.js

@@ -19,31 +19,228 @@ __export(readTamaguiOptions_exports, {
 });
 module.exports = __toCommonJS(readTamaguiOptions_exports);
 var import_path = require("path"), import_fs_extra = require("fs-extra"), import_getDefaultTamaguiOptions = require("./getDefaultTamaguiOptions");
-async function readTamaguiOptions({ cwd = "." }) {
-  const 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 })
-    };
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
-    const 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
+    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 _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
+      ]);
     };
-  } catch (err) {
-    return console.error(`Error reading tamagui.json: ${err.message} ${err.stack}`), {
-      exists: !1,
-      options: await (0, import_getDefaultTamaguiOptions.getDefaultTamaguiOptions)({ cwd })
+  }
+  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 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/readTamaguiOptions.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB,iBAGrB,kBAAqC,qBAErC,kCAAyC;AAEzC,eAAsB,mBAAmB,EAAE,MAAM,IAAI,GAAoB;AACvE,QAAM,eAAW,kBAAK,KAAK,cAAc;AAEzC,MAAI,CAAE,UAAM,4BAAW,QAAQ;AAC7B,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,IACjD;AAGF,MAAI;AACF,UAAM,UAAW,UAAM,0BAAS,QAAQ;AAExC,QAAI,CAAC,MAAM,QAAQ,QAAQ,UAAU;AACnC,YAAM,IAAI,MAAM,kCAAkC;AAGpD,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS;AAAA,QACP,GAAI,CAAC,QAAQ,UAAW,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,QAC9D,GAAG;AAAA,MACL;AAAA,IACF;AAAA,EACF,SAAS,KAAU;AACjB,mBAAQ,MAAM,+BAA+B,IAAI,OAAO,IAAI,IAAI,KAAK,EAAE,GAEhE;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,UAAM,0DAAyB,EAAE,IAAI,CAAC;AAAA,IACjD;AAAA,EACF;AACF;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/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"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/helpers-node",
-  "version": "1.89.25",
+  "version": "1.89.27-1708112217600",
   "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.89.25"
+    "@tamagui/types": "1.89.27-1708112217600"
   },
   "devDependencies": {
-    "@tamagui/build": "1.89.25",
+    "@tamagui/build": "1.89.27-1708112217600",
     "fs-extra": "^11.2.0"
   },
   "publishConfig": {