@guanghechen/commander 4.6.0 → 4.7.0

package/lib/cjs/{index.cjs → node.cjs}

@@ -1,30 +1,98 @@
 'use strict';
 
-var env = require('@guanghechen/env');
-var reporter = require('@guanghechen/reporter');
 var promises = require('node:fs/promises');
 var path = require('node:path');
+var env = require('@guanghechen/env');
+var reporter = require('@guanghechen/reporter');
 var fs = require('node:fs');
 
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
+const WINDOWS_DRIVE_ABSOLUTE_REGEX = /^[a-zA-Z]:[\\/]/;
+function isAbsolutePath(filepath) {
+    return (filepath.startsWith('/') ||
+        filepath.startsWith('\\\\') ||
+        WINDOWS_DRIVE_ABSOLUTE_REGEX.test(filepath));
+}
+function resolvePathFrom(base, fragment) {
+    const useWindowsStyle = WINDOWS_DRIVE_ABSOLUTE_REGEX.test(base);
+    const normalizedBase = base.replace(/\\/g, '/');
+    const normalizedFragment = fragment.replace(/\\/g, '/');
+    const source = isAbsolutePath(normalizedFragment)
+        ? normalizedFragment
+        : `${normalizedBase.replace(/\/$/, '')}/${normalizedFragment}`;
+    const prefix = useWindowsStyle ? source.slice(0, 2) : '';
+    const body = useWindowsStyle ? source.slice(2) : source;
+    const stack = [];
+    for (const token of body.split('/')) {
+        if (token === '' || token === '.') {
+            continue;
+        }
+        if (token === '..') {
+            if (stack.length > 0) {
+                stack.pop();
             }
-        });
+            continue;
+        }
+        stack.push(token);
     }
