@tamagui/cli 1.110.4 → 1.111.0

package/dist/utils.native.js

@@ -31,307 +31,66 @@ __export(utils_exports, {
 });
 module.exports = __toCommonJS(utils_exports);
 var import_static = require("@tamagui/static"), import_chalk = __toESM(require("chalk")), import_fs_extra = __toESM(require("fs-extra")), import_node_path = require("node:path");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+async function getOptions() {
+  var { root = process.cwd(), tsconfigPath = "tsconfig.json", tamaguiOptions, host, debug, loadTamaguiOptions } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, tsConfigFilePath = (0, import_node_path.join)(root, tsconfigPath);
+  ensure(await import_fs_extra.default.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`);
+  var dotDir = (0, import_node_path.join)(root, ".tamagui"), pkgJson = {}, config = "";
   try {
-    var info = gen[key](arg), value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
+    config = await getDefaultTamaguiConfigPath(), pkgJson = await (0, import_fs_extra.readJSON)((0, import_node_path.join)(root, "package.json"));
+  } catch {
   }
-  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] : {}, 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 _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;
+  var filledOptions = {
+    platform: "native",
+    components: [
+      "tamagui"
+    ],
+    config,
+    ...tamaguiOptions
+  }, finalOptions = loadTamaguiOptions ? (0, import_static.loadTamaguiBuildConfigSync)(filledOptions) : filledOptions;
+  return {
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    root,
+    host: host || "127.0.0.1",
+    pkgJson,
+    debug,
+    tsconfigPath,
+    tamaguiOptions: finalOptions,
+    paths: {
+      root,
+      dotDir,
+      conf: (0, import_node_path.join)(dotDir, "tamagui.config.json"),
+      types: (0, import_node_path.join)(dotDir, "types.json")
     }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: !0
-    };
-  }
-}
-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, loadTamaguiOptions, tsConfigFilePath, dotDir, pkgJson, config, e, filledOptions, finalOptions, _arguments = arguments;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _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, loadTamaguiOptions = _ref.loadTamaguiOptions, tsConfigFilePath = (0, import_node_path.join)(root, tsconfigPath), [
-            4,
-            import_fs_extra.default.pathExists(tsConfigFilePath)
-          ];
-        case 1:
-          ensure.apply(void 0, [
-            _state.sent(),
-            "No tsconfig found: ".concat(tsConfigFilePath)
-          ]), dotDir = (0, import_node_path.join)(root, ".tamagui"), pkgJson = {}, config = "", _state.label = 2;
-        case 2:
-          return _state.trys.push([
-            2,
-            5,
-            ,
-            6
-          ]), [
-            4,
-            getDefaultTamaguiConfigPath()
-          ];
-        case 3:
-          return config = _state.sent(), [
-            4,
-            (0, import_fs_extra.readJSON)((0, import_node_path.join)(root, "package.json"))
-          ];
-        case 4:
-          return pkgJson = _state.sent(), [
-            3,
-            6
-          ];
-        case 5:
-          return e = _state.sent(), [
-            3,
-            6
-          ];
-        case 6:
-          return filledOptions = _object_spread({
-            platform: "native",
-            components: [
-              "tamagui"
-            ],
-            config
-          }, tamaguiOptions), finalOptions = loadTamaguiOptions ? (0, import_static.loadTamaguiBuildConfigSync)(filledOptions) : filledOptions, [
-            2,
-            {
-              mode: process.env.NODE_ENV === "production" ? "production" : "development",
-              root,
-              host: host || "127.0.0.1",
-              pkgJson,
-              debug,
-              tsconfigPath,
-              tamaguiOptions: finalOptions,
-              paths: {
-                root,
-                dotDir,
-                conf: (0, import_node_path.join)(dotDir, "tamagui.config.json"),
-                types: (0, import_node_path.join)(dotDir, "types.json")
-              }
-            }
-          ];
-      }
-    });
-  }), _getOptions.apply(this, arguments);
+  };
 }
 function ensure(condition, message) {
-  condition || (console.error(import_chalk.default.red.bold("Error:"), import_chalk.default.yellow("".concat(message))), process.exit(1));
+  condition || (console.error(import_chalk.default.red.bold("Error:"), import_chalk.default.yellow(`${message}`)), process.exit(1));
 }
 var defaultPaths = [
   "tamagui.config.ts",
   (0, import_node_path.join)("src", "tamagui.config.ts")
 ], cachedPath = "";
-function getDefaultTamaguiConfigPath() {
-  return _getDefaultTamaguiConfigPath.apply(this, arguments);
+async function getDefaultTamaguiConfigPath() {
+  if (cachedPath) return cachedPath;
+  var existingPaths = await Promise.all(defaultPaths.map(function(path) {
+    return (0, import_fs_extra.pathExists)(path);
+  })), existing = existingPaths.findIndex(function(x) {
+    return !!x;
+  }), found = defaultPaths[existing];
+  if (!found)
+    throw new Error("No found tamagui.config.ts");
+  return cachedPath = found, found;
 }
-function _getDefaultTamaguiConfigPath() {
-  return _getDefaultTamaguiConfigPath = _async_to_generator(function() {
-    var existingPaths, existing, found;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return cachedPath ? [
-            2,
-            cachedPath
-          ] : [
-            4,
-            Promise.all(defaultPaths.map(function(path) {
-              return (0, import_fs_extra.pathExists)(path);
-            }))
-          ];
-        case 1:
-          if (existingPaths = _state.sent(), existing = existingPaths.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 loadTamagui = /* @__PURE__ */ function() {
-  var _ref = _async_to_generator(function(opts) {
-    var _opts_config, loaded, _tmp, _tmp1, _tmp2;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return _tmp = [
-            _object_spread({
-              components: [
-                "tamagui"
-              ]
-            }, opts)
-          ], _tmp1 = {}, (_opts_config = opts.config) !== null && _opts_config !== void 0 ? (_tmp2 = _opts_config, [
-            3,
-            3
-          ]) : [
-            3,
-            1
-          ];
-        case 1:
-          return [
-            4,
-            getDefaultTamaguiConfigPath()
-          ];
-        case 2:
-          _tmp2 = _state.sent(), _state.label = 3;
-        case 3:
-          return [
-            4,
-            import_static.loadTamagui.apply(void 0, [
-              _object_spread_props.apply(void 0, _tmp.concat([
-                (_tmp1.config = _tmp2, _tmp1)
-              ]))
-            ])
-          ];
-        case 4:
-          return loaded = _state.sent(), [
-            2,
-            loaded
-          ];
-      }
-    });
+var loadTamagui = async function(opts) {
+  var _opts_config, loaded = await (0, import_static.loadTamagui)({
+    components: [
+      "tamagui"
+    ],
+    ...opts,
+    config: (_opts_config = opts.config) !== null && _opts_config !== void 0 ? _opts_config : await getDefaultTamaguiConfigPath()
   });
-  return function(opts) {
-    return _ref.apply(this, arguments);
-  };
-}(), disposers = /* @__PURE__ */ new Set();
+  return loaded;
+}, disposers = /* @__PURE__ */ new Set();
 function registerDispose(cb) {
   disposers.add(cb);
 }

package/dist/utils.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/Users/n8/tamagui/code/core/cli/src/utils.ts"],
-  "mappings": "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",
-  "names": ["getOptions", "root", "tsconfigPath", "tamaguiOptions", "host", "debug", "loadTamaguiOptions", "tsConfigFilePath", "dotDir", "pkgJson", "config", "filledOptions", "finalOptions", "process", "cwd", "join", "fs", "pathExists", "ensure", "getDefaultTamaguiConfigPath", "readJSON", "platform", "components", "loadTamaguiBuildConfigSync", "mode", "env", "NODE_ENV", "paths", "conf", "types", "condition", "message", "console", "error", "chalk", "red", "bold", "yellow", "exit", "defaultPaths", "cachedPath", "existingPaths", "existing", "found", "Promise", "all", "map", "path", "findIndex", "x", "Error", "loadTamagui", "opts", "loaded", "loadTamaguiStatic", "disposers", "Set", "registerDispose", "cb", "add", "disposeAll", "forEach"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AACA;;;;;;;;;oBAGO,4BAEP,eAAkB,2BAClB,kBAAyC,8BACzC,mBAAqB;AAErB,eAAsBA,aAAAA;MAAW,EAC/BC,OAAOC,QAAQC,IAAG,GAClBC,eAAe,iBACfC,gBACAC,MACAC,OACAC,mBAAkB,IANa,UAAA,SAAA,KAAA,UAAA,CAAA,MAAA,SAAA,UAAA,CAAA,IAOJ,CAAC,GACtBC,uBAAmBC,uBAAKT,MAAMG,YAAAA;AACpCO,SAAO,MAAMC,gBAAAA,QAAGC,WAAWJ,gBAAAA,GAAmB,sBAAsBA,gBAAAA,EAAkB;AACtF,MAAMK,aAASJ,uBAAKT,MAAM,UAAA,GACtBc,UAAU,CAAC,GACXC,SAAS;AACb,MAAI;AACFA,aAAS,MAAMC,4BAAAA,GACfF,UAAU,UAAMG,8BAASR,uBAAKT,MAAM,cAAA,CAAA;EACtC,QAAQ;EAER;AAEA,MAAMkB,gBAAgB;IACpBC,UAAU;IACVC,YAAY;MAAC;;IACbL;IACA,GAAGX;EACL,GAEMiB,eAAed,yBACjBe,0CAA2BJ,aAAAA,IAC3BA;AAEJ,SAAO;IACLK,MAAMtB,QAAQuB,IAAIC,aAAa,eAAe,eAAe;IAC7DzB;IACAK,MAAMA,QAAQ;IACdS;IACAR;IACAH;IACAC,gBAAgBiB;IAChBK,OAAO;MACL1B;MACAa;MACAc,UAAMlB,uBAAKI,QAAQ,qBAAA;MACnBe,WAAOnB,uBAAKI,QAAQ,YAAA;IACtB;EACF;AACF;AAEO,SAASH,OAAOmB,WAAoBC,SAAe;AACxD,EAAKD,cACHE,QAAQC,MAAMC,aAAAA,QAAMC,IAAIC,KAAK,QAAA,GAAWF,aAAAA,QAAMG,OAAO,GAAGN,OAAAA,EAAS,CAAA,GACjE7B,QAAQoC,KAAK,CAAA;AAEjB;AAEA,IAAMC,eAAe;EAAC;MAAqB7B,uBAAK,OAAO,mBAAA;GACnD8B,aAAa;AAEjB,eAAevB,8BAAAA;AACb,MAAIuB,WAAY,QAAOA;AACvB,MAAMC,gBAAgB,MAAMC,QAAQC,IAAIJ,aAAaK,IAAI,SAACC,MAAAA;eAAShC,4BAAWgC,IAAAA;OACxEC,WAAWL,cAAcM,UAAU,SAACC,GAAAA;WAAM,CAAC,CAACA;MAC5CC,QAAQV,aAAaO,QAAAA;AAC3B,MAAI,CAACG;AACH,UAAM,IAAIC,MAAM,4BAA4B;AAE9CV,sBAAaS,OACNA;AACT;AAEO,IAAME,cAAc,eACzBC,MAAAA;MAKUA,cAHJC,SAAS,UAAMC,cAAAA,aAAkB;IACrCjC,YAAY;MAAC;;IACb,GAAG+B;IACHpC,SAAQoC,eAAAA,KAAKpC,YAAM,QAAXoC,iBAAAA,SAAAA,eAAgB,MAAMnC,4BAAAA;EAChC,CAAA;AACA,SAAOoC;AACT,GAEME,YAAY,oBAAIC,IAAAA;AAEf,SAASC,gBAAgBC,IAAc;AAC5CH,YAAUI,IAAID,EAAAA;AAChB;AAEO,SAASE,aAAAA;AACdL,YAAUM,QAAQ,SAACH,IAAAA;WAAOA,GAAAA;;AAC5B;",
+  "names": ["getOptions", "root", "process", "cwd", "tsconfigPath", "tamaguiOptions", "host", "debug", "loadTamaguiOptions", "tsConfigFilePath", "join", "ensure", "fs", "pathExists", "dotDir", "pkgJson", "config", "getDefaultTamaguiConfigPath", "readJSON", "filledOptions", "platform", "components", "finalOptions", "loadTamaguiBuildConfigSync", "mode", "env", "NODE_ENV", "paths", "conf", "types", "condition", "message", "console", "error", "chalk", "red", "bold", "yellow", "exit", "defaultPaths", "cachedPath", "existingPaths", "Promise", "all", "map", "path", "existing", "findIndex", "x", "found", "Error", "loadTamagui", "opts", "loaded", "loadTamaguiStatic", "disposers", "Set", "registerDispose", "cb", "add", "disposeAll", "forEach"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/cli",
-  "version": "1.110.4",
+  "version": "1.111.0",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist",
@@ -23,11 +23,11 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/create-theme": "1.110.4",
-    "@tamagui/generate-themes": "1.110.4",
-    "@tamagui/static": "1.110.4",
-    "@tamagui/types": "1.110.4",
-    "@tamagui/vite-plugin": "1.110.4",
+    "@tamagui/create-theme": "1.111.0",
+    "@tamagui/generate-themes": "1.111.0",
+    "@tamagui/static": "1.111.0",
+    "@tamagui/types": "1.111.0",
+    "@tamagui/vite-plugin": "1.111.0",
     "@vitejs/plugin-react-swc": "^3.7.0",
     "arg": "^5.0.2",
     "chalk": "^4.1.2",
@@ -55,7 +55,7 @@
     "vite-plugin-entry-shaking": "^0.4.3"
   },
   "devDependencies": {
-    "@tamagui/build": "1.110.4",
+    "@tamagui/build": "1.111.0",
     "@types/chokidar": "^2.1.3",
     "@types/marked": "^5.0.0"
   }