projen 0.99.2 → 0.99.4

package/node_modules/shelljs/shell.js

@@ -0,0 +1,214 @@
+//
+// ShellJS
+// Unix shell commands on top of Node's API
+//
+// Copyright (c) 2012 Artur Adib
+// http://github.com/shelljs/shelljs
+//
+
+var common = require('./src/common');
+
+//@
+//@ All commands run synchronously, unless otherwise stated.
+//@ All commands accept standard bash globbing characters (`*`, `?`, etc.),
+//@ compatible with [`fast-glob`](https://www.npmjs.com/package/fast-glob).
+//@
+//@ For less-commonly used commands and features, please check out our [wiki
+//@ page](https://github.com/shelljs/shelljs/wiki).
+//@
+
+// Include the docs for all the default commands
+//@commands
+
+// Load all default commands. We import these for their side effect of loading
+// using the plugin architecture via `common.register()`.
+require('./src/cat');
+require('./src/cd');
+require('./src/chmod');
+require('./src/cmd');
+require('./src/cp');
+require('./src/dirs');
+require('./src/echo');
+require('./src/exec');
+require('./src/exec-child'); // A hint to the bundler to keep exec-child.js
+require('./src/find');
+require('./src/grep');
+require('./src/head');
+require('./src/ln');
+require('./src/ls');
+require('./src/mkdir');
+require('./src/mv');
+require('./src/popd');
+require('./src/pushd');
+require('./src/pwd');
+require('./src/rm');
+require('./src/sed');
+require('./src/set');
+require('./src/sort');
+require('./src/tail');
+require('./src/tempdir');
+require('./src/test');
+require('./src/to');
+require('./src/toEnd');
+require('./src/touch');
+require('./src/uniq');
+require('./src/which');
+
+//@
+//@ ### exit(code)
+//@
+//@ Exits the current process with the given exit `code`.
+exports.exit = function exit(code) {
+  common.state.error = null;
+  common.state.errorCode = 0;
+  if (code) {
+    common.error('exit', {
+      continue: true,
+      code: code,
+      prefix: '',
+      silent: true,
+      fatal: false,
+    });
+    process.exit(code);
+  } else {
+    process.exit();
+  }
+};
+
+//@include ./src/error.js
+exports.error = require('./src/error');
+
+//@include ./src/errorCode.js
+exports.errorCode = require('./src/errorCode');
+
+//@include ./src/common.js
+exports.ShellString = common.ShellString;
+
+//@
+//@ ### env['VAR_NAME']
+//@
+//@ Object containing environment variables (both getter and setter). Shortcut
+//@ to `process.env`.
+exports.env = process.env;
+
+//@
+//@ ### Pipes
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ grep('foo', 'file1.txt', 'file2.txt').sed(/o/g, 'a').to('output.txt');
+//@ echo("files with o's in the name:\n" + ls().grep('o'));
+//@ cat('test.js').exec('node'); // pipe to exec() call
+//@ ```
+//@
+//@ Commands can send their output to another command in a pipe-like fashion.
+//@ `sed`, `grep`, `cat`, `exec`, `to`, and `toEnd` can appear on the right-hand
+//@ side of a pipe. Pipes can be chained.
+
+//@
+//@ ## Configuration
+//@
+
+exports.config = common.config;
+
+//@
+//@ ### config.silent
+//@
+//@ Example:
+//@
+//@ ```javascript
+//@ var sh = require('shelljs');
+//@ var silentState = sh.config.silent; // save old silent state
+//@ sh.config.silent = true;
+//@ /* ... */
+//@ sh.config.silent = silentState; // restore old silent state
+//@ ```
+//@
+//@ Suppresses all command output if `true`, except for `echo()` calls.
+//@ Default is `false`.
+
+//@
+//@ ### config.fatal
+//@
+//@ Example:
+//@
+//@ ```javascript
+//@ require('shelljs/global');
+//@ config.fatal = true; // or set('-e');
+//@ cp('this_file_does_not_exist', '/dev/null'); // throws Error here
+//@ /* more commands... */
+//@ ```
+//@
+//@ If `true`, the script will throw a Javascript error when any shell.js
+//@ command encounters an error. Default is `false`. This is analogous to
+//@ Bash's `set -e`.
+
+//@
+//@ ### config.verbose
+//@
+//@ Example:
+//@
+//@ ```javascript
+//@ config.verbose = true; // or set('-v');
+//@ cd('dir/');
+//@ rm('-rf', 'foo.txt', 'bar.txt');
+//@ exec('echo hello');
+//@ ```
+//@
+//@ Will print each command as follows:
+//@
+//@ ```
+//@ cd dir/
+//@ rm -rf foo.txt bar.txt
+//@ exec echo hello
+//@ ```
+
+//@
+//@ ### config.globOptions (deprecated)
+//@
+//@ **Deprecated**: we recommend that you do not edit `config.globOptions`.
+//@ Support for this configuration option may be changed or removed in a future
+//@ ShellJS release.
+//@
+//@ **Breaking change**: ShellJS v0.8.x uses `node-glob`. Starting with ShellJS
+//@ v0.9.x, `config.globOptions` is compatible with `fast-glob`.
+//@
+//@ Example:
+//@
+//@ ```javascript
+//@ config.globOptions = {nodir: true};
+//@ ```
+//@
+//@ `config.globOptions` changes how ShellJS expands glob (wildcard)
+//@ expressions. See
+//@ [fast-glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#options-3)
+//@ for available options. Be aware that modifying `config.globOptions` **may
+//@ break ShellJS functionality.**
+
+//@
+//@ ### config.reset()
+//@
+//@ Example:
+//@
+//@ ```javascript
+//@ var shell = require('shelljs');
+//@ // Make changes to shell.config, and do stuff...
+//@ /* ... */
+//@ shell.config.reset(); // reset to original state
+//@ // Do more stuff, but with original settings
+//@ /* ... */
+//@ ```
+//@
+//@ Reset `shell.config` to the defaults:
+//@
+//@ ```javascript
+//@ {
+//@   fatal: false,
+//@   globOptions: {},
+//@   maxdepth: 255,
+//@   noglob: false,
+//@   silent: false,
+//@   verbose: false,
+//@ }
+//@ ```

