@jjrawlins/cdk-git-tagger 0.0.0

package/node_modules/mock-fs/lib/bypass.js

@@ -0,0 +1,63 @@
+const realBinding = process.binding('fs');
+
+let storedBinding;
+
+/**
+ * Perform action, bypassing mock FS
+ * @param {Function} fn The function.
+ * @example
+ * // This file exists on the real FS, not on the mocked FS
+ * const filePath = '/path/file.json';
+ * const data = mock.bypass(() => fs.readFileSync(filePath, 'utf-8'));
+ * @return {*} The return.
+ */
+module.exports = function bypass(fn) {
+  if (typeof fn !== 'function') {
+    throw new Error(`Must provide a function to perform for mock.bypass()`);
+  }
+
+  disable();
+
+  let result;
+  try {
+    result = fn();
+    if (result && typeof result.then === 'function') {
+      return result.then(
+        (r) => {
+          enable();
+          return r;
+        },
+        (err) => {
+          enable();
+          throw err;
+        }
+      );
+    } else {
+      enable();
+      return result;
+    }
+  } catch (err) {
+    enable();
+    throw err;
+  }
+};
+
+/**
+ * Temporarily disable Mocked FS
+ */
+function disable() {
+  if (realBinding._mockedBinding) {
+    storedBinding = realBinding._mockedBinding;
+    delete realBinding._mockedBinding;
+  }
+}
+
+/**
+ * Enables Mocked FS after being disabled by disable()
+ */
+function enable() {
+  if (storedBinding) {
+    realBinding._mockedBinding = storedBinding;
+    storedBinding = undefined;
+  }
+}

package/node_modules/mock-fs/lib/descriptor.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const constants = require('constants');
+
+/**
+ * Create a new file descriptor.
+ * @param {number} flags Flags.
+ * @param {boolean} isPromise descriptor was opened via fs.promises
+ * @class
+ */
+function FileDescriptor(flags, isPromise = false) {
+  /**
+   * Flags.
+   * @type {number}
+   */
+  this._flags = flags;
+
+  /**
+   * File system item.
+   * @type {Item}
+   */
+  this._item = null;
+
+  /**
+   * Current file position.
+   * @type {number}
+   */
+  this._position = 0;
+
+  this._isPromise = isPromise;
+}
+
+/**
+ * Set the item.
+ * @param {Item} item File system item.
+ */
+FileDescriptor.prototype.setItem = function (item) {
+  this._item = item;
+};
+
+/**
+ * Get the item.
+ * @return {Item} File system item.
+ */
+FileDescriptor.prototype.getItem = function () {
+  return this._item;
+};
+
+/**
+ * Get the current file position.
+ * @return {number} File position.
+ */
+FileDescriptor.prototype.getPosition = function () {
+  return this._position;
+};
+
+/**
+ * Set the current file position.
+ * @param {number} position File position.
+ */
+FileDescriptor.prototype.setPosition = function (position) {
+  this._position = position;
+};
+
+/**
+ * Check if file opened for appending.
+ * @return {boolean} Opened for appending.
+ */
+FileDescriptor.prototype.isAppend = function () {
+  return (this._flags & constants.O_APPEND) === constants.O_APPEND;
+};
+
+/**
+ * Check if file opened for creation.
+ * @return {boolean} Opened for creation.
+ */
+FileDescriptor.prototype.isCreate = function () {
+  return (this._flags & constants.O_CREAT) === constants.O_CREAT;
+};
+
+/**
+ * Check if file opened for reading.
+ * @return {boolean} Opened for reading.
+ */
+FileDescriptor.prototype.isRead = function () {
+  return (this._flags & constants.O_WRONLY) !== constants.O_WRONLY;
+};
+
+/**
+ * Check if file opened for writing.
+ * @return {boolean} Opened for writing.
+ */
+FileDescriptor.prototype.isWrite = function () {
+  return (
+    (this._flags & constants.O_WRONLY) === constants.O_WRONLY ||
+    (this._flags & constants.O_RDWR) === constants.O_RDWR
+  );
+};
+
+/**
+ * Check if file opened for truncating.
+ * @return {boolean} Opened for truncating.
+ */
+FileDescriptor.prototype.isTruncate = function () {
+  return (this._flags & constants.O_TRUNC) === constants.O_TRUNC;
+};
+
+/**
+ * Check if file opened with exclusive flag.
+ * @return {boolean} Opened with exclusive.
+ */
+FileDescriptor.prototype.isExclusive = function () {
+  return (this._flags & constants.O_EXCL) === constants.O_EXCL;
+};
+
+/**
+ * Check if the file descriptor was opened as a promise
+ * @return {boolean} Opened from fs.promise
+ */
+FileDescriptor.prototype.isPromise = function () {
+  return this._isPromise;
+};
+
+/**
+ * Export the constructor.
+ * @type {function()}
+ */
+module.exports = FileDescriptor;

