@tamagui/cli 1.89.26 → 1.89.27-1708112217600

package/dist/update.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/update.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,SAAS,YAAY;AAElC;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/cli/src/update.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,IAAMA,SAAAA,WAAAA;aAAS,oBAAA,WAAA;;;;;;EAEtB,CAAA;oBAFaA;;;;",
+  "names": ["update"]
 }

package/dist/utils.native.js

@@ -31,71 +31,290 @@ __export(utils_exports, {
 });
 module.exports = __toCommonJS(utils_exports);
 var import_path = require("path"), import_static = require("@tamagui/static"), import_chalk = __toESM(require("chalk")), import_fs_extra = __toESM(require("fs-extra"));
-async function getOptions({
-  root = process.cwd(),
-  tsconfigPath = "tsconfig.json",
-  tamaguiOptions,
-  host,
-  debug,
-  loadTamaguiOptions
-} = {}) {
-  root.includes("tamagui/apps/studio") && (console.info("Running in studio mode, loading the site config"), root = root.replace("apps/studio", "apps/site"));
-  const tsConfigFilePath = (0, import_path.join)(root, tsconfigPath);
-  ensure(await import_fs_extra.default.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`);
-  const dotDir = (0, import_path.join)(root, ".tamagui");
-  let pkgJson = {}, config = "";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
-    config = await getDefaultTamaguiConfigPath(), pkgJson = await (0, import_fs_extra.readJSON)((0, import_path.join)(root, "package.json"));
-  } catch {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
   }
-  const 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: {
-      dotDir,
-      conf: (0, import_path.join)(dotDir, "tamagui.config.json"),
-      types: (0, import_path.join)(dotDir, "types.json")
-    }
+  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
+      ]);
+    };
+  }
+  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 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, root.includes("tamagui/apps/studio") && (console.info("Running in studio mode, loading the site config"), root = root.replace("apps/studio", "apps/site")), tsConfigFilePath = (0, import_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_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_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: {
+                dotDir,
+                conf: (0, import_path.join)(dotDir, "tamagui.config.json"),
+                types: (0, import_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(`${message}`)), process.exit(1));
+  condition || (console.error(import_chalk.default.red.bold("Error:"), import_chalk.default.yellow("".concat(message))), process.exit(1));
 }
-const defaultPaths = ["tamagui.config.ts", (0, import_path.join)("src", "tamagui.config.ts")];
-let cachedPath = "";
-async function getDefaultTamaguiConfigPath() {
-  if (cachedPath)
-    return cachedPath;
-  const 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;
+var defaultPaths = [
+  "tamagui.config.ts",
+  (0, import_path.join)("src", "tamagui.config.ts")
+], cachedPath = "";
+function getDefaultTamaguiConfigPath() {
+  return _getDefaultTamaguiConfigPath.apply(this, arguments);
 }
-let cached = null;
-const loadTamagui = async (opts) => {
-  const loaded = await (0, import_static.loadTamagui)({
-    config: await getDefaultTamaguiConfigPath(),
-    components: ["tamagui"],
-    ...opts
+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 cached = null, loadTamagui = function() {
+  var _ref = _async_to_generator(function(opts) {
+    var loaded, _tmp;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return _tmp = {}, [
+            4,
+            getDefaultTamaguiConfigPath()
+          ];
+        case 1:
+          return [
+            4,
+            import_static.loadTamagui.apply(void 0, [
+              _object_spread.apply(void 0, [
+                (_tmp.config = _state.sent(), _tmp.components = [
+                  "tamagui"
+                ], _tmp),
+                opts
+              ])
+            ])
+          ];
+        case 2:
+          return loaded = _state.sent(), loaded && (cached = loaded), [
+            2,
+            loaded
+          ];
+      }
+    });
   });
-  return loaded && (cached = loaded), loaded;
-}, disposers = /* @__PURE__ */ new Set();
+  return function(opts) {
+    return _ref.apply(this, arguments);
+  };
+}(), disposers = /* @__PURE__ */ new Set();
 function registerDispose(cb) {
   disposers.add(cb);
 }
 function disposeAll() {
-  disposers.forEach((cb) => cb());
+  disposers.forEach(function(cb) {
+    return cb();
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/utils.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/utils.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB,iBAGrB,gBAGO,4BAEP,eAAkB,2BAClB,kBAAyC;AAEzC,eAAsB,WAAW;AAAA,EAC/B,OAAO,QAAQ,IAAI;AAAA,EACnB,eAAe;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,IAA6B,CAAC,GAAgC;AAE5D,EAAI,KAAK,SAAS,qBAAqB,MACrC,QAAQ,KAAK,iDAAiD,GAC9D,OAAO,KAAK,QAAQ,eAAe,WAAW;AAGhD,QAAM,uBAAmB,kBAAK,MAAM,YAAY;AAChD,SAAO,MAAM,gBAAAA,QAAG,WAAW,gBAAgB,GAAG,sBAAsB,gBAAgB,EAAE;AACtF,QAAM,aAAS,kBAAK,MAAM,UAAU;AACpC,MAAI,UAAU,CAAC,GACX,SAAS;AACb,MAAI;AACF,aAAS,MAAM,4BAA4B,GAC3C,UAAU,UAAM,8BAAS,kBAAK,MAAM,cAAc,CAAC;AAAA,EACrD,QAAQ;AAAA,EAER;AAEA,QAAM,gBAAgB;AAAA,IACpB,UAAU;AAAA,IACV,YAAY,CAAC,SAAS;AAAA,IACtB;AAAA,IACA,GAAG;AAAA,EACL,GAEM,eAAe,yBACjB,0CAA2B,aAAa,IACxC;AAEJ,SAAO;AAAA,IACL,MAAM,QAAQ,IAAI,aAAa,eAAe,eAAe;AAAA,IAC7D;AAAA,IACA,MAAM,QAAQ;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,IAChB,OAAO;AAAA,MACL;AAAA,MACA,UAAM,kBAAK,QAAQ,qBAAqB;AAAA,MACxC,WAAO,kBAAK,QAAQ,YAAY;AAAA,IAClC;AAAA,EACF;AACF;AAEO,SAAS,OAAO,WAAoB,SAAiB;AAC1D,EAAK,cACH,QAAQ,MAAM,aAAAC,QAAM,IAAI,KAAK,QAAQ,GAAG,aAAAA,QAAM,OAAO,GAAG,OAAO,EAAE,CAAC,GAClE,QAAQ,KAAK,CAAC;AAElB;AAEA,MAAM,eAAe,CAAC,yBAAqB,kBAAK,OAAO,mBAAmB,CAAC;AAC3E,IAAI,aAAa;AACjB,eAAe,8BAA8B;AAC3C,MAAI;AAAY,WAAO;AAEvB,QAAM,YADgB,MAAM,QAAQ,IAAI,aAAa,IAAI,CAAC,aAAS,4BAAW,IAAI,CAAC,CAAC,GACrD,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAC7C,QAAQ,aAAa,QAAQ;AACnC,MAAI,CAAC;AACH,UAAM,IAAI,MAAM,4BAA4B;AAE9C,sBAAa,OACN;AACT;AAEA,IAAI,SAAoC;AACjC,MAAM,cAAc,OACzB,SACuC;AACvC,QAAM,SAAS,UAAM,cAAAC,aAAkB;AAAA,IACrC,QAAQ,MAAM,4BAA4B;AAAA,IAC1C,YAAY,CAAC,SAAS;AAAA,IACtB,GAAG;AAAA,EACL,CAAC;AACD,SAAI,WACF,SAAS,SAEJ;AACT,GAEM,YAAY,oBAAI,IAAc;AAE7B,SAAS,gBAAgB,IAAgB;AAC9C,YAAU,IAAI,EAAE;AAClB;AAEO,SAAS,aAAa;AAC3B,YAAU,QAAQ,CAAC,OAAO,GAAG,CAAC;AAChC;",
-  "names": ["fs", "chalk", "loadTamaguiStatic"]
+  "sources": ["../src/Users/n8/tamagui/packages/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", "includes", "console", "info", "replace", "join", "fs", "pathExists", "ensure", "getDefaultTamaguiConfigPath", "readJSON", "platform", "components", "loadTamaguiBuildConfigSync", "mode", "env", "NODE_ENV", "paths", "conf", "types", "condition", "message", "error", "chalk", "red", "bold", "yellow", "exit", "defaultPaths", "cachedPath", "existingPaths", "existing", "found", "Promise", "all", "map", "path", "findIndex", "x", "Error", "cached", "loadTamagui", "opts", "loaded", "loadTamaguiStatic", "disposers", "Set", "registerDispose", "cb", "add", "disposeAll", "forEach"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/cli",
-  "version": "1.89.26",
+  "version": "1.89.27-1708112217600",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist",
@@ -23,12 +23,12 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/build": "1.89.26",
-    "@tamagui/create-theme": "1.89.26",
-    "@tamagui/generate-themes": "1.89.26",
-    "@tamagui/static": "1.89.26",
-    "@tamagui/types": "1.89.26",
-    "@tamagui/vite-plugin": "1.89.26",
+    "@tamagui/build": "1.89.27-1708112217600",
+    "@tamagui/create-theme": "1.89.27-1708112217600",
+    "@tamagui/generate-themes": "1.89.27-1708112217600",
+    "@tamagui/static": "1.89.27-1708112217600",
+    "@tamagui/types": "1.89.27-1708112217600",
+    "@tamagui/vite-plugin": "1.89.27-1708112217600",
     "@vitejs/plugin-react-swc": "^3.4.0",
     "arg": "^5.0.2",
     "chalk": "^4.1.2",