vxrn 0.1.19 → 0.1.21

package/dist/esm/utils/checkPatches.js

@@ -0,0 +1,40 @@
+import findNodeModules from "find-node-modules";
+import { join } from "node:path";
+import FSExtra from "fs-extra";
+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 = findNodeModules({
+    cwd: options.root
+  }).map((relativePath) => join(options.root, relativePath)), patchesToCopy = /* @__PURE__ */ new Set();
+  await Promise.all(
+    patches.flatMap((patch) => nodeModulesDirs.flatMap(async (dir) => {
+      await FSExtra.pathExists(join(dir, patch.module)) && patchesToCopy.add(patch);
+    }))
+  );
+  let didCopy = !1;
+  for (const patch of [...patchesToCopy]) {
+    const dest = join(options.userPatchesDir, patch.patchFile);
+    if (!await pathExists(dest)) {
+      didCopy = !0, console.info(`Copying patch ${patch.module}`);
+      const src = join(options.internalPatchesDir, patch.patchFile);
+      await FSExtra.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));
+}
+export {
+  checkPatches
+};
+//# sourceMappingURL=checkPatches.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/checkPatches.ts"],
+  "mappings": "AAAA,OAAO,qBAAqB;AAC5B,SAAS,YAAY;AACrB,OAAO,aAAa;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,kBAAkB,gBAAgB;AAAA,IACtC,KAAK,QAAQ;AAAA,EACf,CAAC,EAAE,IAAI,CAAC,iBAAiB,KAAK,QAAQ,MAAM,YAAY,CAAC,GAEnD,gBAAgB,oBAAI,IAAW;AAErC,QAAM,QAAQ;AAAA,IACZ,QAAQ,QAAQ,CAAC,UACR,gBAAgB,QAAQ,OAAO,QAAQ;AAC5C,MAAI,MAAM,QAAQ,WAAW,KAAK,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,OAAO,KAAK,QAAQ,gBAAgB,MAAM,SAAS;AACzD,QAAI,CAAE,MAAM,WAAW,IAAI,GAAI;AAC7B,gBAAU,IACV,QAAQ,KAAK,iBAAiB,MAAM,MAAM,EAAE;AAC5C,YAAM,MAAM,KAAK,QAAQ,oBAAoB,MAAM,SAAS;AAC5D,YAAM,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": []
+}

package/dist/esm/utils/checkPatches.mjs

@@ -0,0 +1,31 @@
+import findNodeModules from "find-node-modules";
+import { join } from "node:path";
+import FSExtra from "fs-extra";
+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 = findNodeModules({
+      cwd: options.root
+    }).map(relativePath => join(options.root, relativePath)),
+    patchesToCopy = /* @__PURE__ */new Set();
+  await Promise.all(patches.flatMap(patch => nodeModulesDirs.flatMap(async dir => {
+    (await FSExtra.pathExists(join(dir, patch.module))) && patchesToCopy.add(patch);
+  })));
+  let didCopy = !1;
+  for (const patch of [...patchesToCopy]) {
+    const dest = join(options.userPatchesDir, patch.patchFile);
+    if (!(await pathExists(dest))) {
+      didCopy = !0, console.info(`Copying patch ${patch.module}`);
+      const src = join(options.internalPatchesDir, patch.patchFile);
+      await FSExtra.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));
+}
+export { checkPatches };

package/dist/esm/utils/checkPatches.native.js

@@ -0,0 +1,262 @@
+import findNodeModules from "find-node-modules";
+import { join } from "node:path";
+import FSExtra from "fs-extra";
+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_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 _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 _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
+    };
+  }
+}
+var patches = [
+  {
+    module: "react-native-screens",
+    patchFile: "react-native-screens+3.22.1.patch"
+  }
+];
+function checkPatches(options) {
+  return _checkPatches.apply(this, arguments);
+}
+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.state.applyPatches === !1 ? [
+            2
+          ] : (nodeModulesDirs = findNodeModules({
+            cwd: options.root
+          }).map(function(relativePath) {
+            return join(options.root, relativePath);
+          }), patchesToCopy = /* @__PURE__ */ new Set(), [
+            4,
+            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,
+                          FSExtra.pathExists(join(dir, patch2.module))
+                        ];
+                      case 1:
+                        return _state2.sent() && patchesToCopy.add(patch2), [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(dir) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+            }))
+          ]);
+        case 1:
+          _state.sent(), didCopy = !1, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            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 = join(options.userPatchesDir, patch.patchFile), [
+            4,
+            pathExists(dest)
+          ]);
+        case 4:
+          return _state.sent() ? [
+            3,
+            6
+          ] : (didCopy = !0, console.info("Copying patch ".concat(patch.module)), src = join(options.internalPatchesDir, patch.patchFile), [
+            4,
+            FSExtra.copy(src, dest)
+          ]);
+        case 5:
+          _state.sent(), _state.label = 6;
+        case 6:
+          return _iteratorNormalCompletion = !0, [
+            3,
+            3
+          ];
+        case 7:
+          return [
+            3,
+            10
+          ];
+        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
+          ];
+      }
+    });
+  }), _checkPatches.apply(this, arguments);
+}
+export {
+  checkPatches
+};
+//# sourceMappingURL=checkPatches.js.map

