@tamagui/cli 1.89.26 → 1.89.27-1708112217600

package/dist/cli.native.js

@@ -19,12 +19,244 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var import_arg = __toESM(require("arg")), import_chalk = __toESM(require("chalk")), import_add = require("./add.js"), import_utils = require("./utils"), import_static = require("@tamagui/static");
-["exit", "SIGINT"].forEach((_) => {
-  process.on(_, () => {
+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_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg2) {
+  try {
+    var info = gen[key](arg2), 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 _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+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 {
+        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
+    };
+  }
+}
+[
+  "exit",
+  "SIGINT"
+].forEach(function(_) {
+  process.on(_, function() {
     (0, import_utils.disposeAll)(), process.exit();
   });
 });
-const COMMAND_MAP = {
+var COMMAND_MAP = {
   generate: {
     description: "Builds your entire tamagui configuration and outputs any CSS.",
     shorthands: [],
@@ -33,57 +265,127 @@ const COMMAND_MAP = {
       "--debug": Boolean,
       "--verbose": Boolean
     },
-    async run() {
-      const { _, ...flags2 } = (0, import_arg.default)(this.flags), options = await (0, import_utils.getOptions)({
-        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
-        loadTamaguiOptions: !0
-      });
-      process.env.TAMAGUI_KEEP_THEMES = "1", await (0, import_static.loadTamagui)({
-        ...options.tamaguiOptions,
-        platform: "web"
-      });
+    run: function() {
+      return _async_to_generator(function() {
+        var _arg2, _, flags2, options;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return _arg2 = (0, import_arg.default)(this.flags), _ = _arg2._, flags2 = _object_without_properties(_arg2, [
+                "_"
+              ]), [
+                4,
+                (0, import_utils.getOptions)({
+                  debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
+                  loadTamaguiOptions: !0
+                })
+              ];
+            case 1:
+              return options = _state.sent(), process.env.TAMAGUI_KEEP_THEMES = "1", [
+                4,
+                (0, import_static.loadTamagui)(_object_spread_props(_object_spread({}, options.tamaguiOptions), {
+                  platform: "web"
+                }))
+              ];
+            case 2:
+              return _state.sent(), [
+                2
+              ];
+          }
+        });
+      }).apply(this);
     }
   },
   "generate-themes": {
-    shorthands: ["gt"],
+    shorthands: [
+      "gt"
+    ],
     description: "Use to pre-build your themes",
     flags: {
       "--help": Boolean,
       "--debug": Boolean,
       "--verbose": Boolean
     },
-    async run() {
-      const { _, ...flags2 } = (0, import_arg.default)(this.flags), options = await (0, import_utils.getOptions)({
-        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
-      }), [_cmd, inPath, outPath] = _;
-      if (!inPath || !outPath)
-        throw new Error(
-          `Must supply both input and output paths, missing one (inPath: ${inPath}, outPath: ${outPath})`
-        );
-      const { generateThemes, writeGeneratedThemes } = require("@tamagui/generate-themes");
-      try {
-        const generated = await generateThemes(inPath);
-        await writeGeneratedThemes(options.paths.dotDir, outPath, generated);
-      } catch (err) {
-        console.error(`Error generating themes: ${err}`);
-        return;
-      }
-      console.info(`Successfully generated themes to ${outPath}`);
+    run: function() {
+      return _async_to_generator(function() {
+        var _arg2, _, flags2, options, _1, _cmd, inPath, outPath, _require, generateThemes, writeGeneratedThemes, generated, err;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return _arg2 = (0, import_arg.default)(this.flags), _ = _arg2._, flags2 = _object_without_properties(_arg2, [
+                "_"
+              ]), [
+                4,
+                (0, import_utils.getOptions)({
+                  debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
+                })
+              ];
+            case 1:
+              if (options = _state.sent(), _1 = _sliced_to_array(_, 3), _cmd = _1[0], inPath = _1[1], outPath = _1[2], !inPath || !outPath)
+                throw new Error("Must supply both input and output paths, missing one (inPath: ".concat(inPath, ", outPath: ").concat(outPath, ")"));
+              _require = require("@tamagui/generate-themes"), generateThemes = _require.generateThemes, writeGeneratedThemes = _require.writeGeneratedThemes, _state.label = 2;
+            case 2:
+              return _state.trys.push([
+                2,
+                5,
+                ,
+                6
+              ]), [
+                4,
+                generateThemes(inPath)
+              ];
+            case 3:
+              return generated = _state.sent(), [
+                4,
+                writeGeneratedThemes(options.paths.dotDir, outPath, generated)
+              ];
+            case 4:
+              return _state.sent(), [
+                3,
+                6
+              ];
+            case 5:
+              return err = _state.sent(), console.error("Error generating themes: ".concat(err)), [
+                2
+              ];
+            case 6:
+              return console.info("Successfully generated themes to ".concat(outPath)), [
+                2
+              ];
+          }
+        });
+      }).apply(this);
     }
   },
   add: {
-    shorthands: ["a"],
-    description: `Use to add fonts and icons to your monorepo. Supported types: ${import_add.generatedPackageTypes.join(
-      ", "
-    )}`,
+    shorthands: [
+      "a"
+    ],
+    description: "Use to add fonts and icons to your monorepo. Supported types: ".concat(import_add.generatedPackageTypes.join(", ")),
     flags: {
       "--help": Boolean,
       "--debug": Boolean,
       "--verbose": Boolean
     },
-    async run() {
-      const { _, ...flags2 } = (0, import_arg.default)(this.flags), { installGeneratedPackage } = require("./add.js"), [cmd, type, path] = _;
-      await installGeneratedPackage(type, path);
+    run: function() {
+      return _async_to_generator(function() {
+        var _arg2, _, flags2, installGeneratedPackage, _1, cmd, type, path;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return _arg2 = (0, import_arg.default)(this.flags), _ = _arg2._, flags2 = _object_without_properties(_arg2, [
+                "_"
+              ]), installGeneratedPackage = require("./add.js").installGeneratedPackage, _1 = _sliced_to_array(_, 3), cmd = _1[0], type = _1[1], path = _1[2], [
+                4,
+                installGeneratedPackage(type, path)
+              ];
+            case 1:
+              return _state.sent(), [
+                2
+              ];
+          }
+        });
+      }).apply(this);
     }
   },
   // build: {