package/node_modules/shelljs/src/cat.js

@@ -0,0 +1,76 @@
+var common = require('./common');
+var fs = require('fs');
+
+common.register('cat', _cat, {
+  canReceivePipe: true,
+  cmdOptions: {
+    'n': 'number',
+  },
+});
+
+//@
+//@ ### cat([options,] file [, file ...])
+//@ ### cat([options,] file_array)
+//@
+//@ Available options:
+//@
+//@ + `-n`: number all output lines
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ var str = cat('file*.txt');
+//@ var str = cat('file1', 'file2');
+//@ var str = cat(['file1', 'file2']); // same as above
+//@ ```
+//@
+//@ Returns a [ShellString](#shellstringstr) containing the given file, or a
+//@ concatenated string containing the files if more than one file is given (a
+//@ new line character is introduced between each file).
+function _cat(options, files) {
+  var cat = common.readFromPipe();
+
+  if (!files && !cat) common.error('no paths given');
+
+  files = [].slice.call(arguments, 1);
+
+  files.forEach(function (file) {
+    if (!fs.existsSync(file)) {
+      common.error('no such file or directory: ' + file);
+    } else if (common.statFollowLinks(file).isDirectory()) {
+      common.error(file + ': Is a directory');
+    }
+
+    cat += fs.readFileSync(file, 'utf8');
+  });
+
+  if (options.number) {
+    cat = addNumbers(cat);
+  }
+
+  return cat;
+}
+module.exports = _cat;
+
+function addNumbers(cat) {
+  var lines = cat.split('\n');
+  var lastLine = lines.pop();
+
+  lines = lines.map(function (line, i) {
+    return numberedLine(i + 1, line);
+  });
+
+  if (lastLine.length) {
+    lastLine = numberedLine(lines.length + 1, lastLine);
+  }
+  lines.push(lastLine);
+
+  return lines.join('\n');
+}
+
+function numberedLine(n, line) {
+  // GNU cat use six pad start number + tab. See http://lingrok.org/xref/coreutils/src/cat.c#57
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
+  var number = ('     ' + n).slice(-6) + '\t';
+  return number + line;
+}

package/node_modules/shelljs/src/cd.js