package/dist/esm/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,OAAOA,qBAAqB;AAC5B,SAASC,YAAY;AACrB,OAAOC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGpB,IAAMC,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,kBAAkBR,gBAAgB;YACtCgB,KAAKT,QAAQU;UACf,CAAA,EAAGC,IAAI,SAACC,cAAAA;mBAAiBlB,KAAKM,QAAQU,MAAME,YAAAA;cAEtCV,gBAAgB,oBAAIW,IAAAA,GAE1B;;YAAMC,QAAQC,IACZnB,QAAQoB,QAAQ,SAACZ,QAAAA;AACf,qBAAOH,gBAAgBe,QAAO,WAAA;2BAAC,oBAAA,SAAOC,KAAAA;;;;AAChC,+BAAA;;0BAAMtB,QAAQuB,WAAWxB,KAAKuB,KAAKb,OAAMP,MAAM,CAAA;;;AAAnD,+BAAIsB,QAAA,KAAA,KACFjB,cAAckB,IAAIhB,MAAAA;;;;;gBAEtB,CAAA;gCAJsCa,KAAAA;;;;YAKxC,CAAA,CAAA;;;AAPF,iBAAA,KAAA,GAUId,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,OAAOX,KAAKM,QAAQqB,gBAAgBjB,MAAMN,SAAS,GACnD;;YAAMoB,WAAWb,IAAAA;;;iBAAjB,OAAA,KAAA,IAAF;;;eACFF,UAAU,IACVmB,QAAQC,KAAM,iBAA6B,OAAbnB,MAAMP,MAAM,CAAA,GACpCS,MAAMZ,KAAKM,QAAQwB,oBAAoBpB,MAAMN,SAAS,GAC5D;;YAAMH,QAAQ8B,KAAKnB,KAAKD,IAAAA;;;AAAxB,iBAAA,KAAA;;AANC,6CAAA;;;;;;;;;;sCAAA,oBAAA,IAAA,iBAAA;;;;;;aAAA,6BAAA,UAAA,UAAA,QAAA,UAAA,OAAA;;gBAAA;oBAAA;;;;;;AAUL,iBAAIF,YACFmB,QAAQC,KACL;;;CAAA,GAGHG,QAAQC,KAAK,CAAA;;;;;EAEjB,CAAA,GAxCsB5B,cAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["findNodeModules", "join", "FSExtra", "patches", "module", "patchFile", "checkPatches", "options", "nodeModulesDirs", "patchesToCopy", "didCopy", "patch", "dest", "src", "state", "applyPatches", "cwd", "root", "map", "relativePath", "Set", "Promise", "all", "flatMap", "dir", "pathExists", "_state", "add", "userPatchesDir", "console", "info", "internalPatchesDir", "copy", "process", "exit"]
+}

package/dist/esm/utils/dispose.js

@@ -0,0 +1,12 @@
+const disposers = /* @__PURE__ */ new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach((cb) => cb());
+}
+export {
+  disposeAll,
+  registerDispose
+};
+//# sourceMappingURL=dispose.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/dispose.ts"],
+  "mappings": "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/esm/utils/dispose.mjs

@@ -0,0 +1,8 @@
+const disposers = /* @__PURE__ */new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach(cb => cb());
+}
+export { disposeAll, registerDispose };

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