@@ -113,7 +415,9 @@ const COMMAND_MAP = {
   //   },
   // },
   studio: {
-    shorthands: ["s"],
+    shorthands: [
+      "s"
+    ],
     description: "Studio",
     flags: {
       "--help": Boolean,
@@ -122,55 +426,111 @@ const COMMAND_MAP = {
       "--remote": Boolean,
       "--build": Boolean
     },
-    async run() {
-      const { _, ...flags2 } = (0, import_arg.default)(this.flags), { studio } = require("./studio"), options = await (0, import_utils.getOptions)({
-        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
-      });
-      await studio(options, flags2["--remote"], flags2["--build"]);
+    run: function() {
+      return _async_to_generator(function() {
+        var _arg2, _, flags2, studio, options;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return _arg2 = (0, import_arg.default)(this.flags), _ = _arg2._, flags2 = _object_without_properties(_arg2, [
+                "_"
+              ]), studio = require("./studio").studio, [
+                4,
+                (0, import_utils.getOptions)({
+                  debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
+                })
+              ];
+            case 1:
+              return options = _state.sent(), [
+                4,
+                studio(options, flags2["--remote"], flags2["--build"])
+              ];
+            case 2:
+              return _state.sent(), [
+                2
+              ];
+          }
+        });
+      }).apply(this);
     }
   }
