@chainlink/external-adapter-framework 2.12.0 → 2.13.1

package/generator-adapter/node_modules/mem-fs/node_modules/vinyl/index.js

@@ -0,0 +1,346 @@
+'use strict';
+
+var path = require('path');
+var util = require('util');
+var Buffer = require('buffer').Buffer;
+
+var clone = require('clone');
+var teex = require('teex');
+var replaceExt = require('replace-ext');
+var removeTrailingSep = require('remove-trailing-separator');
+
+var isStream = require('./lib/is-stream');
+var normalize = require('./lib/normalize');
+var inspectStream = require('./lib/inspect-stream');
+
+function cloneObject (obj) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+
+var builtInFields = [
+  '_contents',
+  '_symlink',
+  'contents',
+  'stat',
+  'history',
+  'path',
+  '_base',
+  'base',
+  '_cwd',
+  'cwd',
+];
+
+function File(file) {
+  var self = this;
+
+  if (!file) {
+    file = {};
+  }
+
+  // Stat = files stats object
+  this.stat = file.stat || null;
+
+  // Contents = stream, buffer, or null if not read
+  this.contents = file.contents || null;
+
+  // Replay path history to ensure proper normalization and trailing sep
+  var history = Array.prototype.slice.call(file.history || []);
+  if (file.path) {
+    history.push(file.path);
+  }
+  this.history = [];
+  history.forEach(function (path) {
+    self.path = path;
+  });
+
+  this.cwd = file.cwd || process.cwd();
+  this.base = file.base;
+
+  this._isVinyl = true;
+
+  this._symlink = null;
+
+  // Set custom properties
+  Object.keys(file).forEach(function (key) {
+    if (self.constructor.isCustomProp(key)) {
+      self[key] = file[key];
+    }
+  });
+}
+
+File.prototype.isBuffer = function () {
+  return Buffer.isBuffer(this.contents);
+};
+
+File.prototype.isStream = function () {
+  return isStream(this.contents);
+};
+
+File.prototype.isNull = function () {
+  return this.contents === null;
+};
+
+File.prototype.isDirectory = function () {
+  if (!this.isNull()) {
+    return false;
+  }
+
+  if (this.stat && typeof this.stat.isDirectory === 'function') {
+    return this.stat.isDirectory();
+  }
+
+  return false;
+};
+
+File.prototype.isSymbolic = function () {
+  if (!this.isNull()) {
+    return false;
+  }
+
+  if (this.stat && typeof this.stat.isSymbolicLink === 'function') {
+    return this.stat.isSymbolicLink();
+  }
+
+  return false;
+};
+
+File.prototype.clone = function (opt) {
+  var self = this;
+
+  if (typeof opt === 'boolean') {
+    opt = {
+      deep: opt,
+      contents: true,
+    };
+  } else if (!opt) {
+    opt = {
+      deep: true,
+      contents: true,
+    };
+  } else {
+    opt.deep = opt.deep === true;
+    opt.contents = opt.contents !== false;
+  }
+
+  // Clone our file contents
+  var contents;
+  if (this.isStream()) {
+    var streams = teex(this._contents);
+    this._contents = streams[0];
+    contents = streams[1];
+  } else if (this.isBuffer()) {
+    contents = opt.contents ? Buffer.from(this.contents) : this.contents;
+  }
+
+  var file = new this.constructor({
+    cwd: this.cwd,
+    base: this.base,
+    stat: this.stat ? cloneObject(this.stat) : null,
+    history: this.history.slice(),
+    contents: contents,
+  });
+
+  if (this.isSymbolic()) {
+    file.symlink = this.symlink;
+  }
+
+  // Clone our custom properties
+  Object.keys(this).forEach(function (key) {
+    if (self.constructor.isCustomProp(key)) {
+      file[key] = opt.deep ? clone(self[key], true) : self[key];
+    }
+  });
+  return file;
+};
+
+// Node.js v6.6.0+ use this symbol for custom inspection.
+File.prototype[util.inspect.custom] = function () {
+  var inspect = [];
+
+  // Use relative path if possible
+  var filePath = this.path ? this.relative : null;
+
+  if (filePath) {
+    inspect.push('"' + filePath + '"');
+  }
+
+  if (this.isBuffer()) {
+    inspect.push(this.contents.inspect());
+  }
+
+  if (this.isStream()) {
+    inspect.push(inspectStream(this.contents));
+  }
+
+  return '<File ' + inspect.join(' ') + '>';
+};
+
+File.isCustomProp = function (key) {
+  return builtInFields.indexOf(key) === -1;
+};
+
+File.isVinyl = function (file) {
+  return (file && file._isVinyl === true) || false;
+};
+
+// Virtual attributes
+// Or stuff with extra logic
+Object.defineProperty(File.prototype, 'contents', {
+  get: function () {
+    return this._contents;
+  },
+  set: function (val) {
+    if (!Buffer.isBuffer(val) && !isStream(val) && val !== null) {
+      throw new Error('File.contents can only be a Buffer, a Stream, or null.');
+    }
+
+    this._contents = val;
+  },
+});
+
+Object.defineProperty(File.prototype, 'cwd', {
+  get: function () {
+    return this._cwd;
+  },
+  set: function (cwd) {
+    if (!cwd || typeof cwd !== 'string') {
+      throw new Error('cwd must be a non-empty string.');
+    }
+    this._cwd = removeTrailingSep(normalize(cwd));
+  },
+});
+
+Object.defineProperty(File.prototype, 'base', {
+  get: function () {
+    return this._base || this._cwd;
+  },
+  set: function (base) {
+    if (base == null) {
+      delete this._base;
+      return;
+    }
+    if (typeof base !== 'string' || !base) {
+      throw new Error('base must be a non-empty string, or null/undefined.');
+    }
+    base = removeTrailingSep(normalize(base));
+    if (base !== this._cwd) {
+      this._base = base;
+    } else {
+      delete this._base;
+    }
+  },
+});
+
+// TODO: Should this be moved to vinyl-fs?
+Object.defineProperty(File.prototype, 'relative', {
+  get: function () {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get relative.');
+    }
+    return path.relative(this.base, this.path);
+  },
+  set: function () {
+    throw new Error(
+      'File.relative is generated from the base and path attributes. Do not modify it.'
+    );
+  },
+});
+
+Object.defineProperty(File.prototype, 'dirname', {
+  get: function () {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get dirname.');
+    }
+    return path.dirname(this.path);
+  },
+  set: function (dirname) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set dirname.');
+    }
+    this.path = path.join(dirname, this.basename);
+  },
+});
+
+Object.defineProperty(File.prototype, 'basename', {
+  get: function () {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get basename.');
+    }
+    return path.basename(this.path);
+  },
+  set: function (basename) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set basename.');
+    }
+    this.path = path.join(this.dirname, basename);
+  },
+});
+
+// Property for getting/setting stem of the filename.
+Object.defineProperty(File.prototype, 'stem', {
+  get: function () {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get stem.');
+    }
+    return path.basename(this.path, this.extname);
+  },
+  set: function (stem) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set stem.');
+    }
+    this.path = path.join(this.dirname, stem + this.extname);
+  },
+});
+
+Object.defineProperty(File.prototype, 'extname', {
+  get: function () {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get extname.');
+    }
+    return path.extname(this.path);
+  },
+  set: function (extname) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set extname.');
+    }
+    this.path = replaceExt(this.path, extname);
+  },
+});
+
+Object.defineProperty(File.prototype, 'path', {
+  get: function () {
+    var path = this.history[this.history.length - 1];
+    if (path) {
+      return path;
+    } else {
+      return null;
+    }
+  },
+  set: function (path) {
+    if (typeof path !== 'string') {
+      throw new Error('path should be a string.');
+    }
+    path = removeTrailingSep(normalize(path));
+
+    // Record history only when path changed
+    if (path && path !== this.path) {
+      this.history.push(path);
+    }
+  },
+});
+
+Object.defineProperty(File.prototype, 'symlink', {
+  get: function () {
+    return this._symlink;
+  },
+  set: function (symlink) {
+    // TODO: should this set the mode to symbolic if set?
+    if (typeof symlink !== 'string') {
+      throw new Error('symlink should be a string');
+    }
+
+    this._symlink = removeTrailingSep(normalize(symlink));
+  },
+});
+
+module.exports = File;

