@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/node_modules/@yarnpkg/shell/lib/commands/entry.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fslib_1 = require("@yarnpkg/fslib");
+const clipanion_1 = require("clipanion");
+const index_1 = require("../index");
+// eslint-disable-next-line arca/no-default-export
+class EntryCommand extends clipanion_1.Command {
+    constructor() {
+        super(...arguments);
+        this.cwd = clipanion_1.Option.String(`--cwd`, process.cwd(), {
+            description: `The directory to run the command in`,
+        });
+        this.commandName = clipanion_1.Option.String();
+        this.args = clipanion_1.Option.Proxy();
+    }
+    async execute() {
+        // We assume that all arguments have to be processed by our shell,
+        // not by the user's shell
+        const command = this.args.length > 0
+            ? `${this.commandName} ${this.args.join(` `)}`
+            : this.commandName;
+        return await (0, index_1.execute)(command, [], {
+            cwd: fslib_1.npath.toPortablePath(this.cwd),
+            stdin: this.context.stdin,
+            stdout: this.context.stdout,
+            stderr: this.context.stderr,
+        });
+    }
+}
+EntryCommand.usage = {
+    description: `run a command using yarn's portable shell`,
+    details: `
+      This command will run a command using Yarn's portable shell.
+
+      Make sure to escape glob patterns, redirections, and other features that might be expanded by your own shell.
+
+      Note: To escape something from Yarn's shell, you might have to escape it twice, the first time from your own shell.
+
+      Note: Don't use this command in Yarn scripts, as Yarn's shell is automatically used.
+
+      For a list of features, visit: https://github.com/yarnpkg/berry/blob/master/packages/yarnpkg-shell/README.md.
+    `,
+    examples: [[
+            `Run a simple command`,
+            `$0 echo Hello`,
+        ], [
+            `Run a command with a glob pattern`,
+            `$0 echo '*.js'`,
+        ], [
+            `Run a command with a redirection`,
+            `$0 echo Hello World '>' hello.txt`,
+        ], [
+            `Run a command with an escaped glob pattern (The double escape is needed in Unix shells)`,
+            `$0 echo '"*.js"'`,
+        ], [
+            `Run a command with a variable (Double quotes are needed in Unix shells, to prevent them from expanding the variable)`,
+            `$0 "GREETING=Hello echo $GREETING World"`,
+        ]],
+};
+exports.default = EntryCommand;

package/dist/wasm/node_modules/@yarnpkg/shell/lib/errors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A recoverable shell error.
+ */
+export declare class ShellError extends Error {
+    constructor(message: string);
+}

package/dist/wasm/node_modules/@yarnpkg/shell/lib/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellError = void 0;
+/**
+ * A recoverable shell error.
+ */
+class ShellError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = `ShellError`;
+    }
+}
+exports.ShellError = ShellError;

package/dist/wasm/node_modules/@yarnpkg/shell/lib/globUtils.d.ts

@@ -0,0 +1,23 @@
+import { PortablePath, FakeFS } from '@yarnpkg/fslib';
+import fastGlob from 'fast-glob';
+import micromatch from 'micromatch';
+export type Glob = {
+    isGlobPattern: (pattern: string) => boolean;
+    match: (pattern: string, options: {
+        cwd: PortablePath;
+        baseFs: FakeFS<PortablePath>;
+    }) => Promise<Array<string>>;
+};
+export declare const micromatchOptions: micromatch.Options;
+export declare const fastGlobOptions: fastGlob.Options;
+/**
+ * Decides whether a string is a glob pattern, using micromatch.
+ *
+ * Required because `fastGlob.isDynamicPattern` doesn't have the `strictBrackets` option.
+ */
+export declare function isGlobPattern(pattern: string): boolean;
+export declare function match(pattern: string, { cwd, baseFs }: {
+    cwd: PortablePath;
+    baseFs: FakeFS<PortablePath>;
+}): Promise<string[]>;
+export declare function isBraceExpansion(pattern: string): boolean;

package/dist/wasm/node_modules/@yarnpkg/shell/lib/globUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastGlobOptions = exports.micromatchOptions = void 0;
+exports.isGlobPattern = isGlobPattern;
+exports.match = match;
+exports.isBraceExpansion = isBraceExpansion;
+const tslib_1 = require("tslib");
+const fslib_1 = require("@yarnpkg/fslib");
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+exports.micromatchOptions = {
+    // This is required because we don't want ")/*" to be a valid shell glob pattern.
+    strictBrackets: true,
+};
+exports.fastGlobOptions = {
+    onlyDirectories: false,
+    onlyFiles: false,
+};
+/**
+ * Decides whether a string is a glob pattern, using micromatch.
+ *
+ * Required because `fastGlob.isDynamicPattern` doesn't have the `strictBrackets` option.
+ */
+function isGlobPattern(pattern) {
+    // The scanner extracts globs from a pattern, but doesn't throw errors
+    if (!micromatch_1.default.scan(pattern, exports.micromatchOptions).isGlob)
+        return false;
+    // The parser is the one that throws errors
+    try {
+        micromatch_1.default.parse(pattern, exports.micromatchOptions);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function match(pattern, { cwd, baseFs }) {
+    return (0, fast_glob_1.default)(pattern, {
+        ...exports.fastGlobOptions,
+        cwd: fslib_1.npath.fromPortablePath(cwd),
+        fs: (0, fslib_1.extendFs)(fs_1.default, new fslib_1.PosixFS(baseFs)),
+    });
+}
+function isBraceExpansion(pattern) {
+    return micromatch_1.default.scan(pattern, exports.micromatchOptions).isBrace;
+}

package/dist/wasm/node_modules/@yarnpkg/shell/lib/index.d.ts

@@ -0,0 +1,56 @@
+import { PortablePath, FakeFS } from '@yarnpkg/fslib';
+import { Readable, Writable } from 'stream';
+import EntryCommand from './commands/entry';
+import { ShellError } from './errors';
+import * as globUtils from './globUtils';
+import { ProcessImplementation } from './pipe';
+export { EntryCommand };
+export { ShellError };
+export { globUtils };
+export type Glob = globUtils.Glob;
+export type UserOptions = {
+    baseFs: FakeFS<PortablePath>;
+    builtins: {
+        [key: string]: ShellBuiltin;
+    };
+    cwd: PortablePath;
+    env: {
+        [key: string]: string | undefined;
+    };
+    stdin: Readable | null;
+    stdout: Writable;
+    stderr: Writable;
+    variables: {
+        [key: string]: string;
+    };
+    glob: globUtils.Glob;
+};
+export type ShellBuiltin = (args: Array<string>, opts: ShellOptions, state: ShellState) => Promise<number>;
+export type ShellOptions = {
+    args: Array<string>;
+    baseFs: FakeFS<PortablePath>;
+    builtins: Map<string, ShellBuiltin>;
+    initialStdin: Readable;
+    initialStdout: Writable;
+    initialStderr: Writable;
+    glob: globUtils.Glob;
+};
+export type ShellState = {
+    cwd: PortablePath;
+    environment: {
+        [key: string]: string;
+    };
+    exitCode: number | null;
+    procedures: {
+        [key: string]: ProcessImplementation;
+    };
+    stdin: Readable;
+    stdout: Writable;
+    stderr: Writable;
+    variables: {
+        [key: string]: string;
+    };
+    nextBackgroundJobIndex: number;
+    backgroundJobs: Array<Promise<unknown>>;
+};
+export declare function execute(command: string, args?: Array<string>, { baseFs, builtins, cwd, env, stdin, stdout, stderr, variables, glob, }?: Partial<UserOptions>): Promise<number>;