vxrn 0.1.19 → 0.1.21

package/dist/cjs/plugins/reactNativeCommonJsPlugin.native.js

@@ -0,0 +1,346 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var reactNativeCommonJsPlugin_exports = {};
+__export(reactNativeCommonJsPlugin_exports, {
+  reactNativeCommonJsPlugin: () => reactNativeCommonJsPlugin
+});
+module.exports = __toCommonJS(reactNativeCommonJsPlugin_exports);
+var import_node_path = require("node:path"), import_es_module_lexer = require("es-module-lexer"), import_getVitePath = require("../utils/getVitePath");
+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 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_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 _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 _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
+    };
+  }
+}
+var extensions = [
+  ".ios.js",
+  ".native.js",
+  ".native.ts",
+  ".native.tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".ts",
+  ".tsx",
+  ".mjs"
+];
+function reactNativeCommonJsPlugin(options) {
+  return {
+    name: "native",
+    enforce: "pre",
+    config: function() {
+      var _ref = _async_to_generator(function(config) {
+        var _config, _config1, _config2, _config_optimizeDeps, _config_optimizeDeps_esbuildOptions, _config_optimizeDeps_esbuildOptions1, _config_build, _config_build_rollupOptions, _config_build_rollupOptions1, _resolve, _optimizeDeps, _esbuildOptions, _plugins, _loader, _rollupOptions, _output, _plugins1, _config3, updateOutputOptions, o;
+        return _ts_generator(this, function(_state) {
+          if ((_config = config).define || (_config.define = {}), config.define["process.env.REACT_NATIVE_SERVER_PUBLIC_PORT"] = JSON.stringify("".concat(options.port)), config.define["process.env.REACT_NATIVE_PLATFORM"] = JSON.stringify("ios"), config.build || (config.build = {}), config.build.modulePreload = {
+            polyfill: !1
+          }, config.build.assetsInlineLimit = 1e8, config.build.chunkSizeWarningLimit = 1e8, config.build.cssCodeSplit = !1, config.build.reportCompressedSize = !1, config.base = void 0, (_resolve = (_config1 = config).resolve) !== null && _resolve !== void 0 || (_config1.resolve = {}), config.resolve.extensions = extensions, config.resolve.conditions = [
+            "react-native",
+            "require",
+            "default",
+            "import"
+          ], (_optimizeDeps = (_config2 = config).optimizeDeps) !== null && _optimizeDeps !== void 0 || (_config2.optimizeDeps = {}), config.optimizeDeps.noDiscovery = !0, config.optimizeDeps.include = void 0, (_esbuildOptions = (_config_optimizeDeps = config.optimizeDeps).esbuildOptions) !== null && _esbuildOptions !== void 0 || (_config_optimizeDeps.esbuildOptions = {}), config.optimizeDeps.esbuildOptions.resolveExtensions = extensions, (_plugins = (_config_optimizeDeps_esbuildOptions = config.optimizeDeps.esbuildOptions).plugins) !== null && _plugins !== void 0 || (_config_optimizeDeps_esbuildOptions.plugins = []), (_loader = (_config_optimizeDeps_esbuildOptions1 = config.optimizeDeps.esbuildOptions).loader) !== null && _loader !== void 0 || (_config_optimizeDeps_esbuildOptions1.loader = {}), config.optimizeDeps.esbuildOptions.loader[".js"] = "jsx", config.optimizeDeps.esbuildOptions.plugins.push({
+            name: "react-native-assets",
+            setup: function(build) {
+              build.onResolve({
+                filter: /\.(png|jpg|gif|webp)$/
+              }, function() {
+                var _ref2 = _async_to_generator(function(param) {
+                  var path, namespace;
+                  return _ts_generator(this, function(_state2) {
+                    return path = param.path, namespace = param.namespace, [
+                      2,
+                      {
+                        path: "",
+                        external: !0
+                      }
+                    ];
+                  });
+                });
+                return function(_) {
+                  return _ref2.apply(this, arguments);
+                };
+              }());
+            }
+          }), (_rollupOptions = (_config_build = config.build).rollupOptions) !== null && _rollupOptions !== void 0 || (_config_build.rollupOptions = {}), config.build.rollupOptions.input = config.root, (_output = (_config_build_rollupOptions = config.build.rollupOptions).output) !== null && _output !== void 0 || (_config_build_rollupOptions.output = {}), (_plugins1 = (_config_build_rollupOptions1 = config.build.rollupOptions).plugins) !== null && _plugins1 !== void 0 || (_config_build_rollupOptions1.plugins = []), !Array.isArray(config.build.rollupOptions.plugins))
+            throw "x";
+          if (options.mode === "build" && ((_config3 = config).plugins || (_config3.plugins = []), config.build.rollupOptions.plugins.push({
+            name: "force-export-all",
+            transform: function(code, id) {
+              return _async_to_generator(function() {
+                var _parse, imports, exports2, forceExports, counts, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, imp, _counts, _imp_n, path, err, err1;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      _state2.trys.push([
+                        0,
+                        9,
+                        ,
+                        10
+                      ]), _parse = _sliced_to_array((0, import_es_module_lexer.parse)(code), 2), imports = _parse[0], exports2 = _parse[1], forceExports = "", counts = {}, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state2.label = 1;
+                    case 1:
+                      _state2.trys.push([
+                        1,
+                        6,
+                        7,
+                        8
+                      ]), _iterator = imports[Symbol.iterator](), _state2.label = 2;
+                    case 2:
+                      return (_iteratorNormalCompletion = (_step = _iterator.next()).done) ? [
+                        3,
+                        5
+                      ] : (imp = _step.value, imp.n && imp.n[0] !== "." ? ((_counts = counts)[_imp_n = imp.n] || (_counts[_imp_n] = 0), counts[imp.n]++, counts[imp.n] != 2 ? [
+                        3,
+                        4
+                      ] : [
+                        4,
+                        (0, import_getVitePath.getVitePath)(options.root, (0, import_node_path.dirname)(id), imp.n)
+                      ]) : [
+                        3,
+                        4
+                      ]);
+                    case 3:
+                      path = _state2.sent(), forceExports += 'Object.assign(exports, require("'.concat(path, '"));'), _state2.label = 4;
+                    case 4:
+                      return _iteratorNormalCompletion = !0, [
+                        3,
+                        2
+                      ];
+                    case 5:
+                      return [
+                        3,
+                        8
+                      ];
+                    case 6:
+                      return err = _state2.sent(), _didIteratorError = !0, _iteratorError = err, [
+                        3,
+                        8
+                      ];
+                    case 7:
+                      try {
+                        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                      } finally {
+                        if (_didIteratorError)
+                          throw _iteratorError;
+                      }
+                      return [
+                        7
+                      ];
+                    case 8:
+                      return forceExports += exports2.map(function(e) {
+                        if (e.n === "default")
+                          return "";
+                        var out = "";
+                        return e.ln !== e.n && (out += "__ignore = typeof ".concat(e.n, " === 'undefined' ? 0 : 0;")), out += "globalThis.____forceExport = ".concat(e.ln), out;
+                      }).join(";"), [
+                        2,
+                        code + `
+` + forceExports
+                      ];
+                    case 9:
+                      return err1 = _state2.sent(), console.warn("Error forcing exports, probably ok", id), [
+                        3,
+                        10
+                      ];
+                    case 10:
+                      return [
+                        2
+                      ];
+                  }
+                });
+              })();
+            }
+          })), process.env.DEBUG && console.info("config..", config), updateOutputOptions = function(out) {
+            out.preserveModules = !0, out.entryFileNames = function(chunkInfo) {
+              return "[name].js";
+            }, out.manualChunks = void 0;
+          }, Array.isArray(config.build.rollupOptions.output))
+            for (var o2 in config.build.rollupOptions.output)
+              updateOutputOptions(o2);
+          else
+            updateOutputOptions(config.build.rollupOptions.output);
+          return [
+            2
+          ];
+        });
+      });
+      return function(config) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reactNativeCommonJsPlugin
+});
+//# sourceMappingURL=reactNativeCommonJsPlugin.js.map

