vxrn 0.0.6 → 0.1.0

package/dist/esm/dev/createDevServer.mjs

@@ -0,0 +1,101 @@
+import mime from "mime/lite";
+import { DEFAULT_PORT } from "../utils/constants.mjs";
+import { createServer } from "../vendor/repack/dev-server/src/index.mjs";
+import { bindKeypressInput } from "./bindKeypressInput.mjs";
+async function createDevServer(options, {
+  listenForHMR,
+  hotUpdatedCJSFiles
+}) {
+  return await createServer({
+    options: {
+      rootDir: options.root,
+      host: options.host,
+      port: options.port ?? DEFAULT_PORT
+      // https: args.https
+      //   ? {
+      //       cert: args.cert,
+      //       key: args.key,
+      //     }
+      //   : undefined,
+    },
+    delegate: ctx => {
+      bindKeypressInput(ctx);
+      const platform = "ios";
+      return listenForHMR(update => {
+        ctx.notifyBuildEnd(platform), ctx.broadcastToHmrClients({
+          action: "built",
+          body: {
+            errors: [],
+            warnings: [],
+            hash: `${Math.random()}`,
+            modules: {},
+            name: "",
+            time: 0
+          }
+        }, platform);
+      }), {
+        hotFiles: {
+          getSource: path => hotUpdatedCJSFiles.get(path) || ""
+        },
+        compiler: {
+          getAsset: async (filename, platform2, sendProgress) => (console.info("[GET] - ", filename), ""),
+          getMimeType: filename => mime.getType(filename) || "application/javascript",
+          inferPlatform: uri => {
+            const url = new URL(uri, "protocol://domain");
+            if (!url.searchParams.get("platform")) {
+              const [, platform2] = /^\/(.+)\/.+$/.exec(url.pathname) ?? [];
+              return platform2;
+            }
+          }
+        },
+        symbolicator: {
+          getSource: async fileUrl => (console.info("get source", fileUrl), ""),
+          getSourceMap: async fileUrl => "",
+          shouldIncludeFrame: frame => !/webpack[/\\]runtime[/\\].+\s/.test(frame.file)
+        },
+        hmr: {
+          getUriPath: () => "/__hmr",
+          onClientConnected: (platform2, clientId) => {}
+        },
+        messages: {
+          getStatus: () => "packager-status:running"
+        },
+        logger: {
+          onMessage: log => {
+            const logEntry = makeLogEntryFromFastifyLog(log);
+            logEntry.issuer = "DevServer", logEntry.type !== "debug" && console.info("[logger]", logEntry.type === "info" ? "" : logEntry.type, logEntry.message.map(m => `${m.msg}`).join(", "));
+          }
+        },
+        api: {
+          // getPlatforms: async () => Object.keys(compiler.workers),
+          getPlatforms: async () => ["ios"],
+          getAssets: async platform2 => (console.info("get assets", platform2), []),
+          getCompilationStats: async platform2 => null
+        }
+      };
+    }
+  });
+}
+function makeLogEntryFromFastifyLog(data) {
+  const {
+    level,
+    time,
+    pid,
+    hostname,
+    ...rest
+  } = data;
+  return {
+    type: {
+      10: "debug",
+      20: "debug",
+      30: "info",
+      40: "warn",
+      50: "error",
+      60: "error"
+    }[level],
+    timestamp: time,
+    issuer: "",
+    message: [rest]
+  };
+}
+export { createDevServer };

package/dist/esm/dev/createDevServer.native.js

