@rspack/dev-server 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/0~open.js

@@ -0,0 +1,547 @@
+import node_process from "node:process";
+import node_child_process, { execFile } from "node:child_process";
+import promises, { constants } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { node_fs, node_os, node_path, promisify, fileURLToPath } from "./131.js";
+let isDockerCached;
+function hasDockerEnv() {
+    try {
+        node_fs.statSync('/.dockerenv');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function hasDockerCGroup() {
+    try {
+        return node_fs.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+    } catch  {
+        return false;
+    }
+}
+function isDocker() {
+    if (void 0 === isDockerCached) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+    return isDockerCached;
+}
+let cachedResult;
+const hasContainerEnv = ()=>{
+    try {
+        node_fs.statSync('/run/.containerenv');
+        return true;
+    } catch  {
+        return false;
+    }
+};
+function isInsideContainer() {
+    if (void 0 === cachedResult) cachedResult = hasContainerEnv() || isDocker();
+    return cachedResult;
+}
+const isWsl = ()=>{
+    if ('linux' !== node_process.platform) return false;
+    if (node_os.release().toLowerCase().includes('microsoft')) {
+        if (isInsideContainer()) return false;
+        return true;
+    }
+    try {
+        return node_fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') ? !isInsideContainer() : false;
+    } catch  {
+        return false;
+    }
+};
+const is_wsl = node_process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+const powershell_utils_execFile = promisify(node_child_process.execFile);
+const powerShellPath = ()=>`${node_process.env.SYSTEMROOT || node_process.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+const executePowerShell = async (command, options = {})=>{
+    const { powerShellPath: psPath, ...execFileOptions } = options;
+    const encodedCommand = executePowerShell.encodeCommand(command);
+    return powershell_utils_execFile(psPath ?? powerShellPath(), [
+        ...executePowerShell.argumentsPrefix,
+        encodedCommand
+    ], {
+        encoding: 'utf8',
+        ...execFileOptions
+    });
+};
+executePowerShell.argumentsPrefix = [
+    '-NoProfile',
+    '-NonInteractive',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-EncodedCommand'
+];
+executePowerShell.encodeCommand = (command)=>Buffer.from(command, 'utf16le').toString('base64');
+executePowerShell.escapeArgument = (value)=>`'${String(value).replaceAll('\'', '\'\'')}'`;
+function parseMountPointFromConfig(content) {
+    for (const line of content.split('\n')){
+        if (/^\s*#/.test(line)) continue;
+        const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+        if (match) return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, '');
+    }
+}
+const wsl_utils_execFile = promisify(node_child_process.execFile);
+const wslDrivesMountPoint = (()=>{
+    const defaultMountPoint = '/mnt/';
+    let mountPoint;
+    return async function() {
+        if (mountPoint) return mountPoint;
+        const configFilePath = '/etc/wsl.conf';
+        let isConfigFileExists = false;
+        try {
+            await promises.access(configFilePath, constants.F_OK);
+            isConfigFileExists = true;
+        } catch  {}
+        if (!isConfigFileExists) return defaultMountPoint;
+        const configContent = await promises.readFile(configFilePath, {
+            encoding: 'utf8'
+        });
+        const parsedMountPoint = parseMountPointFromConfig(configContent);
+        if (void 0 === parsedMountPoint) return defaultMountPoint;
+        mountPoint = parsedMountPoint;
+        mountPoint = mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+    };
+})();
+const powerShellPathFromWsl = async ()=>{
+    const mountPoint = await wslDrivesMountPoint();
+    return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+const wsl_utils_powerShellPath = is_wsl ? powerShellPathFromWsl : powerShellPath;
+let canAccessPowerShellPromise;
+const wsl_utils_canAccessPowerShell = async ()=>{
+    canAccessPowerShellPromise ??= (async ()=>{
+        try {
+            const psPath = await wsl_utils_powerShellPath();
+            await promises.access(psPath, constants.X_OK);
+            return true;
+        } catch  {
+            return false;
+        }
+    })();
+    return canAccessPowerShellPromise;
+};
+const wslDefaultBrowser = async ()=>{
+    const psPath = await wsl_utils_powerShellPath();
+    const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+    const { stdout } = await executePowerShell(command, {
+        powerShellPath: psPath
+    });
+    return stdout.trim();
+};
+const convertWslPathToWindows = async (path)=>{
+    if (/^[a-z]+:\/\//i.test(path)) return path;
+    try {
+        const { stdout } = await wsl_utils_execFile('wslpath', [
+            '-aw',
+            path
+        ], {
+            encoding: 'utf8'
+        });
+        return stdout.trim();
+    } catch  {
+        return path;
+    }
+};
+function defineLazyProperty(object, propertyName, valueGetter) {
+    const define = (value)=>Object.defineProperty(object, propertyName, {
+            value,
+            enumerable: true,
+            writable: true
+        });
+    Object.defineProperty(object, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get () {
+            const result = valueGetter();
+            define(result);
+            return result;
+        },
+        set (value) {
+            define(value);
+        }
+    });
+    return object;
+}
+const execFileAsync = promisify(execFile);
+async function defaultBrowserId() {
+    if ('darwin' !== node_process.platform) throw new Error('macOS only');
+    const { stdout } = await execFileAsync('defaults', [
+        'read',
+        'com.apple.LaunchServices/com.apple.launchservices.secure',
+        'LSHandlers'
+    ]);
+    const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+    return match?.groups.id ?? 'com.apple.Safari';
+}
+const run_applescript_execFileAsync = promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = true } = {}) {
+    if ('darwin' !== node_process.platform) throw new Error('macOS only');
+    const outputArguments = humanReadableOutput ? [] : [
+        '-ss'
+    ];
+    const { stdout } = await run_applescript_execFileAsync("osascript", [
+        '-e',
+        script,
+        outputArguments
+    ]);
+    return stdout.trim();
+}
+async function bundleName(bundleId) {
+    return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+const windows_execFileAsync = promisify(execFile);
+const windowsBrowserProgIds = {
+    MSEdgeHTM: {
+        name: 'Edge',
+        id: 'com.microsoft.edge'
+    },
+    MSEdgeBHTML: {
+        name: 'Edge Beta',
+        id: 'com.microsoft.edge.beta'
+    },
+    MSEdgeDHTML: {
+        name: 'Edge Dev',
+        id: 'com.microsoft.edge.dev'
+    },
+    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+        name: 'Edge',
+        id: 'com.microsoft.edge.old'
+    },
+    ChromeHTML: {
+        name: 'Chrome',
+        id: 'com.google.chrome'
+    },
+    ChromeBHTML: {
+        name: 'Chrome Beta',
+        id: 'com.google.chrome.beta'
+    },
+    ChromeDHTML: {
+        name: 'Chrome Dev',
+        id: 'com.google.chrome.dev'
+    },
+    ChromiumHTM: {
+        name: 'Chromium',
+        id: 'org.chromium.Chromium'
+    },
+    BraveHTML: {
+        name: 'Brave',
+        id: 'com.brave.Browser'
+    },
+    BraveBHTML: {
+        name: 'Brave Beta',
+        id: 'com.brave.Browser.beta'
+    },
+    BraveDHTML: {
+        name: 'Brave Dev',
+        id: 'com.brave.Browser.dev'
+    },
+    BraveSSHTM: {
+        name: 'Brave Nightly',
+        id: 'com.brave.Browser.nightly'
+    },
+    FirefoxURL: {
+        name: 'Firefox',
+        id: 'org.mozilla.firefox'
+    },
+    OperaStable: {
+        name: 'Opera',
+        id: 'com.operasoftware.Opera'
+    },
+    VivaldiHTM: {
+        name: 'Vivaldi',
+        id: 'com.vivaldi.Vivaldi'
+    },
+    'IE.HTTP': {
+        name: 'Internet Explorer',
+        id: 'com.microsoft.ie'
+    }
+};
+const _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+    const { stdout } = await _execFileAsync('reg', [
+        'QUERY',
+        ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+        '/v',
+        'ProgId'
+    ]);
+    const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+    if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+    const { id } = match.groups;
+    const dotIndex = id.lastIndexOf('.');
+    const hyphenIndex = id.lastIndexOf('-');
+    const baseIdByDot = -1 === dotIndex ? void 0 : id.slice(0, dotIndex);
+    const baseIdByHyphen = -1 === hyphenIndex ? void 0 : id.slice(0, hyphenIndex);
+    return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? {
+        name: id,
+        id
+    };
+}
+const default_browser_execFileAsync = promisify(execFile);
+const titleize = (string)=>string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase());
+async function default_browser_defaultBrowser() {
+    if ('darwin' === node_process.platform) {
+        const id = await defaultBrowserId();
+        const name = await bundleName(id);
+        return {
+            name,
+            id
+        };
+    }
+    if ('linux' === node_process.platform) {
+        const { stdout } = await default_browser_execFileAsync('xdg-mime', [
+            'query',
+            'default',
+            'x-scheme-handler/http'
+        ]);
+        const id = stdout.trim();
+        const name = titleize(id.replace(/.desktop$/, '').replace('-', ' '));
+        return {
+            name,
+            id
+        };
+    }
+    if ('win32' === node_process.platform) return defaultBrowser();
+    throw new Error('Only macOS, Linux, and Windows are supported');
+}
+const isInSsh = Boolean(node_process.env.SSH_CONNECTION || node_process.env.SSH_CLIENT || node_process.env.SSH_TTY);
+const is_in_ssh = isInSsh;
+const fallbackAttemptSymbol = Symbol('fallbackAttempt');
+const open_dirname = import.meta.url ? node_path.dirname(fileURLToPath(import.meta.url)) : '';
+const localXdgOpenPath = node_path.join(open_dirname, 'xdg-open');
+const { platform: platform, arch: arch } = node_process;
+const tryEachApp = async (apps, opener)=>{
+    if (0 === apps.length) return;
+    const errors = [];
+    for (const app of apps)try {
+        return await opener(app);
+    } catch (error) {
+        errors.push(error);
+    }
+    throw new AggregateError(errors, 'Failed to open in all supported apps');
+};
+const baseOpen = async (options)=>{
+    options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+    };
+    const isFallbackAttempt = true === options[fallbackAttemptSymbol];
+    delete options[fallbackAttemptSymbol];
+    if (Array.isArray(options.app)) return tryEachApp(options.app, (singleApp)=>baseOpen({
+            ...options,
+            app: singleApp,
+            [fallbackAttemptSymbol]: true
+        }));
+    let { name: app, arguments: appArguments = [] } = options.app ?? {};
+    appArguments = [
+        ...appArguments
+    ];
+    if (Array.isArray(app)) return tryEachApp(app, (appName)=>baseOpen({
+            ...options,
+            app: {
+                name: appName,
+                arguments: appArguments
+            },
+            [fallbackAttemptSymbol]: true
+        }));
+    if ('browser' === app || 'browserPrivate' === app) {
+        const ids = {
+            'com.google.chrome': 'chrome',
+            'google-chrome.desktop': 'chrome',
+            'com.brave.browser': 'brave',
+            'org.mozilla.firefox': 'firefox',
+            'firefox.desktop': 'firefox',
+            'com.microsoft.msedge': 'edge',
+            'com.microsoft.edge': 'edge',
+            'com.microsoft.edgemac': 'edge',
+            'microsoft-edge.desktop': 'edge',
+            'com.apple.safari': 'safari'
+        };
+        const flags = {
+            chrome: '--incognito',
+            brave: '--incognito',
+            firefox: '--private-window',
+            edge: '--inPrivate'
+        };
+        let browser;
+        if (is_wsl) {
+            const progId = await wslDefaultBrowser();
+            const browserInfo = _windowsBrowserProgIdMap.get(progId);
+            browser = browserInfo ?? {};
+        } else browser = await default_browser_defaultBrowser();
+        if (browser.id in ids) {
+            const browserName = ids[browser.id.toLowerCase()];
+            if ('browserPrivate' === app) {
+                if ('safari' === browserName) throw new Error('Safari doesn\'t support opening in private mode via command line');
+                appArguments.push(flags[browserName]);
+            }
+            return baseOpen({
+                ...options,
+                app: {
+                    name: open_apps[browserName],
+                    arguments: appArguments
+                }
+            });
+        }
+        throw new Error(`${browser.name} is not supported as a default browser`);
+    }
+    let command;
+    const cliArguments = [];
+    const childProcessOptions = {};
+    let shouldUseWindowsInWsl = false;
+    if (is_wsl && !isInsideContainer() && !is_in_ssh && !app) shouldUseWindowsInWsl = await wsl_utils_canAccessPowerShell();
+    if ('darwin' === platform) {
+        command = 'open';
+        if (options.wait) cliArguments.push('--wait-apps');
+        if (options.background) cliArguments.push('--background');
+        if (options.newInstance) cliArguments.push('--new');
+        if (app) cliArguments.push('-a', app);
+    } else if ('win32' === platform || shouldUseWindowsInWsl) {
+        command = await wsl_utils_powerShellPath();
+        cliArguments.push(...executePowerShell.argumentsPrefix);
+        if (!is_wsl) childProcessOptions.windowsVerbatimArguments = true;
+        if (is_wsl && options.target) options.target = await convertWslPathToWindows(options.target);
+        const encodedArguments = [
+            '$ProgressPreference = \'SilentlyContinue\';',
+            'Start'
+        ];
+        if (options.wait) encodedArguments.push('-Wait');
+        if (app) {
+            encodedArguments.push(executePowerShell.escapeArgument(app));
+            if (options.target) appArguments.push(options.target);
+        } else if (options.target) encodedArguments.push(executePowerShell.escapeArgument(options.target));
+        if (appArguments.length > 0) {
+            appArguments = appArguments.map((argument)=>executePowerShell.escapeArgument(argument));
+            encodedArguments.push('-ArgumentList', appArguments.join(','));
+        }
+        options.target = executePowerShell.encodeCommand(encodedArguments.join(' '));
+        if (!options.wait) childProcessOptions.stdio = 'ignore';
+    } else {
+        if (app) command = app;
+        else {
+            const isBundled = !open_dirname || '/' === open_dirname;
+            let exeLocalXdgOpen = false;
+            try {
+                await promises.access(localXdgOpenPath, constants.X_OK);
+                exeLocalXdgOpen = true;
+            } catch  {}
+            const useSystemXdgOpen = node_process.versions.electron ?? ('android' === platform || isBundled || !exeLocalXdgOpen);
+            command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) cliArguments.push(...appArguments);
+        if (!options.wait) {
+            childProcessOptions.stdio = 'ignore';
+            childProcessOptions.detached = true;
+        }
+    }
+    if ('darwin' === platform && appArguments.length > 0) cliArguments.push('--args', ...appArguments);
+    if (options.target) cliArguments.push(options.target);
+    const subprocess = node_child_process.spawn(command, cliArguments, childProcessOptions);
+    if (options.wait) return new Promise((resolve, reject)=>{
+        subprocess.once('error', reject);
+        subprocess.once('close', (exitCode)=>{
+            if (!options.allowNonzeroExitCode && 0 !== exitCode) return void reject(new Error(`Exited with code ${exitCode}`));
+            resolve(subprocess);
+        });
+    });
+    if (isFallbackAttempt) return new Promise((resolve, reject)=>{
+        subprocess.once('error', reject);
+        subprocess.once('spawn', ()=>{
+            subprocess.once('close', (exitCode)=>{
+                subprocess.off('error', reject);
+                if (0 !== exitCode) return void reject(new Error(`Exited with code ${exitCode}`));
+                subprocess.unref();
+                resolve(subprocess);
+            });
+        });
+    });
+    subprocess.unref();
+    return new Promise((resolve, reject)=>{
+        subprocess.once('error', reject);
+        subprocess.once('spawn', ()=>{
+            subprocess.off('error', reject);
+            resolve(subprocess);
+        });
+    });
+};
+const open_open = (target, options)=>{
+    if ('string' != typeof target) throw new TypeError('Expected a `target`');
+    return baseOpen({
+        ...options,
+        target
+    });
+};
+function detectArchBinary(binary) {
+    if ('string' == typeof binary || 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 && is_wsl) return detectArchBinary(wsl);
+    if (!platformBinary) throw new Error(`${platform} is not supported`);
+    return detectArchBinary(platformBinary);
+}
+const open_apps = {
+    browser: 'browser',
+    browserPrivate: 'browserPrivate'
+};
+defineLazyProperty(open_apps, 'chrome', ()=>detectPlatformBinary({
+        darwin: 'google chrome',
+        win32: 'chrome',
+        linux: [
+            'google-chrome',
+            'google-chrome-stable',
+            'chromium',
+            'chromium-browser'
+        ]
+    }, {
+        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(open_apps, 'brave', ()=>detectPlatformBinary({
+        darwin: 'brave browser',
+        win32: 'brave',
+        linux: [
+            'brave-browser',
+            'brave'
+        ]
+    }, {
+        wsl: {
+            ia32: '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe',
+            x64: [
+                '/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe',
+                '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe'
+            ]
+        }
+    }));
+defineLazyProperty(open_apps, 'firefox', ()=>detectPlatformBinary({
+        darwin: 'firefox',
+        win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+        linux: 'firefox'
+    }, {
+        wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+    }));
+defineLazyProperty(open_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'
+    }));
+defineLazyProperty(open_apps, 'safari', ()=>detectPlatformBinary({
+        darwin: 'Safari'
+    }));
+const node_modules_open = open_open;
+export { node_modules_open };