package/dist/cjs/plugins/reactNativeCommonJsPlugin.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/plugins/Users/n8/vxrn/packages/vxrn/src/plugins/reactNativeCommonJsPlugin.ts"],
+  "mappings": "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",
+  "names": ["extensions", "reactNativeCommonJsPlugin", "options", "name", "enforce", "config", "updateOutputOptions", "o", "define", "JSON", "stringify", "port", "build", "modulePreload", "polyfill", "assetsInlineLimit", "chunkSizeWarningLimit", "cssCodeSplit", "reportCompressedSize", "base", "undefined", "resolve", "conditions", "optimizeDeps", "noDiscovery", "include", "esbuildOptions", "resolveExtensions", "plugins", "loader", "push", "setup", "onResolve", "filter", "path", "namespace", "external", "rollupOptions", "input", "root", "output", "Array", "isArray", "mode", "transform", "code", "id", "parse", "imports", "exports", "forceExports", "counts", "imp", "err", "n", "getVitePath", "dirname", "_state", "map", "e", "out", "ln", "join", "console", "warn", "process", "env", "DEBUG", "info", "preserveModules", "entryFileNames", "chunkInfo", "manualChunks"]
+}

package/dist/cjs/utils/checkPatches.js

@@ -0,0 +1,62 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var checkPatches_exports = {};
+__export(checkPatches_exports, {
+  checkPatches: () => checkPatches
+});
+module.exports = __toCommonJS(checkPatches_exports);
+var import_find_node_modules = __toESM(require("find-node-modules"), 1), import_node_path = require("node:path"), import_fs_extra = __toESM(require("fs-extra"), 1);
+const patches = [
+  {
+    module: "react-native-screens",
+    patchFile: "react-native-screens+3.22.1.patch"
+  }
+];
+async function checkPatches(options) {
+  if (options.state.applyPatches === !1)
+    return;
+  const nodeModulesDirs = (0, import_find_node_modules.default)({
+    cwd: options.root
+  }).map((relativePath) => (0, import_node_path.join)(options.root, relativePath)), patchesToCopy = /* @__PURE__ */ new Set();
+  await Promise.all(
+    patches.flatMap((patch) => nodeModulesDirs.flatMap(async (dir) => {
+      await import_fs_extra.default.pathExists((0, import_node_path.join)(dir, patch.module)) && patchesToCopy.add(patch);
+    }))
+  );
+  let didCopy = !1;
+  for (const patch of [...patchesToCopy]) {
+    const dest = (0, import_node_path.join)(options.userPatchesDir, patch.patchFile);
+    if (!await pathExists(dest)) {
+      didCopy = !0, console.info(`Copying patch ${patch.module}`);
+      const src = (0, import_node_path.join)(options.internalPatchesDir, patch.patchFile);
+      await import_fs_extra.default.copy(src, dest);
+    }
+  }
+  didCopy && (console.info(
+    `
+Please restart after applying the patch by running "npx patch-package".
+  Ideally add it to your devDependencies and as a postinstall script.
+`
+  ), process.exit(0));
+}
+//# sourceMappingURL=checkPatches.js.map