@@ -0,0 +1,40 @@
+var os = require('os');
+var common = require('./common');
+
+common.register('cd', _cd, {});
+
+//@
+//@ ### cd([dir])
+//@
+//@ Changes to directory `dir` for the duration of the script. Changes to home
+//@ directory if no argument is supplied. Returns a
+//@ [ShellString](#shellstringstr) to indicate success or failure.
+function _cd(options, dir) {
+  if (!dir) dir = os.homedir();
+
+  if (dir === '-') {
+    if (!process.env.OLDPWD) {
+      common.error('could not find previous directory');
+    } else {
+      dir = process.env.OLDPWD;
+    }
+  }
+
+  try {
+    var curDir = process.cwd();
+    process.chdir(dir);
+    process.env.OLDPWD = curDir;
+  } catch (e) {
+    // something went wrong, let's figure out the error
+    var err;
+    try {
+      common.statFollowLinks(dir); // if this succeeds, it must be some sort of file
+      err = 'not a directory: ' + dir;
+    } catch (e2) {
+      err = 'no such file or directory: ' + dir;
+    }
+    if (err) common.error(err);
+  }
+  return '';
+}
+module.exports = _cd;

package/node_modules/shelljs/src/chmod.js

@@ -0,0 +1,222 @@
+var common = require('./common');
+var fs = require('fs');
+var path = require('path');
+
+var PERMS = (function (base) {
+  return {
+    OTHER_EXEC: base.EXEC,
+    OTHER_WRITE: base.WRITE,
+    OTHER_READ: base.READ,
+
+    GROUP_EXEC: base.EXEC << 3,
+    GROUP_WRITE: base.WRITE << 3,
+    GROUP_READ: base.READ << 3,
+
+    OWNER_EXEC: base.EXEC << 6,
+    OWNER_WRITE: base.WRITE << 6,
+    OWNER_READ: base.READ << 6,
+
+    // Literal octal numbers are apparently not allowed in "strict" javascript.
+    STICKY: parseInt('01000', 8),
+    SETGID: parseInt('02000', 8),
+    SETUID: parseInt('04000', 8),
+
+    TYPE_MASK: parseInt('0770000', 8),
+  };
+}({
+  EXEC: 1,
+  WRITE: 2,
+  READ: 4,
+}));
+
+common.register('chmod', _chmod, {
+});
+
+//@
+//@ ### chmod([options,] octal_mode || octal_string, file)
+//@ ### chmod([options,] symbolic_mode, file)
+//@
+//@ Available options:
+//@
+//@ + `-v`: output a diagnostic for every file processed//@
+//@ + `-c`: like verbose, but report only when a change is made//@
+//@ + `-R`: change files and directories recursively//@
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ chmod(755, '/Users/brandon');
+//@ chmod('755', '/Users/brandon'); // same as above
+//@ chmod('u+x', '/Users/brandon');
+//@ chmod('-R', 'a-w', '/Users/brandon');
+//@ ```
+//@
+//@ Alters the permissions of a file or directory by either specifying the
+//@ absolute permissions in octal form or expressing the changes in symbols.
+//@ This command tries to mimic the POSIX behavior as much as possible.
+//@ Notable exceptions:
+//@
+//@ + In symbolic modes, `a-r` and `-r` are identical.  No consideration is
+//@   given to the `umask`.
+//@ + There is no "quiet" option, since default behavior is to run silent.
+//@ + Windows OS uses a very different permission model than POSIX. `chmod()`
+//@   does its best on Windows, but there are limits to how file permissions can
+//@   be set. Note that WSL (Windows subsystem for Linux) **does** follow POSIX,
+//@   so cross-platform compatibility should not be a concern there.
+//@
+//@ Returns a [ShellString](#shellstringstr) indicating success or failure.
+function _chmod(options, mode, filePattern) {
+  if (!filePattern) {
+    if (options.length > 0 && options.charAt(0) === '-') {
+      // Special case where the specified file permissions started with - to subtract perms, which
+      // get picked up by the option parser as command flags.
+      // If we are down by one argument and options starts with -, shift everything over.
+      [].unshift.call(arguments, '');
+    } else {
+      common.error('You must specify a file.');
+    }
+  }
+
+  options = common.parseOptions(options, {
+    'R': 'recursive',
+    'c': 'changes',
+    'v': 'verbose',
+  });
+
+  filePattern = [].slice.call(arguments, 2);
+
+  var files;
+
+  // TODO: replace this with a call to common.expand()
+  if (options.recursive) {
+    files = [];
+    filePattern.forEach(function addFile(expandedFile) {
+      var stat = common.statNoFollowLinks(expandedFile);
+
+      if (!stat.isSymbolicLink()) {
+        files.push(expandedFile);
+
+        if (stat.isDirectory()) {  // intentionally does not follow symlinks.
+          fs.readdirSync(expandedFile).forEach(function (child) {
+            addFile(expandedFile + '/' + child);
+          });
+        }
+      }
+    });
+  } else {
+    files = filePattern;
+  }
+
+  files.forEach(function innerChmod(file) {
+    file = path.resolve(file);
+    if (!fs.existsSync(file)) {
+      common.error('File not found: ' + file);
+    }
+
+    // When recursing, don't follow symlinks.
+    if (options.recursive && common.statNoFollowLinks(file).isSymbolicLink()) {
+      return;
+    }
+
+    var stat = common.statFollowLinks(file);
+    var isDir = stat.isDirectory();
+    var perms = stat.mode;
+    var type = perms & PERMS.TYPE_MASK;
+
+    var newPerms = perms;
+
+    if (Number.isNaN(parseInt(mode, 8))) {
+      // parse options
+      mode.split(',').forEach(function (symbolicMode) {
+        var pattern = /([ugoa]*)([=+-])([rwxXst]*)/i;
+        var matches = pattern.exec(symbolicMode);
+
+        if (matches) {
+          var applyTo = matches[1];
+          var operator = matches[2];
+          var change = matches[3];
+
+          var changeOwner = applyTo.includes('u') || applyTo === 'a' || applyTo === '';
+          var changeGroup = applyTo.includes('g') || applyTo === 'a' || applyTo === '';
+          var changeOther = applyTo.includes('o') || applyTo === 'a' || applyTo === '';
+
+          var changeRead = change.includes('r');
+          var changeWrite = change.includes('w');
+          var changeExec = change.includes('x');
+          var changeExecDir = change.includes('X');
+          var changeSticky = change.includes('t');
+          var changeSetuid = change.includes('s');
+
+          if (changeExecDir && isDir) {
+            changeExec = true;
+          }
+
+          var mask = 0;
+          if (changeOwner) {
+            mask |= (changeRead ? PERMS.OWNER_READ : 0) + (changeWrite ? PERMS.OWNER_WRITE : 0) + (changeExec ? PERMS.OWNER_EXEC : 0) + (changeSetuid ? PERMS.SETUID : 0);
+          }
+          if (changeGroup) {
+            mask |= (changeRead ? PERMS.GROUP_READ : 0) + (changeWrite ? PERMS.GROUP_WRITE : 0) + (changeExec ? PERMS.GROUP_EXEC : 0) + (changeSetuid ? PERMS.SETGID : 0);
+          }
+          if (changeOther) {
+            mask |= (changeRead ? PERMS.OTHER_READ : 0) + (changeWrite ? PERMS.OTHER_WRITE : 0) + (changeExec ? PERMS.OTHER_EXEC : 0);
+          }
+
+          // Sticky bit is special - it's not tied to user, group or other.
+          if (changeSticky) {
+            mask |= PERMS.STICKY;
+          }
+
+          switch (operator) {
+            case '+':
+              newPerms |= mask;
+              break;
+
+            case '-':
+              newPerms &= ~mask;
+              break;
+
+            case '=':
+              newPerms = type + mask;
+
+              // According to POSIX, when using = to explicitly set the
+              // permissions, setuid and setgid can never be cleared.
+              if (common.statFollowLinks(file).isDirectory()) {
+                newPerms |= (PERMS.SETUID + PERMS.SETGID) & perms;
+              }
+              break;
+            default:
+              common.error('Could not recognize operator: `' + operator + '`');
+          }
+
+          if (options.verbose) {
+            console.log(file + ' -> ' + newPerms.toString(8));
+          }
+
+          if (perms !== newPerms) {
+            if (!options.verbose && options.changes) {
+              console.log(file + ' -> ' + newPerms.toString(8));
+            }
+            fs.chmodSync(file, newPerms);
+            perms = newPerms; // for the next round of changes!
+          }
+        } else {
+          common.error('Invalid symbolic mode change: ' + symbolicMode);
+        }
+      });
+    } else {
+      // they gave us a full number
+      newPerms = type + parseInt(mode, 8);
+
+      // POSIX rules are that setuid and setgid can only be added using numeric
+      // form, but not cleared.
+      if (common.statFollowLinks(file).isDirectory()) {
+        newPerms |= (PERMS.SETUID + PERMS.SETGID) & perms;
+      }
+
+      fs.chmodSync(file, newPerms);
+    }
+  });
+  return '';
+}
+module.exports = _chmod;

