@tamagui/cli 1.89.26 → 1.89.27-1708112217600

package/dist/generate.native.js

@@ -29,39 +29,257 @@ __export(generate_exports, {
 });
 module.exports = __toCommonJS(generate_exports);
 var import_fs_extra = __toESM(require("fs-extra")), import_ts_morph = require("ts-morph"), import_utils = require("./utils");
-async function generateTypes(options) {
-  const types = await getTypes(options);
-  await import_fs_extra.default.writeJSON(options.paths.types, types, {
-    spaces: 2
-  });
-}
-async function getTypes(options) {
-  const tamagui = await (0, import_utils.loadTamagui)(options.tamaguiOptions);
-  if (!tamagui)
-    throw new Error("No tamagui config");
-  const nameToPaths = tamagui.nameToPaths || [], uniqueViewExportingPaths = new Set(
-    Object.keys(nameToPaths).map((name) => `${[...nameToPaths[name]][0]}.ts*`)
-  ), files = new import_ts_morph.Project({
-    compilerOptions: {
-      noEmit: !1,
-      declaration: !0,
-      emitDeclarationOnly: !0
+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, 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 _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 _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];
     },
-    skipAddingFilesFromTsConfig: !0,
-    tsConfigFilePath: options.tsconfigPath
-  }).addSourceFilesAtPaths([...uniqueViewExportingPaths]);
-  return Object.fromEntries(
-    files.flatMap((x) => [...x.getExportedDeclarations()].map(([k, v]) => [
-      k,
-      v[0].getType().getApparentType().getProperties().map((prop) => {
-        var _a;
-        return [
-          prop.getEscapedName(),
-          (_a = prop.getValueDeclaration()) == null ? void 0 : _a.getType().getText()
-        ];
-      })
-    ]))
-  );
+    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 generateTypes(options) {
+  return _generateTypes.apply(this, arguments);
+}
+function _generateTypes() {
+  return _generateTypes = _async_to_generator(function(options) {
+    var types;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            getTypes(options)
+          ];
+        case 1:
+          return types = _state.sent(), [
+            4,
+            import_fs_extra.default.writeJSON(options.paths.types, types, {
+              spaces: 2
+            })
+          ];
+        case 2:
+          return _state.sent(), [
+            2
+          ];
+      }
+    });
+  }), _generateTypes.apply(this, arguments);
+}
+function getTypes(options) {
+  return _getTypes.apply(this, arguments);
+}
+function _getTypes() {
+  return _getTypes = _async_to_generator(function(options) {
+    var tamagui, nameToPaths, uniqueViewExportingPaths, project, files;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            (0, import_utils.loadTamagui)(options.tamaguiOptions)
+          ];
+        case 1:
+          if (tamagui = _state.sent(), !tamagui)
+            throw new Error("No tamagui config");
+          return nameToPaths = tamagui.nameToPaths || [], uniqueViewExportingPaths = new Set(Object.keys(nameToPaths).map(function(name) {
+            return "".concat(_to_consumable_array(nameToPaths[name])[0], ".ts*");
+          })), project = new import_ts_morph.Project({
+            compilerOptions: {
+              noEmit: !1,
+              declaration: !0,
+              emitDeclarationOnly: !0
+            },
+            skipAddingFilesFromTsConfig: !0,
+            tsConfigFilePath: options.tsconfigPath
+          }), files = project.addSourceFilesAtPaths(_to_consumable_array(uniqueViewExportingPaths)), [
+            2,
+            Object.fromEntries(files.flatMap(function(x) {
+              return _to_consumable_array(x.getExportedDeclarations()).map(function(param) {
+                var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
+                return [
+                  k,
+                  v[0].getType().getApparentType().getProperties().map(function(prop) {
+                    var _prop_getValueDeclaration;
+                    return [
+                      prop.getEscapedName(),
+                      (_prop_getValueDeclaration = prop.getValueDeclaration()) === null || _prop_getValueDeclaration === void 0 ? void 0 : _prop_getValueDeclaration.getType().getText()
+                    ];
+                  })
+                ];
+              });
+            }))
+          ];
+      }
+    });
+  }), _getTypes.apply(this, arguments);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/generate.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/generate.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAe,8BACf,kBAAwB,qBAExB,eAA4B;AAE5B,eAAsB,cAAc,SAA6B;AAC/D,QAAM,QAAQ,MAAM,SAAS,OAAO;AACpC,QAAM,gBAAAA,QAAG,UAAU,QAAQ,MAAM,OAAO,OAAO;AAAA,IAC7C,QAAQ;AAAA,EACV,CAAC;AACH;AAEA,eAAsB,SAAS,SAA6B;AAC1D,QAAM,UAAU,UAAM,0BAAY,QAAQ,cAAc;AAExD,MAAI,CAAC;AACH,UAAM,IAAI,MAAM,mBAAmB;AAGrC,QAAM,cAAc,QAAQ,eAAe,CAAC,GACtC,2BAA2B,IAAI;AAAA,IACnC,OAAO,KAAK,WAAW,EAAE,IAAI,CAAC,SACrB,GAAG,CAAC,GAAG,YAAY,IAAI,CAAC,EAAE,CAAC,CAAC,MACpC;AAAA,EACH,GAYM,QAVU,IAAI,wBAAQ;AAAA,IAC1B,iBAAiB;AAAA,MACf,QAAQ;AAAA,MACR,aAAa;AAAA,MACb,qBAAqB;AAAA,IACvB;AAAA,IACA,6BAA6B;AAAA,IAC7B,kBAAkB,QAAQ;AAAA,EAC5B,CAAC,EAEqB,sBAAsB,CAAC,GAAG,wBAAwB,CAAC;AAEzE,SAAO,OAAO;AAAA,IACZ,MAAM,QAAQ,CAAC,MACN,CAAC,GAAG,EAAE,wBAAwB,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MACzC;AAAA,MACL;AAAA,MACA,EAAE,CAAC,EACA,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,IAAI,CAAC,SAAS;AAlD3B;AAmDc,eAAO;AAAA,UACL,KAAK,eAAe;AAAA,WACpB,UAAK,oBAAoB,MAAzB,mBAA4B,UAAU;AAAA,QACxC;AAAA,MACF,CAAC;AAAA,IACL,CACD,CACF;AAAA,EACH;AAiBF;",
-  "names": ["fs"]
+  "sources": ["../src/Users/n8/tamagui/packages/cli/src/generate.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,sBAAe,8BACf,kBAAwB,qBAExB,eAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5B,SAAsBA,cAAcC,SAA2B;SAAzCD,eAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,iBAAAA;AAAAA,0BAAf,oBAAA,SAA6BC,SAA2B;QACvDC;;;;AAAQ,iBAAA;;YAAMC,SAASF,OAAAA;;;AAAvBC,yBAAQ,OAAA,KAAA,GACd;;YAAME,gBAAAA,QAAGC,UAAUJ,QAAQK,MAAMJ,OAAOA,OAAO;cAC7CK,QAAQ;YACV,CAAA;;;AAFA,wBAAA,KAAA;;;;;EAGF,CAAA,GALsBP,eAAAA,MAAAA,MAAAA,SAAAA;;AAOtB,SAAsBG,SAASF,SAA2B;SAApCE,UAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,YAAAA;AAAAA,qBAAf,oBAAA,SAAwBF,SAA2B;QAClDO,SAMAC,aACAC,0BAMAC,SAUAC;;;;AAvBU,iBAAA;;gBAAMC,0BAAYZ,QAAQa,cAAc;;;AAExD,cAFMN,UAAU,OAAA,KAAA,GAEZ,CAACA;AACH,kBAAM,IAAIO,MAAO,mBAAA;AAGbN,+BAAcD,QAAQC,eAAW,CAAA,GACjCC,2BAA2B,IAAIM,IACnCC,OAAOC,KAAKT,WAAAA,EAAaU,IAAI,SAACC,MAAAA;AAC5B,mBAAQ,GAA4B,OAAzB,qBAAGX,YAAYW,IAAAA,CAAK,EAAE,CAAA,GAAG,MAAA;UACtC,CAAA,CAAA,GAGIT,UAAU,IAAIU,wBAAQ;YAC1BC,iBAAiB;cACfC,QAAQ;cACRC,aAAa;cACbC,qBAAqB;YACvB;YACAC,6BAA6B;YAC7BC,kBAAkB1B,QAAQ2B;UAC5B,CAAA,GAEMhB,QAAQD,QAAQkB,sBAAuB,qBAAGnB,wBAAAA,CAAAA,GAEhD;;YAAOO,OAAOa,YACZlB,MAAMmB,QAAQ,SAACC,GAAAA;AACb,qBAAQ,qBAAGA,EAAEC,wBAAuB,CAAA,EAAId,IAAI,SAAA,OAAA;yDAAEe,IAAAA,OAAAA,CAAAA,GAAGC,IAAAA,OAAAA,CAAAA;AAC/C,uBAAO;kBACLD;kBACAC,EAAE,CAAA,EACCC,QAAO,EACPC,gBAAe,EACfC,cAAa,EACbnB,IAAI,SAACoB,MAAAA;wBAGFA;AAFF,2BAAO;sBACLA,KAAKC,eAAc;uBACnBD,4BAAAA,KAAKE,oBAAmB,OAAA,QAAxBF,8BAAAA,SAAAA,SAAAA,0BAA4BH,QAAO,EAAGM,QAAO;;kBAEjD,CAAA;;cAEN,CAAA;YACF,CAAA,CAAA;;;;EAkBJ,CAAA,GA7DsBvC,UAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["generateTypes", "options", "types", "getTypes", "fs", "writeJSON", "paths", "spaces", "tamagui", "nameToPaths", "uniqueViewExportingPaths", "project", "files", "loadTamagui", "tamaguiOptions", "Error", "Set", "Object", "keys", "map", "name", "Project", "compilerOptions", "noEmit", "declaration", "emitDeclarationOnly", "skipAddingFilesFromTsConfig", "tsConfigFilePath", "tsconfigPath", "addSourceFilesAtPaths", "fromEntries", "flatMap", "x", "getExportedDeclarations", "k", "v", "getType", "getApparentType", "getProperties", "prop", "getEscapedName", "getValueDeclaration", "getText"]
 }

package/dist/index.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../src/index.ts"],
-  "mappings": ";;AAEA,QAAQ,OAAO;",
-  "names": []
+  "sources": ["../src/Users/n8/tamagui/packages/cli/src/index.ts"],
+  "mappings": ";;AAEAA,QAAQ,OAAA;",
+  "names": ["require"]
 }