package/node_modules/mock-fs/lib/directory.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const util = require('util');
+const Item = require('./item.js');
+const constants = require('constants');
+
+/**
+ * A directory.
+ * @class
+ */
+function Directory() {
+  Item.call(this);
+
+  /**
+   * Items in this directory.
+   * @type {Object<string, Item>}
+   */
+  this._items = {};
+
+  /**
+   * Permissions.
+   */
+  this._mode = 511; // 0777
+}
+util.inherits(Directory, Item);
+
+/**
+ * Add an item to the directory.
+ * @param {string} name The name to give the item.
+ * @param {Item} item The item to add.
+ * @return {Item} The added item.
+ */
+Directory.prototype.addItem = function (name, item) {
+  if (this._items.hasOwnProperty(name)) {
+    throw new Error('Item with the same name already exists: ' + name);
+  }
+  this._items[name] = item;
+  ++item.links;
+  if (item instanceof Directory) {
+    // for '.' entry
+    ++item.links;
+    // for subdirectory
+    ++this.links;
+  }
+  this.setMTime(new Date());
+  return item;
+};
+
+/**
+ * Get a named item.
+ * @param {string} name Item name.
+ * @return {Item} The named item (or null if none).
+ */
+Directory.prototype.getItem = function (name) {
+  let item = null;
+  if (this._items.hasOwnProperty(name)) {
+    item = this._items[name];
+  }
+  return item;
+};
+
+/**
+ * Remove an item.
+ * @param {string} name Name of item to remove.
+ * @return {Item} The orphan item.
+ */
+Directory.prototype.removeItem = function (name) {
+  if (!this._items.hasOwnProperty(name)) {
+    throw new Error('Item does not exist in directory: ' + name);
+  }
+  const item = this._items[name];
+  delete this._items[name];
+  --item.links;
+  if (item instanceof Directory) {
+    // for '.' entry
+    --item.links;
+    // for subdirectory
+    --this.links;
+  }
+  this.setMTime(new Date());
+  return item;
+};
+
+/**
+ * Get list of item names in this directory.
+ * @return {Array<string>} Item names.
+ */
+Directory.prototype.list = function () {
+  return Object.keys(this._items).sort();
+};
+
+/**
+ * Get directory stats.
+ * @param {bolean} bigint Use BigInt.
+ * @return {object} Stats properties.
+ */
+Directory.prototype.getStats = function (bigint) {
+  const stats = Item.prototype.getStats.call(this, bigint);
+  const convert = bigint ? (v) => BigInt(v) : (v) => v;
+
+  stats[1] = convert(this.getMode() | constants.S_IFDIR); // mode
+  stats[8] = convert(1); // size
+  stats[9] = convert(1); // blocks
+
+  return stats;
+};
+
+/**
+ * Export the constructor.
+ * @type {function()}
+ */
+module.exports = Directory;