-}, commandEntries = Object.keys(COMMAND_MAP).flatMap((command2) => {
-  const definition2 = COMMAND_MAP[command2];
-  return [command2, ...definition2.shorthands].map((cmd) => [cmd, definition2]);
-}), commands = Object.fromEntries(commandEntries), {
-  _: [command],
-  ...flags
-} = (0, import_arg.default)(
-  {
-    "--help": Boolean,
-    "--version": Boolean
-  },
-  {
-    permissive: !0
-  }
-);
+}, commandEntries = Object.keys(COMMAND_MAP).flatMap(function(command2) {
+  var definition2 = COMMAND_MAP[command2], entries = [
+    command2
+  ].concat(_to_consumable_array(definition2.shorthands)).map(function(cmd) {
+    return [
+      cmd,
+      definition2
+    ];
+  });
+  return entries;
+}), commands = Object.fromEntries(commandEntries), _arg = (0, import_arg.default)({
+  "--help": Boolean,
+  "--version": Boolean
+}, {
+  permissive: !0
+}), _arg__ = _sliced_to_array(_arg._, 1), command = _arg__[0], flags = _object_without_properties(_arg, [
+  "_"
+]);
 flags["--version"] && (console.log(require("../package.json").version), process.exit(0));
 !command && flags["--help"] && (console.log(`$ tamagui
 
 commands:
 
-${Object.keys(COMMAND_MAP).map((key) => `  ${key}`).join(`
-`)}`), process.exit(0));
-command in commands || (console.error(), console.warn(import_chalk.default.yellow(`Not a valid command: ${command}`)), process.exit(1));
-const definition = commands[command];
+`.concat(Object.keys(COMMAND_MAP).map(function(key) {
+  return "  ".concat(key);
+}).join(`
+`))), process.exit(0));
+command in commands || (console.error(), console.warn(import_chalk.default.yellow("Not a valid command: ".concat(command))), process.exit(1));
+var definition = commands[command];
 main();
-async function main() {
-  flags["--help"] && (console.log(`
-$ tamagui ${command}: ${definition.description}
-`), console.log(
-    `Flags: ${Object.entries(definition.flags).map(([k, v]) => `${k} (${v.name})`)}`
-  ), process.exit(0));
-  const { _, ...cmdFlags } = (0, import_arg.default)(definition.flags);
-  cmdFlags["--help"] && (console.log(`$ tamagui ${_}
+function main() {
+  return _main.apply(this, arguments);
+}
+function _main() {
+  return _main = _async_to_generator(function() {
+    var _arg2, _, cmdFlags, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          flags["--help"] && (console.log(`
+$ tamagui `.concat(command, ": ").concat(definition.description, `
+`)), console.log("Flags: ".concat(Object.entries(definition.flags).map(function(param) {
+            var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+            return "".concat(k, " (").concat(v.name, ")");
+          }))), process.exit(0)), _arg2 = (0, import_arg.default)(definition.flags), _ = _arg2._, cmdFlags = _object_without_properties(_arg2, [
+            "_"
+          ]), cmdFlags["--help"] && (console.log("$ tamagui ".concat(_, `
 
-    Flags: ${JSON.stringify(cmdFlags, null, 2)}
+    Flags: `).concat(JSON.stringify(cmdFlags, null, 2), `
 
-`), process.exit(0));
-  try {
-    await definition.run();
-  } catch (err) {
-    console.error(`Error running command: ${err.message}`);
-  }
-  process.exit(0);
+`)), process.exit(0)), _state.label = 1;
+        case 1:
+          return _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]), [
+            4,
+            definition.run()
+          ];
+        case 2:
+          return _state.sent(), [
+            3,
+            4
+          ];
+        case 3:
+          return err = _state.sent(), console.error("Error running command: ".concat(err.message)), [
+            3,
+            4
+          ];
+        case 4:
+          return process.exit(0), [
+            2
+          ];
+      }
+    });
+  }), _main.apply(this, arguments);
 }
 //# sourceMappingURL=cli.js.map

package/dist/cli.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/cli.ts"],
-  "mappings": "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",
-  "names": ["flags", "arg", "command", "definition", "chalk"]
+  "sources": ["../src/Users/n8/tamagui/packages/cli/src/cli.ts"],
+  "mappings": "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",
+  "names": ["forEach", "_", "process", "on", "disposeAll", "exit", "COMMAND_MAP", "generate", "description", "shorthands", "flags", "Boolean", "run", "arg", "options", "getOptions", "debug", "loadTamaguiOptions", "env", "TAMAGUI_KEEP_THEMES", "loadTamagui", "tamaguiOptions", "platform", "_cmd", "inPath", "outPath", "require", "generateThemes", "writeGeneratedThemes", "generated", "err", "Error", "paths", "dotDir", "console", "error", "info", "add", "generatedPackageTypes", "join", "installGeneratedPackage", "cmd", "type", "path", "studio", "commandEntries", "Object", "keys", "flatMap", "command", "definition", "entries", "map", "commands", "fromEntries", "permissive", "log", "version", "key", "warn", "chalk", "yellow", "main", "cmdFlags", "k", "v", "name", "JSON", "stringify", "message"]
 }