-    n.default = e;
-    return Object.freeze(n);
+    if (useWindowsStyle) {
+        const resolved = `${prefix}/${stack.join('/')}`;
+        return resolved.endsWith('/') ? resolved.slice(0, -1) : resolved;
+    }
+    return `/${stack.join('/')}`;
+}
+function createUnsupportedFsError(operation) {
+    return new Error(`runtime does not support file-system operation: ${operation}`);
+}
+function getFallbackCwd() {
+    const proc = globalThis.process;
+    if (proc && typeof proc.cwd === 'function') {
+        return proc.cwd();
+    }
+    return '/';
+}
+function createBrowserCommandRuntime() {
+    return {
+        cwd: () => getFallbackCwd(),
+        isAbsolute: filepath => isAbsolutePath(filepath),
+        resolve: (...paths) => {
+            if (paths.length === 0) {
+                return getFallbackCwd();
+            }
+            let resolved = getFallbackCwd();
+            for (const path of paths) {
+                if (path.length === 0) {
+                    continue;
+                }
+                resolved = resolvePathFrom(resolved, path);
+            }
+            return resolved;
+        },
+        readFile: async () => {
+            throw createUnsupportedFsError('readFile');
+        },
+        stat: async () => {
+            throw createUnsupportedFsError('stat');
+        },
+    };
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+let defaultRuntime = createBrowserCommandRuntime();
+function getDefaultCommandRuntime() {
+    return defaultRuntime;
+}
+function setDefaultCommandRuntime(runtime) {
+    defaultRuntime = runtime;
+}
+
+function createNodeCommandRuntime() {
+    return {
+        cwd: () => process.cwd(),
+        isAbsolute: filepath => path.isAbsolute(filepath),
+        resolve: (...paths) => path.resolve(...paths),
+        readFile: filepath => promises.readFile(filepath, 'utf8'),
+        stat: filepath => promises.stat(filepath),
+    };
+}
 
 const TERMINAL_STYLE = {
     bold: '\x1b[1m',
@@ -291,6 +359,7 @@ class Command {
     #builtin;
     #presetConfig;
     #reporter;
+    #runtime;
     #parent;
     #options = [];
     #arguments = [];
@@ -306,6 +375,7 @@ class Command {
         this.#builtin = normalizeBuiltinConfig(config.builtin);
         this.#presetConfig = config.preset;
         this.#reporter = config.reporter;
+        this.#runtime = config.runtime ?? getDefaultCommandRuntime();
     }
     get name() {
         return this.#name || undefined;
@@ -824,12 +894,12 @@ class Command {
         return await this.#assertPresetRoot(commandPreset.root, 'command.preset.root', commandPath);
     }
     async #assertPresetRoot(root, sourceName, commandPath) {
-        if (!path.isAbsolute(root)) {
+        if (!this.#runtime.isAbsolute(root)) {
             throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" is not an absolute directory`, commandPath);
         }
         let stats;
         try {
-            stats = await promises.stat(root);
+            stats = await this.#runtime.stat(root);
         }
         catch (error) {
             throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" cannot be accessed (${error.message})`, commandPath);
@@ -869,7 +939,7 @@ class Command {
                 },
             ];
         }
-        const absolutePath = path.resolve(presetRoot, defaultFilename);
+        const absolutePath = this.#runtime.resolve(presetRoot, defaultFilename);
         return [
             {
                 displayPath: absolutePath,
@@ -879,13 +949,13 @@ class Command {
         ];
     }
     #resolvePresetFileAbsolutePath(filepath, presetRoot) {
-        if (path.isAbsolute(filepath)) {
+        if (this.#runtime.isAbsolute(filepath)) {
             return filepath;
         }
         if (presetRoot !== undefined) {
-            return path.resolve(presetRoot, filepath);
+            return this.#runtime.resolve(presetRoot, filepath);
         }
-        return path.resolve(process.cwd(), filepath);
+        return this.#runtime.resolve(this.#runtime.cwd(), filepath);
     }
     #assertPresetOptionFragments(tokens, filepath, chain, optionPolicyMap) {
         if (tokens.length === 0) {
@@ -998,14 +1068,14 @@ class Command {
     }
     async #readPresetFile(file, commandPath) {
         try {
-            return await promises.readFile(file.absolutePath, 'utf8');
+            return await this.#runtime.readFile(file.absolutePath);
         }
         catch (error) {
             const ioError = error;
             if (!file.explicit && ioError.code === 'ENOENT') {
                 return undefined;
             }
-            throw new CommanderError('ConfigurationError', `failed to read preset file "${file.displayPath}": ${ioError.message}`, commandPath);
+            throw new CommanderError('ConfigurationError', `failed to read preset file "${file.displayPath}": ${error.message}`, commandPath);
         }
     }
     #tokenizePresetOptions(content) {
@@ -1775,11 +1845,11 @@ class CompletionCommand extends Command {
             if (writeOpt !== undefined) {
                 const filePath = typeof writeOpt === 'string' && writeOpt !== '' ? writeOpt : paths[shell];
                 const expandedPath = expandHome(filePath);
-                const dir = path__namespace.dirname(expandedPath);
-                if (!fs__namespace.existsSync(dir)) {
-                    fs__namespace.mkdirSync(dir, { recursive: true });
+                const dir = path.dirname(expandedPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
                 }
-                fs__namespace.writeFileSync(expandedPath, script, 'utf-8');
+                fs.writeFileSync(expandedPath, script, 'utf-8');
                 console.log(`Completion script written to: ${expandedPath}`);
             }
             else {
@@ -2072,6 +2142,8 @@ class PwshCompletion {
     }
 }
 
+setDefaultCommandRuntime(createNodeCommandRuntime());
+
 exports.BashCompletion = BashCompletion;
 exports.Coerce = Coerce;
 exports.Command = Command;
@@ -2079,6 +2151,9 @@ exports.CommanderError = CommanderError;
 exports.CompletionCommand = CompletionCommand;
 exports.FishCompletion = FishCompletion;
 exports.PwshCompletion = PwshCompletion;
+exports.createBrowserCommandRuntime = createBrowserCommandRuntime;
+exports.createNodeCommandRuntime = createNodeCommandRuntime;
+exports.getDefaultCommandRuntime = getDefaultCommandRuntime;
 exports.isDomain = isDomain;
 exports.isIp = isIp;
 exports.isIpv4 = isIpv4;
@@ -2086,4 +2161,5 @@ exports.isIpv6 = isIpv6;
 exports.logColorfulOption = logColorfulOption;
 exports.logDateOption = logDateOption;
 exports.logLevelOption = logLevelOption;
+exports.setDefaultCommandRuntime = setDefaultCommandRuntime;
 exports.silentOption = silentOption;