vxrn 0.1.19 → 0.1.21

package/dist/cjs/{VXRNConfigFilled.native.js → utils/checkPatches.native.js}

@@ -21,22 +21,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
 )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var VXRNConfigFilled_exports = {};
-__export(VXRNConfigFilled_exports, {
-  getOptionsFilled: () => getOptionsFilled
+var checkPatches_exports = {};
+__export(checkPatches_exports, {
+  checkPatches: () => checkPatches
 });
-module.exports = __toCommonJS(VXRNConfigFilled_exports);
-var import_node_path = require("node:path"), import_pkg_types = require("pkg-types"), import_fs_extra = __toESM(require("fs-extra"), 1);
-const import_meta = {};
+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);
 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) {
+function _array_without_holes(arr) {
   if (Array.isArray(arr))
-    return arr;
+    return _array_like_to_array(arr);
 }
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -62,65 +61,15 @@ function _async_to_generator(fn) {
     });
   };
 }
-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 _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 _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_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 _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) {
@@ -224,84 +173,117 @@ function _ts_generator(thisArg, body) {
     };
   }
 }
-function getOptionsFilled(options) {
-  return _getOptionsFilled.apply(this, arguments);
+var patches = [
+  {
+    module: "react-native-screens",
+    patchFile: "react-native-screens+3.22.1.patch"
+  }
+];
+function checkPatches(options) {
+  return _checkPatches.apply(this, arguments);
 }
-function _getOptionsFilled() {
-  return _getOptionsFilled = _async_to_generator(function(options) {
-    var _options_host, host, _options_root, root, _options_port, port, _url, packageRootDir, cacheDir, internalPatchesDir, userPatchesDir, _ref, state, packageJSON;
+function _checkPatches() {
+  return _checkPatches = _async_to_generator(function(options) {
+    var nodeModulesDirs, patchesToCopy, didCopy, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, patch, dest, src, err;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          return _options_host = options.host, host = _options_host === void 0 ? "127.0.0.1" : _options_host, _options_root = options.root, root = _options_root === void 0 ? process.cwd() : _options_root, _options_port = options.port, port = _options_port === void 0 ? 8081 : _options_port, packageRootDir = (0, import_node_path.join)((_url = import_meta.url) !== null && _url !== void 0 ? _url : __filename, "..", "..", "..").replace("file:", ""), cacheDir = (0, import_node_path.join)(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = (0, import_node_path.join)(packageRootDir, "patches"), userPatchesDir = (0, import_node_path.join)(root, "patches"), [
+          return options.state.applyPatches === !1 ? [
+            2
+          ] : (nodeModulesDirs = (0, import_find_node_modules.default)({
+            cwd: options.root
+          }).map(function(relativePath) {
+            return (0, import_node_path.join)(options.root, relativePath);
+          }), patchesToCopy = /* @__PURE__ */ new Set(), [
             4,
-            Promise.all([
-              //
-              readState(cacheDir),
-              (0, import_pkg_types.readPackageJSON)()
-            ])
-          ];
+            Promise.all(patches.flatMap(function(patch2) {
+              return nodeModulesDirs.flatMap(function() {
+                var _ref = _async_to_generator(function(dir) {
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          import_fs_extra.default.pathExists((0, import_node_path.join)(dir, patch2.module))
+                        ];
+                      case 1:
+                        return _state2.sent() && patchesToCopy.add(patch2), [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(dir) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+            }))
+          ]);
         case 1:
-          return _ref = _sliced_to_array.apply(void 0, [
-            _state.sent(),
-            2
-          ]), state = _ref[0], packageJSON = _ref[1], [
+          _state.sent(), didCopy = !1, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state.label = 2;
+        case 2:
+          _state.trys.push([
             2,
-            _object_spread_props(_object_spread({}, options), {
-              packageJSON,
-              state,
-              packageRootDir,
-              cacheDir,
-              userPatchesDir,
-              internalPatchesDir,
-              host,
-              root,
-              port
-            })
-          ];
-      }
-    });
-  }), _getOptionsFilled.apply(this, arguments);
-}
-function readState(cacheDir) {
-  return _readState.apply(this, arguments);
-}
-function _readState() {
-  return _readState = _async_to_generator(function(cacheDir) {
-    var statePath, state, _tmp;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return statePath = (0, import_node_path.join)(cacheDir, "state.json"), [
+            8,
+            9,
+            10
+          ]), _iterator = _to_consumable_array(patchesToCopy)[Symbol.iterator](), _state.label = 3;
+        case 3:
+          return (_iteratorNormalCompletion = (_step = _iterator.next()).done) ? [
+            3,
+            7
+          ] : (patch = _step.value, dest = (0, import_node_path.join)(options.userPatchesDir, patch.patchFile), [
             4,
-            import_fs_extra.default.pathExists(statePath)
-          ];
-        case 1:
+            pathExists(dest)
+          ]);
+        case 4:
           return _state.sent() ? [
+            3,
+            6
+          ] : (didCopy = !0, console.info("Copying patch ".concat(patch.module)), src = (0, import_node_path.join)(options.internalPatchesDir, patch.patchFile), [
             4,
-            import_fs_extra.default.readJSON(statePath)
-          ] : [
+            import_fs_extra.default.copy(src, dest)
+          ]);
+        case 5:
+          _state.sent(), _state.label = 6;
+        case 6:
+          return _iteratorNormalCompletion = !0, [
             3,
             3
           ];
-        case 2:
-          return _tmp = _state.sent(), [
+        case 7:
+          return [
             3,
-            4
+            10
           ];
-        case 3:
-          _tmp = {}, _state.label = 4;
-        case 4:
-          return state = _tmp, [
-            2,
-            state
+        case 8:
+          return err = _state.sent(), _didIteratorError = !0, _iteratorError = err, [
+            3,
+            10
+          ];
+        case 9:
+          try {
+            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+          } finally {
+            if (_didIteratorError)
+              throw _iteratorError;
+          }
+          return [
+            7
+          ];
+        case 10:
+          return 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)), [
+            2
           ];
       }
     });
-  }), _readState.apply(this, arguments);
+  }), _checkPatches.apply(this, arguments);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getOptionsFilled
+  checkPatches
 });