package/dist/cjs/utils/checkPatches.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/checkPatches.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAA4B,0CAC5B,mBAAqB,sBACrB,kBAAoB;AAGpB,MAAM,UAAU;AAAA,EACd;AAAA,IACE,QAAQ;AAAA,IACR,WAAW;AAAA,EACb;AACF;AAEA,eAAsB,aAAa,SAA2B;AAC5D,MAAI,QAAQ,MAAM,iBAAiB;AACjC;AAGF,QAAM,sBAAkB,yBAAAA,SAAgB;AAAA,IACtC,KAAK,QAAQ;AAAA,EACf,CAAC,EAAE,IAAI,CAAC,qBAAiB,uBAAK,QAAQ,MAAM,YAAY,CAAC,GAEnD,gBAAgB,oBAAI,IAAW;AAErC,QAAM,QAAQ;AAAA,IACZ,QAAQ,QAAQ,CAAC,UACR,gBAAgB,QAAQ,OAAO,QAAQ;AAC5C,MAAI,MAAM,gBAAAC,QAAQ,eAAW,uBAAK,KAAK,MAAM,MAAM,CAAC,KAClD,cAAc,IAAI,KAAK;AAAA,IAE3B,CAAC,CACF;AAAA,EACH;AAEA,MAAI,UAAU;AAEd,aAAW,SAAS,CAAC,GAAG,aAAa,GAAG;AACtC,UAAM,WAAO,uBAAK,QAAQ,gBAAgB,MAAM,SAAS;AACzD,QAAI,CAAE,MAAM,WAAW,IAAI,GAAI;AAC7B,gBAAU,IACV,QAAQ,KAAK,iBAAiB,MAAM,MAAM,EAAE;AAC5C,YAAM,UAAM,uBAAK,QAAQ,oBAAoB,MAAM,SAAS;AAC5D,YAAM,gBAAAA,QAAQ,KAAK,KAAK,IAAI;AAAA,IAC9B;AAAA,EACF;AAEA,EAAI,YACF,QAAQ;AAAA,IACN;AAAA;AAAA;AAAA;AAAA,EAEF,GACA,QAAQ,KAAK,CAAC;AAElB;",
+  "names": ["findNodeModules", "FSExtra"]
+}