init

mc_test/node_modules/one-time/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Unshift.io, Arnout Kazemier,  the Contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

mc_test/node_modules/one-time/README.md

@@ -0,0 +1,88 @@
+# one-time
+
+Call the supplied function exactly one time. This prevents double callback
+execution. This module can be used on both Node.js, React-Native, or browsers
+using Browserify. No magical ES5/6 methods used unlike the `once` module does
+(except for the async version).
+
+## Installation
+
+This module is published to the public npm registry and can be installed
+by running:
+
+```sh
+npm install --save one-time
+```
+
+## Usage (normal)
+
+Simply supply the function with the function that should only be called one
+time:
+
+```js
+var one = require('one-time');
+
+function load(file, fn) {
+  fn = one(fn);
+
+  eventemitter.once('load', fn);
+  eventemitter.once('error', fn);
+
+  // do stuff
+  eventemitter.emit('error', new Error('Failed to load, but still finished'));
+  eventemitter.emit('load');
+}
+
+function example(fn) {
+  fn = one(fn);
+
+  fn();
+  fn('also receives all arguments');
+  fn('it returns the same value') === 'bar';
+  fn('never');
+  fn('gonna');
+  fn('give');
+  fn('you');
+  fn('up');
+}
+
+example(function () {
+  return 'bar'
+});
+```
+
+## Usage (async)
+
+The same pattern is available for **async** functions as well, for that you
+should import that `one-time/async` version instead. This one is optimized
+for **async** and **await** support. It following exactly the same as the
+normal version but assumes it's an `async function () {}` that it's wrapping
+instead of a regular function, and it will return an `async function() {}`
+instead of a regular function.
+
+```js
+import one from 'one-time/async';
+
+const fn = one(async function () {
+  return await example();
+});
+
+await fn();
+await fn();
+await fn();
+```
+
+### Why not `once`?
+
+The main reason is that `once` cannot be used in a browser environment unless
+it's ES5 compatible. For a module as simple as this I find that unacceptable. In
+addition to that it super heavy on the dependency side. So it's totally not
+suitable to be used in client side applications.
+
+In addition to that we make sure that your code stays easy to debug as returned
+functions are named in the same way as your supplied functions. Making heap
+inspection and stack traces easier to understand.
+
+## License
+
+[MIT](LICENSE)

mc_test/node_modules/one-time/async.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var name = require('fn.name');
+
+/**
+ * Wrap callbacks to prevent double execution.
+ *
+ * @param {Function} fn Function that should only be called once.
+ * @returns {Function} A async wrapped callback which prevents multiple executions.
+ * @public
+ */
+module.exports = function one(fn) {
+  var called = 0
+    , value;
+
+  /**
+   * The function that prevents double execution.
+   *
+   * @async
+   * @public
+   */
+  async function onetime() {
+    if (called) return value;
+
+    called = 1;
+    value = await fn.apply(this, arguments);
+    fn = null;
+
+    return value;
+  }
+
+  //
+  // To make debugging more easy we want to use the name of the supplied
+  // function. So when you look at the functions that are assigned to event
+  // listeners you don't see a load of `onetime` functions but actually the
+  // names of the functions that this module will call.
+  //
+  // NOTE: We cannot override the `name` property, as that is `readOnly`
+  // property, so displayName will have to do.
+  //
+  onetime.displayName = name(fn);
+  return onetime;
+};

mc_test/node_modules/one-time/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var name = require('fn.name');
+
+/**
+ * Wrap callbacks to prevent double execution.
+ *
+ * @param {Function} fn Function that should only be called once.
+ * @returns {Function} A wrapped callback which prevents multiple executions.
+ * @public
+ */
+module.exports = function one(fn) {
+  var called = 0
+    , value;
+
+  /**
+   * The function that prevents double execution.
+   *
+   * @private
+   */
+  function onetime() {
+    if (called) return value;
+
+    called = 1;
+    value = fn.apply(this, arguments);
+    fn = null;
+
+    return value;
+  }
+
+  //
+  // To make debugging more easy we want to use the name of the supplied
+  // function. So when you look at the functions that are assigned to event
+  // listeners you don't see a load of `onetime` functions but actually the
+  // names of the functions that this module will call.
+  //
+  // NOTE: We cannot override the `name` property, as that is `readOnly`
+  // property, so displayName will have to do.
+  //
+  onetime.displayName = name(fn);
+  return onetime;
+};

mc_test/node_modules/one-time/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "one-time",
+  "version": "1.0.0",
+  "description": "Run the supplied function exactly one time (once)",
+  "main": "index.js",
+  "scripts": {
+    "test:runner": "mocha test.js",
+    "test:watch": "npm run test:runner -- --watch",
+    "test": "nyc --reporter=text --reporter=json-summary npm run test:runner"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/3rd-Eden/one-time.git"
+  },
+  "keywords": [
+    "once",
+    "function",
+    "single",
+    "one",
+    "one-time",
+    "execution",
+    "nope"
+  ],
+  "author": "Arnout Kazemier",
+  "license": "MIT",
+  "devDependencies": {
+    "assume": "^2.2.0",
+    "mocha": "^6.1.4",
+    "nyc": "^14.1.0"
+  },
+  "dependencies": {
+    "fn.name": "1.x.x"
+  }
+}