-//# sourceMappingURL=VXRNConfigFilled.js.map
+//# sourceMappingURL=checkPatches.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/checkPatches.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA4B,0CAC5B,mBAAqB,sBACrB,kBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGpB,IAAMA,UAAU;EACd;IACEC,QAAQ;IACRC,WAAW;EACb;;AAGF,SAAsBC,aAAaC,SAAyB;SAAtCD,cAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,gBAAAA;AAAAA,yBAAf,oBAAA,SAA4BC,SAAyB;QAKpDC,iBAIAC,eAYFC,SAEC,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,OACHC,MAIEC,KAAAA;;;;AA3BV,iBAAIN,QAAQO,MAAMC,iBAAiB,KACjC;;eAGIP,sBAAkBQ,yBAAAA,SAAgB;YACtCC,KAAKV,QAAQW;UACf,CAAA,EAAGC,IAAI,SAACC,cAAAA;uBAAiBC,uBAAKd,QAAQW,MAAME,YAAAA;cAEtCX,gBAAgB,oBAAIa,IAAAA,GAE1B;;YAAMC,QAAQC,IACZrB,QAAQsB,QAAQ,SAACd,QAAAA;AACf,qBAAOH,gBAAgBiB,QAAO,WAAA;2BAAC,oBAAA,SAAOC,KAAAA;;;;AAChC,+BAAA;;0BAAMC,gBAAAA,QAAQC,eAAWP,uBAAKK,KAAKf,OAAMP,MAAM,CAAA;;;AAAnD,+BAAIyB,QAAA,KAAA,KACFpB,cAAcqB,IAAInB,MAAAA;;;;;gBAEtB,CAAA;gCAJsCe,KAAAA;;;;YAKxC,CAAA,CAAA;;;AAPF,iBAAA,KAAA,GAUIhB,UAAU,IAET,4BAAA,IAAA,oBAAA,IAAA,iBAAA;;;;;;;cAAA,YAAgB,qBAAGD,aAAAA,EAAAA,OAAAA,QAAAA,EAAAA;;kBAAnB,6BAAA,QAAA,UAAA,KAAA,GAAA,QAAA;;;eAAME,QAAN,MAAA,OACGC,WAAOS,uBAAKd,QAAQwB,gBAAgBpB,MAAMN,SAAS,GACnD;;YAAMuB,WAAWhB,IAAAA;;;iBAAjB,OAAA,KAAA,IAAF;;;eACFF,UAAU,IACVsB,QAAQC,KAAM,iBAA6B,OAAbtB,MAAMP,MAAM,CAAA,GACpCS,UAAMQ,uBAAKd,QAAQ2B,oBAAoBvB,MAAMN,SAAS,GAC5D;;YAAMsB,gBAAAA,QAAQQ,KAAKtB,KAAKD,IAAAA;;;AAAxB,iBAAA,KAAA;;AANC,6CAAA;;;;;;;;;;sCAAA,oBAAA,IAAA,iBAAA;;;;;;aAAA,6BAAA,UAAA,UAAA,QAAA,UAAA,OAAA;;gBAAA;oBAAA;;;;;;AAUL,iBAAIF,YACFsB,QAAQC,KACL;;;CAAA,GAGHG,QAAQC,KAAK,CAAA;;;;;EAEjB,CAAA,GAxCsB/B,cAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["patches", "module", "patchFile", "checkPatches", "options", "nodeModulesDirs", "patchesToCopy", "didCopy", "patch", "dest", "src", "state", "applyPatches", "findNodeModules", "cwd", "root", "map", "relativePath", "join", "Set", "Promise", "all", "flatMap", "dir", "FSExtra", "pathExists", "_state", "add", "userPatchesDir", "console", "info", "internalPatchesDir", "copy", "process", "exit"]
+}