package/generator-adapter/node_modules/mem-fs/node_modules/vinyl/lib/inspect-stream.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function inspectStream(stream) {
+  var streamType = stream.constructor.name;
+  // Avoid StreamStream
+  if (streamType === 'Stream') {
+    streamType = '';
+  }
+
+  return '<' + streamType + 'Stream>';
+}
+
+module.exports = inspectStream;

package/generator-adapter/node_modules/mem-fs/node_modules/vinyl/lib/is-stream.js

@@ -0,0 +1,15 @@
+'use strict';
+
+function isStream(stream) {
+  if (!stream) {
+    return false;
+  }
+
+  if (typeof stream.pipe !== 'function') {
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = isStream;

package/generator-adapter/node_modules/mem-fs/node_modules/vinyl/lib/normalize.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var path = require('path');
+
+function normalize(str) {
+  return str === '' ? str : path.normalize(str);
+}
+
+module.exports = normalize;

package/generator-adapter/node_modules/mem-fs/node_modules/vinyl/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "vinyl",
+  "version": "3.0.1",
+  "description": "Virtual file format.",
+  "author": "Gulp Team <team@gulpjs.com> (https://gulpjs.com/)",
+  "contributors": [
+    "Eric Schoffstall <yo@contra.io>",
+    "Blaine Bublitz <blaine.bublitz@gmail.com>"
+  ],
+  "repository": "gulpjs/vinyl",
+  "license": "MIT",
+  "engines": {
+    "node": ">=10.13.0"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js",
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "nyc mocha --async-only"
+  },
+  "dependencies": {
+    "clone": "^2.1.2",
+    "remove-trailing-separator": "^1.1.0",
+    "replace-ext": "^2.0.0",
+    "teex": "^1.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "eslint-config-gulp": "^5.0.1",
+    "eslint-plugin-node": "^11.1.0",
+    "expect": "^27.4.6",
+    "mocha": "^8.4.0",
+    "nyc": "^15.1.0",
+    "readable-stream": "^3.6.0",
+    "streamx": "^2.12.5"
+  },
+  "nyc": {
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "keywords": [
+    "virtual",
+    "filesystem",
+    "file",
+    "directory",
+    "stat",
+    "path"
+  ]
+}

package/generator-adapter/node_modules/mem-fs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem-fs",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "description": "Simple in-memory vinyl file store",
   "type": "module",
   "scripts": {
@@ -19,18 +19,18 @@
   "dependencies": {
     "@types/node": ">=18",
     "@types/vinyl": "^2.0.12",
-    "vinyl": "^3.0.0",
+    "vinyl": "^3.0.1",
     "vinyl-file": "^5.0.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.16",
-    "eslint": "^9.39.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-config-xo": "^0.49.0",
-    "prettier": "^3.0.3",
-    "typescript": "^5.2.2",
-    "typescript-eslint": "^8.32.1",
-    "vitest": "^4.0.16"
+    "eslint-config-xo": "^0.50.0",
+    "prettier": "^3.8.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=18.0.0"

package/generator-adapter/node_modules/ora/index.d.ts

@@ -109,7 +109,9 @@ export type Options = {
 	/**
 	Discard stdin input (except Ctrl+C) while running if it's TTY. This prevents the spinner from twitching on input, outputting broken lines on `Enter` key presses, and prevents buffering of input while the spinner is running.
 
-	This has no effect on Windows as there's no good way to implement discarding stdin properly there.
+	This has no effect on Windows as there is no good way to implement discarding stdin properly there.
+
+	Note: `discardStdin` puts stdin into raw mode. In raw mode, `Ctrl+C` no longer generates `SIGINT` from the terminal. Ora re-emits `Ctrl+C` from stdin input, but if your code blocks the event loop with synchronous work, `Ctrl+C` handling is delayed until the blocking work ends. Use async APIs, a worker thread, or a child process to keep `Ctrl+C` responsive, or set `discardStdin` to `false`.
 
 	@default true
 	*/