package/node_modules/shelljs/src/cmd.js

@@ -0,0 +1,122 @@
+var common = require('./common');
+var execa = require('execa');
+
+var DEFAULT_MAXBUFFER_SIZE = 20 * 1024 * 1024;
+var COMMAND_NOT_FOUND_ERROR_CODE = 127;
+
+common.register('cmd', _cmd, {
+  cmdOptions: null,
+  globStart: 1,
+  canReceivePipe: true,
+  wrapOutput: true,
+});
+
+function commandNotFound(execaResult) {
+  if (process.platform === 'win32') {
+    var str = 'is not recognized as an internal or external command';
+    return execaResult.code && execaResult.stderr.includes(str);
+  } else {
+    return execaResult.code &&
+      execaResult.stdout === null && execaResult.stderr === null;
+  }
+}
+
+//@
+//@ ### cmd(arg1[, arg2, ...] [, options])
+//@
+//@ Available options:
+//@
+//@ + `cwd: directoryPath`: change the current working directory only for this
+//@   cmd() invocation.
+//@ + `maxBuffer: num`: Raise or decrease the default buffer size for
+//@   stdout/stderr.
+//@ + `timeout`: Change the default timeout.
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ var version = cmd('node', '--version').stdout;
+//@ cmd('git', 'commit', '-am', `Add suport for node ${version}`);
+//@ console.log(cmd('echo', '1st arg', '2nd arg', '3rd arg').stdout)
+//@ console.log(cmd('echo', 'this handles ;, |, &, etc. as literal characters').stdout)
+//@ ```
+//@
+//@ Executes the given command synchronously. This is intended as an easier
+//@ alternative for [exec()](#execcommand--options--callback), with better
+//@ security around globbing, comamnd injection, and variable expansion. This is
+//@ guaranteed to only run one external command, and won't give special
+//@ treatment for any shell characters (ex. this treats `|` as a literal
+//@ character, not as a shell pipeline).
+//@ This returns a [ShellString](#shellstringstr).
+//@
+//@ By default, this performs globbing on all platforms, but you can disable
+//@ this with `set('-f')`.
+//@
+//@ This **does not** support asynchronous mode. If you need asynchronous
+//@ command execution, check out [execa](https://www.npmjs.com/package/execa) or
+//@ the node builtin `child_process.execFile()` instead.
+function _cmd(options, command, commandArgs, userOptions) {
+  if (!command) {
+    common.error('Must specify a non-empty string as a command');
+  }
+
+  // `options` will usually not have a value: it's added by our commandline flag
+  // parsing engine.
+  commandArgs = [].slice.call(arguments, 2);
+
+  // `userOptions` may or may not be provided. We need to check the last
+  // argument. If it's an object, assume it's meant to be passed as
+  // userOptions (since ShellStrings are already flattened to strings).
+  if (commandArgs.length === 0) {
+    userOptions = {};
+  } else {
+    var lastArg = commandArgs.pop();
+    if (common.isObject(lastArg)) {
+      userOptions = lastArg;
+    } else {
+      userOptions = {};
+      commandArgs.push(lastArg);
+    }
+  }
+
+  var pipe = common.readFromPipe();
+
+  // Some of our defaults differ from execa's defaults. These can be overridden
+  // by the user.
+  var defaultOptions = {
+    maxBuffer: DEFAULT_MAXBUFFER_SIZE,
+    stripEof: false, // Preserve trailing newlines for consistency with unix.
+    reject: false, // Use ShellJS's error handling system.
+  };
+
+  // For other options, we forbid the user from overriding them (either for
+  // correctness or security).
+  var requiredOptions = {
+    input: pipe,
+    shell: false,
+  };
+
+  var execaOptions =
+    Object.assign(defaultOptions, userOptions, requiredOptions);
+
+  var result = execa.sync(command, commandArgs, execaOptions);
+  var stdout;
+  var stderr;
+  var code;
+  if (commandNotFound(result)) {
+    // This can happen if `command` is not an executable binary, or possibly
+    // under other conditions.
+    stdout = '';
+    stderr = "'" + command + "': command not found";
+    code = COMMAND_NOT_FOUND_ERROR_CODE;
+  } else {
+    stdout = result.stdout.toString();
+    stderr = result.stderr.toString();
+    code = result.code;
+  }
+
+  // Pass `continue: true` so we can specify a value for stdout.
+  if (code) common.error(stderr, code, { silent: true, continue: true });
+  return new common.ShellString(stdout, stderr, code);
+}
+module.exports = _cmd;