package/node_modules/mock-fs/lib/error.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const uvBinding = process.binding('uv');
+
+/**
+ * Error codes from libuv.
+ * @enum {number}
+ */
+const codes = {};
+
+uvBinding.getErrorMap().forEach(function (value, errno) {
+  const code = value[0];
+  const message = value[1];
+  codes[code] = {errno: errno, message: message};
+});
+
+/**
+ * Create an error.
+ * @param {string} code Error code.
+ * @param {string} path Path (optional).
+ * @class
+ */
+function FSError(code, path) {
+  if (!codes.hasOwnProperty(code)) {
+    throw new Error('Programmer error, invalid error code: ' + code);
+  }
+  Error.call(this);
+  const details = codes[code];
+  let message = code + ', ' + details.message;
+  if (path) {
+    message += " '" + path + "'";
+  }
+  this.message = message;
+  this.code = code;
+  this.errno = details.errno;
+  if (path !== undefined) {
+    this.path = path;
+  }
+  Error.captureStackTrace(this, FSError);
+}
+FSError.prototype = new Error();
+FSError.codes = codes;
+
+/**
+ * Create an abort error for when an asynchronous task was aborted.
+ * @class
+ */
+function AbortError() {
+  Error.call(this);
+  this.code = 'ABORT_ERR';
+  this.name = 'AbortError';
+  Error.captureStackTrace(this, AbortError);
+}
+AbortError.prototype = new Error();
+
+/**
+ * FSError constructor.
+ */
+exports.FSError = FSError;
+
+/**
+ * AbortError constructor.
+ */
+exports.AbortError = AbortError;

package/node_modules/mock-fs/lib/file.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const util = require('util');
+const Item = require('./item.js');
+const constants = require('constants');
+
+const EMPTY = Buffer.alloc(0);
+
+/**
+ * A file.
+ * @class
+ */
+function File() {
+  Item.call(this);
+
+  /**
+   * File content.
+   * @type {Buffer}
+   */
+  this._content = EMPTY;
+}
+util.inherits(File, Item);
+
+/**
+ * Get the file contents.
+ * @return {Buffer} File contents.
+ */
+File.prototype.getContent = function () {
+  this.setATime(new Date());
+  return this._content;
+};
+
+/**
+ * Set the file contents.
+ * @param {string|Buffer} content File contents.
+ */
+File.prototype.setContent = function (content) {
+  if (typeof content === 'string') {
+    content = Buffer.from(content);
+  } else if (!Buffer.isBuffer(content)) {
+    throw new Error('File content must be a string or buffer');
+  }
+  this._content = content;
+  const now = Date.now();
+  this.setCTime(new Date(now));
+  this.setMTime(new Date(now));
+};
+
+/**
+ * Get file stats.
+ * @param {boolean} bigint Use BigInt.
+ * @return {object} Stats properties.
+ */
+File.prototype.getStats = function (bigint) {
+  const size = this._content.length;
+  const stats = Item.prototype.getStats.call(this, bigint);
+  const convert = bigint ? (v) => BigInt(v) : (v) => v;
+
+  stats[1] = convert(this.getMode() | constants.S_IFREG); // mode
+  stats[8] = convert(size); // size
+  stats[9] = convert(Math.ceil(size / 512)); // blocks
+
+  return stats;
+};
+
+/**
+ * Export the constructor.
+ * @type {function()}
+ */
+module.exports = File;
+exports = module.exports;
+
+/**
+ * Standard input.
+ * @class
+ */
+function StandardInput() {
+  File.call(this);
+  this.setMode(438); // 0666
+}
+util.inherits(StandardInput, File);
+
+exports.StandardInput = StandardInput;
+
+/**
+ * Standard output.
+ * @class
+ */
+function StandardOutput() {
+  File.call(this);
+  this.setMode(438); // 0666
+}
+util.inherits(StandardOutput, File);
+
+/**
+ * Write the contents to stdout.
+ * @param {string|Buffer} content File contents.
+ */
+StandardOutput.prototype.setContent = function (content) {
+  if (process.stdout.isTTY) {
+    process.stdout.write(content);
+  }
+};
+
+exports.StandardOutput = StandardOutput;
+
+/**
+ * Standard error.
+ * @class
+ */
+function StandardError() {
+  File.call(this);
+  this.setMode(438); // 0666
+}
+util.inherits(StandardError, File);
+
+/**
+ * Write the contents to stderr.
+ * @param {string|Buffer} content File contents.
+ */
+StandardError.prototype.setContent = function (content) {
+  if (process.stderr.isTTY) {
+    process.stderr.write(content);
+  }
+};
+
+exports.StandardError = StandardError;