@@ -0,0 +1,398 @@
+import mime from "mime/lite";
+import { DEFAULT_PORT } from "../utils/constants";
+import { createServer } from "../vendor/repack/dev-server/src";
+import { bindKeypressInput } from "./bindKeypressInput";
+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 _object_without_properties(source, excluded) {
+  if (source == null)
+    return {};
+  var target = _object_without_properties_loose(source, excluded), key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++)
+      key = sourceSymbolKeys[i], !(excluded.indexOf(key) >= 0) && Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
+  }
+  return target;
+}
+function _object_without_properties_loose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {}, sourceKeys = Object.keys(source), key, i;
+  for (i = 0; i < sourceKeys.length; i++)
+    key = sourceKeys[i], !(excluded.indexOf(key) >= 0) && (target[key] = source[key]);
+  return target;
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _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
+    };
+  }
+}
+function createDevServer(options, _) {
+  return _createDevServer.apply(this, arguments);
+}
+function _createDevServer() {
+  return _createDevServer = _async_to_generator(function(options, param) {
+    var listenForHMR, hotUpdatedCJSFiles, _options_port;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return listenForHMR = param.listenForHMR, hotUpdatedCJSFiles = param.hotUpdatedCJSFiles, [
+            4,
+            createServer({
+              options: {
+                rootDir: options.root,
+                host: options.host,
+                port: (_options_port = options.port) !== null && _options_port !== void 0 ? _options_port : DEFAULT_PORT
+              },
+              // https: args.https
+              //   ? {
+              //       cert: args.cert,
+              //       key: args.key,
+              //     }
+              //   : undefined,
+              delegate: function(ctx) {
+                bindKeypressInput(ctx);
+                var platform = "ios";
+                return listenForHMR(function(update) {
+                  ctx.notifyBuildEnd(platform), ctx.broadcastToHmrClients({
+                    action: "built",
+                    body: {
+                      errors: [],
+                      warnings: [],
+                      hash: "".concat(Math.random()),
+                      modules: {},
+                      name: "",
+                      time: 0
+                    }
+                  }, platform);
+                }), {
+                  hotFiles: {
+                    getSource: function(path) {
+                      var next = hotUpdatedCJSFiles.get(path);
+                      return next || "";
+                    }
+                  },
+                  compiler: {
+                    getAsset: function() {
+                      var _ref = _async_to_generator(function(filename, platform2, sendProgress) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("[GET] - ", filename), [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(filename, platform2, sendProgress) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    // return (await compiler.getAsset(filename, platform, sendProgress)).data
+                    getMimeType: function(filename) {
+                      return mime.getType(filename) || "application/javascript";
+                    },
+                    inferPlatform: function(uri) {
+                      var url = new URL(uri, "protocol://domain");
+                      if (!url.searchParams.get("platform")) {
+                        var _exec, _ref = _sliced_to_array((_exec = /^\/(.+)\/.+$/.exec(url.pathname)) !== null && _exec !== void 0 ? _exec : [], 2), platform2 = _ref[1];
+                        return platform2;
+                      }
+                    }
+                  },
+                  symbolicator: {
+                    getSource: function() {
+                      var _ref = _async_to_generator(function(fileUrl) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("get source", fileUrl), [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(fileUrl) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    getSourceMap: function() {
+                      var _ref = _async_to_generator(function(fileUrl) {
+                        return _ts_generator(this, function(_state2) {
+                          return [
+                            2,
+                            ""
+                          ];
+                        });
+                      });
+                      return function(fileUrl) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    shouldIncludeFrame: function(frame) {
+                      return !/webpack[/\\]runtime[/\\].+\s/.test(frame.file);
+                    }
+                  },
+                  hmr: {
+                    getUriPath: function() {
+                      return "/__hmr";
+                    },
+                    onClientConnected: function(platform2, clientId) {
+                    }
+                  },
+                  // todo
+                  // const lastStats = {}
+                  // ctx.broadcastToHmrClients(
+                  //   { action: 'sync', body: createHmrBody(lastStats) },
+                  //   platform,
+                  //   [clientId]
+                  // )
+                  messages: {
+                    getStatus: function() {
+                      return "packager-status:running";
+                    }
+                  },
+                  logger: {
+                    onMessage: function(log) {
+                      var logEntry = makeLogEntryFromFastifyLog(log);
+                      logEntry.issuer = "DevServer", logEntry.type !== "debug" && console.info("[logger]", logEntry.type === "info" ? "" : logEntry.type, logEntry.message.map(function(m) {
+                        return "".concat(m.msg);
+                      }).join(", "));
+                    }
+                  },
+                  // reporter.process(logEntry)
+                  api: {
+                    // getPlatforms: async () => Object.keys(compiler.workers),
+                    getPlatforms: /* @__PURE__ */ _async_to_generator(function() {
+                      return _ts_generator(this, function(_state2) {
+                        return [
+                          2,
+                          [
+                            "ios"
+                          ]
+                        ];
+                      });
+                    }),
+                    getAssets: function() {
+                      var _ref = _async_to_generator(function(platform2) {
+                        return _ts_generator(this, function(_state2) {
+                          return console.info("get assets", platform2), [
+                            2,
+                            []
+                          ];
+                        });
+                      });
+                      return function(platform2) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }(),
+                    // return Object.entries(compiler.assetsCache[platform] ?? {}).map(([name, asset]) => ({
+                    //   name,
+                    //   size: asset.info.size,
+                    // })),
+                    getCompilationStats: function() {
+                      var _ref = _async_to_generator(function(platform2) {
+                        return _ts_generator(this, function(_state2) {
+                          return [
+                            2,
+                            null
+                          ];
+                        });
+                      });
+                      return function(platform2) {
+                        return _ref.apply(this, arguments);
+                      };
+                    }()
+                  }
+                };
+              }
+            })
+          ];
+        case 1:
+          return [
+            2,
+            _state.sent()
+          ];
+      }
+    });
+  }), _createDevServer.apply(this, arguments);
+}
+function makeLogEntryFromFastifyLog(data) {
+  var level = data.level, time = data.time, pid = data.pid, hostname = data.hostname, rest = _object_without_properties(data, [
+    "level",
+    "time",
+    "pid",
+    "hostname"
+  ]), levelToTypeMapping = {
+    10: "debug",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "error"
+  };
+  return {
+    type: levelToTypeMapping[level],
+    timestamp: time,
+    issuer: "",
+    message: [
+      rest
+    ]
+  };
+}
+export {
+  createDevServer
+};
+//# sourceMappingURL=createDevServer.js.map

package/dist/esm/dev/createDevServer.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/dev/Users/n8/vxrn/packages/vxrn/src/dev/createDevServer.ts"],
+  "mappings": "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",
+  "names": ["mime", "DEFAULT_PORT", "createServer", "bindKeypressInput", "createDevServer", "options", "listenForHMR", "hotUpdatedCJSFiles", "rootDir", "root", "host", "port", "delegate", "ctx", "platform", "update", "notifyBuildEnd", "broadcastToHmrClients", "action", "body", "errors", "warnings", "hash", "Math", "random", "modules", "name", "time", "hotFiles", "getSource", "path", "next", "get", "compiler", "getAsset", "filename", "sendProgress", "console", "info", "getMimeType", "getType", "inferPlatform", "uri", "url", "URL", "searchParams", "exec", "pathname", "symbolicator", "fileUrl", "getSourceMap", "shouldIncludeFrame", "frame", "test", "file", "hmr", "getUriPath", "onClientConnected", "clientId", "messages", "getStatus", "logger", "onMessage", "log", "logEntry", "makeLogEntryFromFastifyLog", "issuer", "type", "message", "map", "m", "msg", "join", "api", "getPlatforms", "getAssets", "getCompilationStats", "makeLogEntryFromFastifyLog", "data", "level", "time", "pid", "hostname", "rest", "levelToTypeMapping", "type", "timestamp", "issuer", "message"]
+}

package/dist/esm/getVitePath.js

@@ -0,0 +1,28 @@
+import { join, relative, dirname } from "path";
+import resolve from "esm-resolve";
+import FSExtra from "fs-extra";
+async function getVitePath(rootPath, importer, moduleName, absolute = !1) {
+  if (moduleName === "react-native")
+    return "react-native";
+  if (moduleName === "react")
+    return "react";
+  if (moduleName === "react/jsx-runtime")
+    return "react/jsx-runtime";
+  if (moduleName === "react/jsx-dev-runtime")
+    return "react/jsx-dev-runtime";
+  if (moduleName[0] === ".") {
+    const rootAt = importer.indexOf(rootPath);
+    return join(dirname(importer.slice(rootAt)), moduleName) + ".js";
+  } else {
+    const sourceFile = join(process.cwd(), "index.js"), resolved = resolve(sourceFile)(moduleName);
+    if (!resolved)
+      throw new Error("\u274C cant find");
+    const real = await FSExtra.realpath(resolved);
+    let id = real;
+    return absolute || (id = relative(importer, real)), id.endsWith("/react/jsx-dev-runtime.js") && (id = "react/jsx-runtime"), id;
+  }
+}
+export {
+  getVitePath
+};
+//# sourceMappingURL=getVitePath.js.map

package/dist/esm/getVitePath.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/getVitePath.ts"],
+  "mappings": "AAAA,SAAS,MAAM,UAAU,eAAe;AAExC,OAAO,aAAa;AACpB,OAAO,aAAa;AAEpB,eAAsB,YACpB,UACA,UACA,YACA,WAAW,IACX;AAEA,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAET,MAAI,eAAe;AACjB,WAAO;AAGT,MAAI,WAAW,CAAC,MAAM,KAAK;AACzB,UAAM,SAAS,SAAS,QAAQ,QAAQ;AAExC,WADa,KAAK,QAAQ,SAAS,MAAM,MAAM,CAAC,GAAG,UAAU,IAC/C;AAAA,EAChB,OAAO;AACL,UAAM,aAAa,KAAK,QAAQ,IAAI,GAAG,UAAU,GAC3C,WAAW,QAAQ,UAAU,EAAE,UAAU;AAE/C,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,kBAAa;AAE/B,UAAM,OAAO,MAAM,QAAQ,SAAS,QAAQ;AAC5C,QAAI,KAAK;AACT,WAAK,aACH,KAAK,SAAS,UAAU,IAAI,IAE1B,GAAG,SAAS,2BAA2B,MACzC,KAAK,sBAEA;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/esm/getVitePath.mjs

@@ -0,0 +1,21 @@
+import { join, relative, dirname } from "path";
+import resolve from "esm-resolve";
+import FSExtra from "fs-extra";
+async function getVitePath(rootPath, importer, moduleName, absolute = !1) {
+  if (moduleName === "react-native") return "react-native";
+  if (moduleName === "react") return "react";
+  if (moduleName === "react/jsx-runtime") return "react/jsx-runtime";
+  if (moduleName === "react/jsx-dev-runtime") return "react/jsx-dev-runtime";
+  if (moduleName[0] === ".") {
+    const rootAt = importer.indexOf(rootPath);
+    return join(dirname(importer.slice(rootAt)), moduleName) + ".js";
+  } else {
+    const sourceFile = join(process.cwd(), "index.js"),
+      resolved = resolve(sourceFile)(moduleName);
+    if (!resolved) throw new Error("\u274C cant find");
+    const real = await FSExtra.realpath(resolved);
+    let id = real;
+    return absolute || (id = relative(importer, real)), id.endsWith("/react/jsx-dev-runtime.js") && (id = "react/jsx-runtime"), id;
+  }
+}
+export { getVitePath };