@@ -0,0 +1,14 @@
+var disposers = /* @__PURE__ */ new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach(function(cb) {
+    return cb();
+  });
+}
+export {
+  disposeAll,
+  registerDispose
+};
+//# sourceMappingURL=dispose.js.map

package/dist/esm/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/esm/utils/getBaseViteConfig.js

@@ -1,4 +1,4 @@
-import { resolveFile } from "../createDevServer";
+import { resolveFile } from "../exports/dev";
 function getBaseViteConfig({ mode }) {
   return {
     mode,

package/dist/esm/utils/getBaseViteConfig.mjs

@@ -1,4 +1,4 @@
-import { resolveFile } from "../createDevServer.mjs";
+import { resolveFile } from "../exports/dev.mjs";
 function getBaseViteConfig({
   mode
 }) {

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

@@ -1,4 +1,4 @@
-import { resolveFile } from "../createDevServer";
+import { resolveFile } from "../exports/dev";
 function getBaseViteConfig(param) {
   var mode = param.mode;
   return {

package/dist/esm/utils/getOptionsFilled.js

@@ -1,8 +1,10 @@
 import { join } from "node:path";
 import { readPackageJSON } from "pkg-types";
+import { createRequire } from "module";
 import FSExtra from "fs-extra";
+const require2 = createRequire(import.meta.url);
 async function getOptionsFilled(options) {
-  const { host = "127.0.0.1", root = process.cwd(), port = 8081 } = options, packageRootDir = join(import.meta.url ?? __filename, "..", "..", "..").replace("file:", ""), cacheDir = join(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = join(packageRootDir, "patches"), userPatchesDir = join(root, "patches"), [state, packageJSON] = await Promise.all([
+  const { host = "127.0.0.1", root = process.cwd(), port = 8081 } = options, packageRootDir = join(require2.resolve("vxrn"), "../../.."), cacheDir = join(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = join(packageRootDir, "patches"), userPatchesDir = join(root, "patches"), [state, packageJSON] = await Promise.all([
     //
     readState(cacheDir),
     readPackageJSON()

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

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/getOptionsFilled.ts"],
-  "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,uBAAuB;AAChC,OAAO,aAAa;AAKpB,eAAsB,iBAAiB,SAAqB;AAC1D,QAAM,EAAE,OAAO,aAAa,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,SAC5D,iBAAiB,KAAK,YAAY,OAAO,YAAY,MAAM,MAAM,IAAI,EAAE,QAAQ,SAAS,EAAE,GAC1F,WAAW,KAAK,MAAM,gBAAgB,UAAU,MAAM,GACtD,qBAAqB,KAAK,gBAAgB,SAAS,GACnD,iBAAiB,KAAK,MAAM,SAAS,GACrC,CAAC,OAAO,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,IAE7C,UAAU,QAAQ;AAAA,IAClB,gBAAgB;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,YAAY,KAAK,UAAU,YAAY;AAI7C,SAHsB,MAAM,QAAQ,WAAW,SAAS,IACpD,MAAM,QAAQ,SAAS,SAAS,IAChC,CAAC;AAEP;",
-  "names": []
+  "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,OAAO,aAAa;AAGpB,MAAMA,WAAU,cAAc,YAAY,GAAG;AAI7C,eAAsB,iBAAiB,SAAqB;AAC1D,QAAM,EAAE,OAAO,aAAa,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,SAE5D,iBAAiB,KAAKA,SAAQ,QAAQ,MAAM,GAAG,UAAU,GAEzD,WAAW,KAAK,MAAM,gBAAgB,UAAU,MAAM,GACtD,qBAAqB,KAAK,gBAAgB,SAAS,GACnD,iBAAiB,KAAK,MAAM,SAAS,GACrC,CAAC,OAAO,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,IAE7C,UAAU,QAAQ;AAAA,IAClB,gBAAgB;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,YAAY,KAAK,UAAU,YAAY;AAI7C,SAHsB,MAAM,QAAQ,WAAW,SAAS,IACpD,MAAM,QAAQ,SAAS,SAAS,IAChC,CAAC;AAEP;",
+  "names": ["require"]
 }

package/dist/esm/utils/getOptionsFilled.mjs

@@ -1,13 +1,15 @@
 import { join } from "node:path";
 import { readPackageJSON } from "pkg-types";
+import { createRequire } from "module";
 import FSExtra from "fs-extra";
+const require2 = createRequire(import.meta.url);
 async function getOptionsFilled(options) {
   const {
       host = "127.0.0.1",
       root = process.cwd(),
       port = 8081
     } = options,
-    packageRootDir = join(import.meta.url ?? __filename, "..", "..", "..").replace("file:", ""),
+    packageRootDir = join(require2.resolve("vxrn"), "../../.."),
     cacheDir = join(root, "node_modules", ".cache", "vxrn"),
     internalPatchesDir = join(packageRootDir, "patches"),
     userPatchesDir = join(root, "patches"),

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

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { readPackageJSON } from "pkg-types";
+import { createRequire } from "module";
 import FSExtra from "fs-extra";
 function _array_like_to_array(arr, len) {
   (len == null || len > arr.length) && (len = arr.length);
@@ -197,16 +198,17 @@ function _ts_generator(thisArg, body) {
     };
   }
 }
+var require2 = 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 = join((_url = import.meta.url) !== null && _url !== void 0 ? _url : __filename, "..", "..", "..").replace("file:", ""), cacheDir = join(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = join(packageRootDir, "patches"), userPatchesDir = 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 = join(require2.resolve("vxrn"), "../../.."), cacheDir = join(root, "node_modules", ".cache", "vxrn"), internalPatchesDir = join(packageRootDir, "patches"), userPatchesDir = join(root, "patches"), [
             4,
             Promise.all([
               //

package/dist/esm/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,SAASA,YAAY;AACrB,SAASC,uBAAuB;AAChC,OAAOC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKpB,SAAsBC,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,iBAAiBR,MAAK,OAAA,YAAYgB,SAAG,QAAf,SAAA,SAAA,OAAmBC,YAAY,MAAM,MAAM,IAAA,EAAMC,QAAQ,SAAS,EAAA,GACxFT,WAAWT,KAAKM,MAAM,gBAAgB,UAAU,MAAA,GAChDI,qBAAqBV,KAAKQ,gBAAgB,SAAA,GAC1CG,iBAAiBX,KAAKM,MAAM,SAAA,GACL;;YAAMa,QAAQC,IAAG;;cAE5CC,UAAUZ,QAAAA;cACVR,gBAAAA;;;;AAH2B,wBAAA,iBAAA,MAAA,QAAA;YAAA,OAAA,KAAA;;cAAtBW,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;;SA6BPkB,UAAUZ,UAAgB;SAA1BY,WAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,aAAAA;AAAAA,sBAAf,oBAAA,SAAyBZ,UAAgB;QACjCa,WACAV,OAAAA;;;;AADAU,6BAAYtB,KAAKS,UAAU,YAAA,GACX;;YAAMP,QAAQqB,WAAWD,SAAAA;;;iBAAzB,OAAA,KAAA,IAClB;;YAAMpB,QAAQsB,SAASF,SAAAA;cADL;;;;;wBAClB,OAAA,KAAA;;;;;iBACA,CAAC;;AAFCV,yBAAAA,MAGN;;YAAOA;;;;EACT,CAAA,GANeS,WAAAA,MAAAA,MAAAA,SAAAA;;",
-  "names": ["join", "readPackageJSON", "FSExtra", "getOptionsFilled", "options", "host", "root", "port", "packageRootDir", "cacheDir", "internalPatchesDir", "userPatchesDir", "state", "packageJSON", "process", "cwd", "url", "__filename", "replace", "Promise", "all", "readState", "statePath", "pathExists", "readJSON"]
+  "mappings": "AAAA,SAASA,YAAY;AACrB,SAASC,uBAAuB;AAChC,SAASC,qBAAqB;AAC9B,OAAOC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGpB,IAAMC,WAAUF,cAAc,YAAYG,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,iBAAiBX,KAAKI,SAAQe,QAAQ,MAAA,GAAS,UAAA,GAE/CP,WAAWZ,KAAKS,MAAM,gBAAgB,UAAU,MAAA,GAChDI,qBAAqBb,KAAKW,gBAAgB,SAAA,GAC1CG,iBAAiBd,KAAKS,MAAM,SAAA,GACL;;YAAMW,QAAQC,IAAG;;cAE5CC,UAAUV,QAAAA;cACVX,gBAAAA;;;;AAH2B,wBAAA,iBAAA,MAAA,QAAA;YAAA,OAAA,KAAA;;cAAtBc,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+BPgB,UAAUV,UAAgB;SAA1BU,WAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,aAAAA;AAAAA,sBAAf,oBAAA,SAAyBV,UAAgB;QACjCW,WACAR,OAAAA;;;;AADAQ,6BAAYvB,KAAKY,UAAU,YAAA,GACX;;YAAMT,QAAQqB,WAAWD,SAAAA;;;iBAAzB,OAAA,KAAA,IAClB;;YAAMpB,QAAQsB,SAASF,SAAAA;cADL;;;;;wBAClB,OAAA,KAAA;;;;;iBACA,CAAC;;AAFCR,yBAAAA,MAGN;;YAAOA;;;;EACT,CAAA,GANeO,WAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["join", "readPackageJSON", "createRequire", "FSExtra", "require", "url", "getOptionsFilled", "options", "host", "root", "port", "packageRootDir", "cacheDir", "internalPatchesDir", "userPatchesDir", "state", "packageJSON", "process", "cwd", "resolve", "Promise", "all", "readState", "statePath", "pathExists", "readJSON"]
 }

package/dist/esm/utils/patches.js

@@ -0,0 +1,40 @@
+import findNodeModules from "find-node-modules";
+import { join } from "node:path";
+import FSExtra from "fs-extra";
+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 = findNodeModules({
+    cwd: options.root
+  }).map((relativePath) => join(options.root, relativePath)), patchesToCopy = /* @__PURE__ */ new Set();
+  await Promise.all(
+    patches.flatMap((patch) => nodeModulesDirs.flatMap(async (dir) => {
+      await FSExtra.pathExists(join(dir, patch.module)) && patchesToCopy.add(patch);
+    }))
+  );
+  let didCopy = !1;
+  for (const patch of [...patchesToCopy]) {
+    const dest = join(options.userPatchesDir, patch.patchFile);
+    if (!await FSExtra.pathExists(dest)) {
+      didCopy = !0, console.info(`Copying patch ${patch.module}`);
+      const src = join(options.internalPatchesDir, patch.patchFile);
+      await FSExtra.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));
+}
+export {
+  checkPatches
+};
+//# sourceMappingURL=patches.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/patches.ts"],
+  "mappings": "AAAA,OAAO,qBAAqB;AAC5B,SAAS,YAAY;AACrB,OAAO,aAAa;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,kBAAkB,gBAAgB;AAAA,IACtC,KAAK,QAAQ;AAAA,EACf,CAAC,EAAE,IAAI,CAAC,iBAAiB,KAAK,QAAQ,MAAM,YAAY,CAAC,GAEnD,gBAAgB,oBAAI,IAAW;AAErC,QAAM,QAAQ;AAAA,IACZ,QAAQ,QAAQ,CAAC,UACR,gBAAgB,QAAQ,OAAO,QAAQ;AAC5C,MAAI,MAAM,QAAQ,WAAW,KAAK,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,OAAO,KAAK,QAAQ,gBAAgB,MAAM,SAAS;AACzD,QAAI,CAAE,MAAM,QAAQ,WAAW,IAAI,GAAI;AACrC,gBAAU,IACV,QAAQ,KAAK,iBAAiB,MAAM,MAAM,EAAE;AAC5C,YAAM,MAAM,KAAK,QAAQ,oBAAoB,MAAM,SAAS;AAC5D,YAAM,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": []
+}

package/dist/esm/utils/patches.mjs

@@ -0,0 +1,31 @@
+import findNodeModules from "find-node-modules";
+import { join } from "node:path";
+import FSExtra from "fs-extra";
+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 = findNodeModules({
+      cwd: options.root
+    }).map(relativePath => join(options.root, relativePath)),
+    patchesToCopy = /* @__PURE__ */new Set();
+  await Promise.all(patches.flatMap(patch => nodeModulesDirs.flatMap(async dir => {
+    (await FSExtra.pathExists(join(dir, patch.module))) && patchesToCopy.add(patch);
+  })));
+  let didCopy = !1;
+  for (const patch of [...patchesToCopy]) {
+    const dest = join(options.userPatchesDir, patch.patchFile);
+    if (!(await FSExtra.pathExists(dest))) {
+      didCopy = !0, console.info(`Copying patch ${patch.module}`);
+      const src = join(options.internalPatchesDir, patch.patchFile);
+      await FSExtra.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));
+}
+export { checkPatches };