package/dist/cjs/utils/dispose.js

@@ -0,0 +1,28 @@
+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 dispose_exports = {};
+__export(dispose_exports, {
+  disposeAll: () => disposeAll,
+  registerDispose: () => registerDispose
+});
+module.exports = __toCommonJS(dispose_exports);
+const disposers = /* @__PURE__ */ new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach((cb) => cb());
+}
+//# sourceMappingURL=dispose.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/dispose.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAM,YAAY,oBAAI,IAAc;AAE7B,SAAS,gBAAgB,IAAgB;AAC9C,YAAU,IAAI,EAAE;AAClB;AAEO,SAAS,aAAa;AAC3B,YAAU,QAAQ,CAAC,OAAO,GAAG,CAAC;AAChC;",
+  "names": []
+}

package/dist/cjs/utils/dispose.native.js

@@ -0,0 +1,36 @@
+"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 dispose_exports = {};
+__export(dispose_exports, {
+  disposeAll: () => disposeAll,
+  registerDispose: () => registerDispose
+});
+module.exports = __toCommonJS(dispose_exports);
+var disposers = /* @__PURE__ */ new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach(function(cb) {
+    return cb();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  disposeAll,
+  registerDispose
+});
+//# sourceMappingURL=dispose.js.map

package/dist/cjs/utils/dispose.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/dispose.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;IAAMA,YAAY,oBAAIC,IAAAA;AAEf,SAASC,gBAAgBC,IAAc;AAC5CH,YAAUI,IAAID,EAAAA;AAChB;AAEO,SAASE,aAAAA;AACdL,YAAUM,QAAQ,SAACH,IAAAA;WAAOA,GAAAA;;AAC5B;",
+  "names": ["disposers", "Set", "registerDispose", "cb", "add", "disposeAll", "forEach"]
+}

package/dist/cjs/utils/getBaseViteConfig.js

@@ -17,7 +17,7 @@ __export(getBaseViteConfig_exports, {
   getBaseViteConfig: () => getBaseViteConfig
 });
 module.exports = __toCommonJS(getBaseViteConfig_exports);
