monoverse 0.0.3 → 0.0.4

package/build/cli.js

@@ -21899,6 +21899,345 @@ var require_express2 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+  "../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var isDocker;
+    function hasDockerEnv() {
+      try {
+        fs.statSync("/.dockerenv");
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    function hasDockerCGroup() {
+      try {
+        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+      } catch (_) {
+        return false;
+      }
+    }
+    module2.exports = () => {
+      if (isDocker === void 0) {
+        isDocker = hasDockerEnv() || hasDockerCGroup();
+      }
+      return isDocker;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+  "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var fs = require("fs");
+    var isDocker = require_is_docker();
+    var isWsl = () => {
+      if (process.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isDocker()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+      } catch (_) {
+        return false;
+      }
+    };
+    if (process.env.__IS_WSL_TEST__) {
+      module2.exports = isWsl;
+    } else {
+      module2.exports = isWsl();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js
+var require_define_lazy_prop = __commonJS({
+  "../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (object, propertyName, fn) => {
+      const define2 = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+      Object.defineProperty(object, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          const result = fn();
+          define2(result);
+          return result;
+        },
+        set(value) {
+          define2(value);
+        }
+      });
+      return object;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/open@8.4.2/node_modules/open/index.js
+var require_open = __commonJS({
+  "../../node_modules/.pnpm/open@8.4.2/node_modules/open/index.js"(exports2, module2) {
+    var path2 = require("path");
+    var childProcess = require("child_process");
+    var { promises: fs, constants: fsConstants } = require("fs");
+    var isWsl = require_is_wsl();
+    var isDocker = require_is_docker();
+    var defineLazyProperty = require_define_lazy_prop();
+    var localXdgOpenPath = path2.join(__dirname, "xdg-open");
+    var { platform, arch } = process;
+    var hasContainerEnv = () => {
+      try {
+        fs.statSync("/run/.containerenv");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    var cachedResult;
+    function isInsideContainer() {
+      if (cachedResult === void 0) {
+        cachedResult = hasContainerEnv() || isDocker();
+      }
+      return cachedResult;
+    }
+    var getWslDrivesMountPoint = (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await fs.access(configFilePath, fsConstants.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await fs.readFile(configFilePath, { encoding: "utf8" });
+        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        if (!configMountPoint) {
+          return defaultMountPoint;
+        }
+        mountPoint = configMountPoint.groups.mountPoint.trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    var pTryEach = async (array, mapper) => {
+      let latestError;
+      for (const item of array) {
+        try {
+          return await mapper(item);
+        } catch (error) {
+          latestError = error;
+        }
+      }
+      throw latestError;
+    };
+    var baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      if (Array.isArray(options.app)) {
+        return pTryEach(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp
+        }));
+      }
+      let { name: app2, arguments: appArguments = [] } = options.app || {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app2)) {
+        return pTryEach(app2, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          }
+        }));
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app2) {
+          cliArguments.push("-a", app2);
+        }
+      } else if (platform === "win32" || isWsl && !isInsideContainer() && !app2) {
+        const mountPoint = await getWslDrivesMountPoint();
+        command = isWsl ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+        cliArguments.push(
+          "-NoProfile",
+          "-NonInteractive",
+          "\u2013ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand"
+        );
+        if (!isWsl) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        const encodedArguments = ["Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app2) {
+          encodedArguments.push(`"\`"${app2}\`""`, "-ArgumentList");
+          if (options.target) {
+            appArguments.unshift(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(`"${options.target}"`);
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((arg) => `"\`"${arg}\`""`);
+          encodedArguments.push(appArguments.join(","));
+        }
+        options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+      } else {
+        if (app2) {
+          command = app2;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await fs.access(localXdgOpenPath, fsConstants.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = process.versions.electron || platform === "android" || isBundled || !exeLocalXdgOpen;
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode > 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve(subprocess);
+          });
+        });
+      }
+      subprocess.unref();
+      return subprocess;
+    };
+    var open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    var openApp = (name, options) => {
+      if (typeof name !== "string") {
+        throw new TypeError("Expected a `name`");
+      }
+      const { arguments: appArguments = [] } = options || {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    function detectArchBinary(binary) {
+      if (typeof binary === "string" || Array.isArray(binary)) {
+        return binary;
+      }
+      const { [arch]: archBinary } = binary;
+      if (!archBinary) {
+        throw new Error(`${arch} is not supported`);
+      }
+      return archBinary;
+    }
+    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+      if (wsl && isWsl) {
+        return detectArchBinary(wsl);
+      }
+      if (!platformBinary) {
+        throw new Error(`${platform} is not supported`);
+      }
+      return detectArchBinary(platformBinary);
+    }
+    var apps = {};
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      linux: ["google-chrome", "google-chrome-stable", "chromium"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    open.apps = apps;
+    open.openApp = openApp;
+    module2.exports = open;
+  }
+});
+
 // ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js
 var require_base64 = __commonJS({
   "../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js"(exports2) {
@@ -94102,6 +94441,7 @@ Defaulting to \`null\`.`;
 var path = require("path");
 var http = require("http");
 var express = require_express2();
+var openLink = require_open();
 var { createRequestHandler } = require_dist3();
 var app = express();
 var server = http.createServer(app).listen(() => {
@@ -94111,10 +94451,8 @@ var server = http.createServer(app).listen(() => {
   app.use(express.static(staticPath));
   app.all("*", createRequestHandler({ build }));
   app.set("port", port);
-  console.log(
-    `Example app listening on port ${port}! Open at http://localhost:${port}`
-  );
-  console.log(`serving public files from ${staticPath}`);
+  console.log(`Started at http://localhost:${port}`);
+  openLink(`http://localhost:${port}`);
 });
 /*! Bundled license information:
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "monoverse",
   "private": false,
-  "version": "0.0.3",
+  "version": "0.0.4",
   "sideEffects": false,
   "author": {
     "name": "Kishore",
@@ -17,33 +17,34 @@
   "dependencies": {
     "@remix-run/express": "^1.19.0",
     "cross-env": "^7.0.3",
-    "express": "^4.18.2"
+    "express": "^4.18.2",
+    "open": "^8.4.2"
   },
   "devDependencies": {
-    "@remix-run/react": "^1.18.1",
-    "@remix-run/serve": "^1.18.1",
-    "@remix-run/node": "^1.18.1",
-    "query-registry": "^2.6.0",
-    "p-limit": "^3.1.0",
-    "lodash": "^4.17.21",
-    "framer-motion": "^10.12.18",
-    "clsx": "^1.2.1",
-    "@types/semver": "^7.5.0",
     "@monorepo-utils/package-utils": "^2.10.2",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "semver": "^7.5.4",
-    "semver-diff": "3.1.1",
-    "tiny-invariant": "^1.3.1",
-    "zod": "^3.21.4",
     "@remix-run/dev": "^1.18.1",
+    "@remix-run/node": "^1.18.1",
+    "@remix-run/react": "^1.18.1",
+    "@remix-run/serve": "^1.18.1",
     "@types/express": "^4.17.17",
     "@types/lodash": "^4.14.195",
     "@types/node": "^20.4.1",
     "@types/react": "^18.2.14",
     "@types/react-dom": "^18.2.6",
+    "@types/semver": "^7.5.0",
+    "clsx": "^1.2.1",
+    "framer-motion": "^10.12.18",
+    "lodash": "^4.17.21",
     "npm-run-all": "^4.1.5",
+    "p-limit": "^3.1.0",
+    "query-registry": "^2.6.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "semver": "^7.5.4",
+    "semver-diff": "3.1.1",
+    "tiny-invariant": "^1.3.1",
     "typescript": "^5.1.6",
+    "zod": "^3.21.4",
     "@pkishorez/designsystem": "0.0.1",
     "@pkishorez/eslint": "0.0.1",
     "@pkishorez/vitest": "0.0.1"