-var import_createDevServer = require("../createDevServer");
+var import_dev = require("../exports/dev");
 function getBaseViteConfig({ mode }) {
   return {
     mode,
@@ -27,7 +27,7 @@ function getBaseViteConfig({ mode }) {
     },
     resolve: {
       alias: {
-        "react-native": (0, import_createDevServer.resolveFile)("react-native-web-lite")
+        "react-native": (0, import_dev.resolveFile)("react-native-web-lite")
       }
     },
     build: {

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

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/getBaseViteConfig.ts"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,6BAA4B;AAErB,SAAS,kBAAkB,EAAE,KAAK,GAAuD;AAC9F,SAAO;AAAA,IACL;AAAA,IACA,QAAQ;AAAA,MACN,SAAS,GAAG,SAAS,aAAa;AAAA,MAClC,wBAAwB,IAAI,IAAI;AAAA,IAClC;AAAA,IACA,SAAS;AAAA,MACP,OAAO;AAAA,QACL,oBAAgB,oCAAY,uBAAuB;AAAA,MACrD;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL,iBAAiB;AAAA,QACf,yBAAyB;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AACF;",
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,iBAA4B;AAErB,SAAS,kBAAkB,EAAE,KAAK,GAAuD;AAC9F,SAAO;AAAA,IACL;AAAA,IACA,QAAQ;AAAA,MACN,SAAS,GAAG,SAAS,aAAa;AAAA,MAClC,wBAAwB,IAAI,IAAI;AAAA,IAClC;AAAA,IACA,SAAS;AAAA,MACP,OAAO;AAAA,QACL,oBAAgB,wBAAY,uBAAuB;AAAA,MACrD;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL,iBAAiB;AAAA,QACf,yBAAyB;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/cjs/utils/getBaseViteConfig.native.js

@@ -18,7 +18,7 @@ __export(getBaseViteConfig_exports, {
   getBaseViteConfig: () => getBaseViteConfig
 });
 module.exports = __toCommonJS(getBaseViteConfig_exports);
-var import_createDevServer = require("../createDevServer");
+var import_dev = require("../exports/dev");
 function getBaseViteConfig(param) {
   var mode = param.mode;
   return {
@@ -29,7 +29,7 @@ function getBaseViteConfig(param) {
     },
     resolve: {
       alias: {
-        "react-native": (0, import_createDevServer.resolveFile)("react-native-web-lite")
+        "react-native": (0, import_dev.resolveFile)("react-native-web-lite")
       }
     },
     build: {

package/dist/cjs/utils/getBaseViteConfig.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/getBaseViteConfig.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AACA;;;;;6BAA4B;AAErB,SAASA,kBAAkB,OAAgD;MAA9CC,OAAF,MAAEA;AAClC,SAAO;IACLA;IACAC,QAAQ;MACNC,SAAU,GAAyB,OAAvBF,SAAS,aAAA;MACrB,wBAAyB,IAAQ,OAALA,MAAK,GAAA;IACnC;IACAG,SAAS;MACPC,OAAO;QACL,oBAAgBC,oCAAY,uBAAA;MAC9B;IACF;IACAC,OAAO;MACLC,iBAAiB;QACfC,yBAAyB;MAC3B;IACF;EACF;AACF;",
+  "mappings": ";;;;;;;;;;;;;;;AACA;;;;;iBAA4B;AAErB,SAASA,kBAAkB,OAAgD;MAA9CC,OAAF,MAAEA;AAClC,SAAO;IACLA;IACAC,QAAQ;MACNC,SAAU,GAAyB,OAAvBF,SAAS,aAAA;MACrB,wBAAyB,IAAQ,OAALA,MAAK,GAAA;IACnC;IACAG,SAAS;MACPC,OAAO;QACL,oBAAgBC,wBAAY,uBAAA;MAC9B;IACF;IACAC,OAAO;MACLC,iBAAiB;QACfC,yBAAyB;MAC3B;IACF;EACF;AACF;",
   "names": ["getBaseViteConfig", "mode", "define", "__DEV__", "resolve", "alias", "resolveFile", "build", "commonjsOptions", "transformMixedEsModules"]
 }

package/dist/cjs/utils/getOptionsFilled.js

@@ -25,10 +25,10 @@ __export(getOptionsFilled_exports, {
   getOptionsFilled: () => getOptionsFilled
 });
 module.exports = __toCommonJS(getOptionsFilled_exports);
-var import_node_path = require("node:path"), import_pkg_types = require("pkg-types"), import_fs_extra = __toESM(require("fs-extra"), 1);
-const import_meta = {};
+var import_node_path = require("node:path"), import_pkg_types = require("pkg-types"), import_module = require("module"), import_fs_extra = __toESM(require("fs-extra"), 1);
+const import_meta = {}, require2 = (0, import_module.createRequire)(import_meta.url);
 async function getOptionsFilled(options) {
-  const { host = "127.0.0.1", root = process.cwd(), port = 8081 } = options, packageRootDir = (0, import_node_path.join)(import_meta.url ?? __filename, "..", "..", "..").replace("file:", ""), cacheDir = (0, import_node_path.join)(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = (0, import_node_path.join)(packageRootDir, "patches"), userPatchesDir = (0, import_node_path.join)(root, "patches"), [state, packageJSON] = await Promise.all([
+  const { host = "127.0.0.1", root = process.cwd(), port = 8081 } = options, packageRootDir = (0, import_node_path.join)(require2.resolve("vxrn"), "../../.."), cacheDir = (0, import_node_path.join)(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = (0, import_node_path.join)(packageRootDir, "patches"), userPatchesDir = (0, import_node_path.join)(root, "patches"), [state, packageJSON] = await Promise.all([
     //
     readState(cacheDir),
     (0, import_pkg_types.readPackageJSON)()

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

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/getOptionsFilled.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAqB,sBACrB,mBAAgC,sBAChC,kBAAoB;AAFpB;AAOA,eAAsB,iBAAiB,SAAqB;AAC1D,QAAM,EAAE,OAAO,aAAa,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,SAC5D,qBAAiB,uBAAK,YAAY,OAAO,YAAY,MAAM,MAAM,IAAI,EAAE,QAAQ,SAAS,EAAE,GAC1F,eAAW,uBAAK,MAAM,gBAAgB,UAAU,MAAM,GACtD,yBAAqB,uBAAK,gBAAgB,SAAS,GACnD,qBAAiB,uBAAK,MAAM,SAAS,GACrC,CAAC,OAAO,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,IAE7C,UAAU,QAAQ;AAAA,QAClB,kCAAgB;AAAA,EAClB,CAAC;AACD,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAMA,eAAe,UAAU,UAAkB;AACzC,QAAM,gBAAY,uBAAK,UAAU,YAAY;AAI7C,SAHsB,MAAM,gBAAAA,QAAQ,WAAW,SAAS,IACpD,MAAM,gBAAAA,QAAQ,SAAS,SAAS,IAChC,CAAC;AAEP;",
-  "names": ["FSExtra"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAqB,sBACrB,mBAAgC,sBAChC,gBAA8B,mBAC9B,kBAAoB;AAHpB,wBAMMA,eAAU,6BAAc,YAAY,GAAG;AAI7C,eAAsB,iBAAiB,SAAqB;AAC1D,QAAM,EAAE,OAAO,aAAa,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,SAE5D,qBAAiB,uBAAKA,SAAQ,QAAQ,MAAM,GAAG,UAAU,GAEzD,eAAW,uBAAK,MAAM,gBAAgB,UAAU,MAAM,GACtD,yBAAqB,uBAAK,gBAAgB,SAAS,GACnD,qBAAiB,uBAAK,MAAM,SAAS,GACrC,CAAC,OAAO,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,IAE7C,UAAU,QAAQ;AAAA,QAClB,kCAAgB;AAAA,EAClB,CAAC;AACD,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAMA,eAAe,UAAU,UAAkB;AACzC,QAAM,gBAAY,uBAAK,UAAU,YAAY;AAI7C,SAHsB,MAAM,gBAAAC,QAAQ,WAAW,SAAS,IACpD,MAAM,gBAAAA,QAAQ,SAAS,SAAS,IAChC,CAAC;AAEP;",
+  "names": ["require", "FSExtra"]
 }

package/dist/cjs/utils/getOptionsFilled.native.js

@@ -26,7 +26,7 @@ __export(getOptionsFilled_exports, {
   getOptionsFilled: () => getOptionsFilled
 });
 module.exports = __toCommonJS(getOptionsFilled_exports);
-var import_node_path = require("node:path"), import_pkg_types = require("pkg-types"), import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_node_path = require("node:path"), import_pkg_types = require("pkg-types"), import_module = require("module"), import_fs_extra = __toESM(require("fs-extra"), 1);
 const import_meta = {};
 function _array_like_to_array(arr, len) {
   (len == null || len > arr.length) && (len = arr.length);
@@ -224,16 +224,17 @@ function _ts_generator(thisArg, body) {
     };
   }
 }
+var require2 = (0, import_module.createRequire)(import_meta.url);
 function getOptionsFilled(options) {
   return _getOptionsFilled.apply(this, arguments);
 }
 function _getOptionsFilled() {
   return _getOptionsFilled = _async_to_generator(function(options) {
-    var _options_host, host, _options_root, root, _options_port, port, _url, packageRootDir, cacheDir, internalPatchesDir, userPatchesDir, _ref, state, packageJSON;
+    var _options_host, host, _options_root, root, _options_port, port, packageRootDir, cacheDir, internalPatchesDir, userPatchesDir, _ref, state, packageJSON;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          return _options_host = options.host, host = _options_host === void 0 ? "127.0.0.1" : _options_host, _options_root = options.root, root = _options_root === void 0 ? process.cwd() : _options_root, _options_port = options.port, port = _options_port === void 0 ? 8081 : _options_port, packageRootDir = (0, import_node_path.join)((_url = import_meta.url) !== null && _url !== void 0 ? _url : __filename, "..", "..", "..").replace("file:", ""), cacheDir = (0, import_node_path.join)(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = (0, import_node_path.join)(packageRootDir, "patches"), userPatchesDir = (0, import_node_path.join)(root, "patches"), [
+          return _options_host = options.host, host = _options_host === void 0 ? "127.0.0.1" : _options_host, _options_root = options.root, root = _options_root === void 0 ? process.cwd() : _options_root, _options_port = options.port, port = _options_port === void 0 ? 8081 : _options_port, packageRootDir = (0, import_node_path.join)(require2.resolve("vxrn"), "../../.."), cacheDir = (0, import_node_path.join)(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = (0, import_node_path.join)(packageRootDir, "patches"), userPatchesDir = (0, import_node_path.join)(root, "patches"), [
             4,
             Promise.all([
               //

package/dist/cjs/utils/getOptionsFilled.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/Users/n8/vxrn/packages/vxrn/src/utils/getOptionsFilled.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uBAAqB,sBACrB,mBAAgC,sBAChC,kBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKpB,SAAsBA,iBAAiBC,SAAmB;SAApCD,kBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,oBAAAA;AAAAA,6BAAf,oBAAA,SAAgCC,SAAmB;uBAChDC,MAAAA,eAAoBC,MAAAA,eAAsBC,MACtB,MAAtBC,gBACAC,UACAC,oBACAC,gBACuB,MAAtBC,OAAOC;;;;iCALoDT,QAA1DC,MAAAA,OAAAA,kBAAAA,SAAO,cAAA,eAAA,gBAAmDD,QAAtCE,MAAAA,OAAAA,kBAAAA,SAAOQ,QAAQC,IAAG,IAAA,eAAA,gBAAoBX,QAAhBG,MAAAA,OAAAA,kBAAAA,SAAO,OAAA,eACnDC,qBAAiBQ,wBAAK,OAAA,YAAYC,SAAG,QAAf,SAAA,SAAA,OAAmBC,YAAY,MAAM,MAAM,IAAA,EAAMC,QAAQ,SAAS,EAAA,GACxFV,eAAWO,uBAAKV,MAAM,gBAAgB,UAAU,MAAA,GAChDI,yBAAqBM,uBAAKR,gBAAgB,SAAA,GAC1CG,qBAAiBK,uBAAKV,MAAM,SAAA,GACL;;YAAMc,QAAQC,IAAG;;cAE5CC,UAAUb,QAAAA;kBACVc,kCAAAA;;;;AAH2B,wBAAA,iBAAA,MAAA,QAAA;YAAA,OAAA,KAAA;;cAAtBX,QAAsB,KAAA,CAAA,GAAfC,cAAe,KAAA,CAAA,GAK7B;;YAAO,qBAAA,eAAA,CAAA,GACFT,OAAAA,GAAAA;cACHS;cACAD;cACAJ;cACAC;cACAE;cACAD;cACAL;cACAC;cACAC;;;;;EAEJ,CAAA,GAvBsBJ,kBAAAA,MAAAA,MAAAA,SAAAA;;SA6BPmB,UAAUb,UAAgB;SAA1Ba,WAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,aAAAA;AAAAA,sBAAf,oBAAA,SAAyBb,UAAgB;QACjCe,WACAZ,OAAAA;;;;AADAY,iCAAYR,uBAAKP,UAAU,YAAA,GACX;;YAAMgB,gBAAAA,QAAQC,WAAWF,SAAAA;;;iBAAzB,OAAA,KAAA,IAClB;;YAAMC,gBAAAA,QAAQE,SAASH,SAAAA;cADL;;;;;wBAClB,OAAA,KAAA;;;;;iBACA,CAAC;;AAFCZ,yBAAAA,MAGN;;YAAOA;;;;EACT,CAAA,GANeU,WAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["getOptionsFilled", "options", "host", "root", "port", "packageRootDir", "cacheDir", "internalPatchesDir", "userPatchesDir", "state", "packageJSON", "process", "cwd", "join", "url", "__filename", "replace", "Promise", "all", "readState", "readPackageJSON", "statePath", "FSExtra", "pathExists", "readJSON"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uBAAqB,sBACrB,mBAAgC,sBAChC,gBAA8B,mBAC9B,kBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGpB,IAAMA,eAAUC,6BAAc,YAAYC,GAAG;AAI7C,SAAsBC,iBAAiBC,SAAmB;SAApCD,kBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,oBAAAA;AAAAA,6BAAf,oBAAA,SAAgCC,SAAmB;uBAChDC,MAAAA,eAAoBC,MAAAA,eAAsBC,MAE5CC,gBAEAC,UACAC,oBACAC,gBACuB,MAAtBC,OAAOC;;;;iCAPoDT,QAA1DC,MAAAA,OAAAA,kBAAAA,SAAO,cAAA,eAAA,gBAAmDD,QAAtCE,MAAAA,OAAAA,kBAAAA,SAAOQ,QAAQC,IAAG,IAAA,eAAA,gBAAoBX,QAAhBG,MAAAA,OAAAA,kBAAAA,SAAO,OAAA,eAEnDC,qBAAiBQ,uBAAKhB,SAAQiB,QAAQ,MAAA,GAAS,UAAA,GAE/CR,eAAWO,uBAAKV,MAAM,gBAAgB,UAAU,MAAA,GAChDI,yBAAqBM,uBAAKR,gBAAgB,SAAA,GAC1CG,qBAAiBK,uBAAKV,MAAM,SAAA,GACL;;YAAMY,QAAQC,IAAG;;cAE5CC,UAAUX,QAAAA;kBACVY,kCAAAA;;;;AAH2B,wBAAA,iBAAA,MAAA,QAAA;YAAA,OAAA,KAAA;;cAAtBT,QAAsB,KAAA,CAAA,GAAfC,cAAe,KAAA,CAAA,GAK7B;;YAAO,qBAAA,eAAA,CAAA,GACFT,OAAAA,GAAAA;cACHS;cACAD;cACAJ;cACAC;cACAE;cACAD;cACAL;cACAC;cACAC;;;;;EAEJ,CAAA,GAzBsBJ,kBAAAA,MAAAA,MAAAA,SAAAA;;SA+BPiB,UAAUX,UAAgB;SAA1BW,WAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,aAAAA;AAAAA,sBAAf,oBAAA,SAAyBX,UAAgB;QACjCa,WACAV,OAAAA;;;;AADAU,iCAAYN,uBAAKP,UAAU,YAAA,GACX;;YAAMc,gBAAAA,QAAQC,WAAWF,SAAAA;;;iBAAzB,OAAA,KAAA,IAClB;;YAAMC,gBAAAA,QAAQE,SAASH,SAAAA;cADL;;;;;wBAClB,OAAA,KAAA;;;;;iBACA,CAAC;;AAFCV,yBAAAA,MAGN;;YAAOA;;;;EACT,CAAA,GANeQ,WAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["require", "createRequire", "url", "getOptionsFilled", "options", "host", "root", "port", "packageRootDir", "cacheDir", "internalPatchesDir", "userPatchesDir", "state", "packageJSON", "process", "cwd", "join", "resolve", "Promise", "all", "readState", "readPackageJSON", "statePath", "FSExtra", "pathExists", "readJSON"]
 }

package/dist/cjs/utils/patches.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 patches_exports = {};
+__export(patches_exports, {
+  checkPatches: () => checkPatches
+});
+module.exports = __toCommonJS(patches_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 import_fs_extra.default.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=patches.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/patches.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;AAGA,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,gBAAAA,QAAQ,WAAW,IAAI,GAAI;AACrC,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"]
+}