@staffbase/create-staffbase-plugin 1.0.2 → 1.0.8

package/scaffoldTpl/node_modules/jstransformer/index.js

@@ -1,359 +0,0 @@
-'use strict';
-
-var fs = require('fs');
-var assert = require('assert');
-var Promise = require('promise');
-var isPromise = require('is-promise');
-
-var tr = (module.exports = function (transformer) {
-  return new Transformer(transformer);
-});
-tr.Transformer = Transformer;
-tr.normalizeFn = normalizeFn;
-tr.normalizeFnAsync = normalizeFnAsync;
-tr.normalize = normalize;
-tr.normalizeAsync = normalizeAsync;
-if (fs.readFile) {
-  tr.readFile = Promise.denodeify(fs.readFile);
-  tr.readFileSync = fs.readFileSync;
-} else {
-  tr.readFile = function () { throw new Error('fs.readFile unsupported'); };
-  tr.readFileSync = function () { throw new Error('fs.readFileSync unsupported'); };
-}
-
-function normalizeFn(result) {
-  if (typeof result === 'function') {
-    return {fn: result, dependencies: []};
-  } else if (result && typeof result === 'object' && typeof result.fn === 'function') {
-    if ('dependencies' in result) {
-      if (!Array.isArray(result.dependencies)) {
-        throw new Error('Result should have a dependencies property that is an array');
-      }
-    } else {
-      result.dependencies = [];
-    }
-    return result;
-  } else {
-    throw new Error('Invalid result object from transform.');
-  }
-}
-function normalizeFnAsync(result, cb) {
-  return Promise.resolve(result).then(function (result) {
-    if (result && isPromise(result.fn)) {
-      return result.fn.then(function (fn) {
-        result.fn = fn;
-        return result;
-      });
-    }
-    return result;
-  }).then(tr.normalizeFn).nodeify(cb);
-}
-function normalize(result) {
-  if (typeof result === 'string') {
-    return {body: result, dependencies: []};
-  } else if (result && typeof result === 'object' && typeof result.body === 'string') {
-    if ('dependencies' in result) {
-      if (!Array.isArray(result.dependencies)) {
-        throw new Error('Result should have a dependencies property that is an array');
-      }
-    } else {
-      result.dependencies = [];
-    }
-    return result;
-  } else {
-    throw new Error('Invalid result object from transform.');
-  }
-}
-function normalizeAsync(result, cb) {
-  return Promise.resolve(result).then(function (result) {
-    if (result && isPromise(result.body)) {
-      return result.body.then(function (body) {
-        result.body = body;
-        return result;
-      });
-    }
-    return result;
-  }).then(tr.normalize).nodeify(cb);
-}
-
-function Transformer(tr) {
-  assert(tr, 'Transformer must be an object');
-  assert(typeof tr.name === 'string', 'Transformer must have a name');
-  assert(typeof tr.outputFormat === 'string', 'Transformer must have an output format');
-  assert([
-    'compile',
-    'compileAsync',
-    'compileFile',
-    'compileFileAsync',
-    'compileClient',
-    'compileClientAsync',
-    'compileFileClient',
-    'compileFileClientAsync',
-    'render',
-    'renderAsync',
-    'renderFile',
-    'renderFileAsync'
-  ].some(function (method) {
-    return typeof tr[method] === 'function';
-  }), 'Transformer must implement at least one of the potential methods.');
-  this._tr = tr;
-  this.name = this._tr.name;
-  this.outputFormat = this._tr.outputFormat;
-  this.inputFormats = this._tr.inputFormats || [this.name];
-}
-
-var fallbacks = {
-  compile: ['compile', 'render'],
-  compileAsync: ['compileAsync', 'compile', 'render'],
-  compileFile: ['compileFile', 'compile', 'renderFile', 'render'],
-  compileFileAsync: [
-    'compileFileAsync', 'compileFile', 'compileAsync', 'compile',
-    'renderFile', 'render'
-  ],
-  compileClient: ['compileClient'],
-  compileClientAsync: ['compileClientAsync', 'compileClient'],
-  compileFileClient: ['compileFileClient', 'compileClient'],
-  compileFileClientAsync: [
-    'compileFileClientAsync', 'compileFileClient', 'compileClientAsync', 'compileClient'
-  ],
-  render: ['render', 'compile'],
-  renderAsync: ['renderAsync', 'render', 'compileAsync', 'compile'],
-  renderFile: ['renderFile', 'render', 'compileFile', 'compile'],
-  renderFileAsync: [
-    'renderFileAsync', 'renderFile', 'renderAsync', 'render',
-    'compileFileAsync', 'compileFile', 'compileAsync', 'compile'
-  ]
-};
-
-Transformer.prototype._hasMethod = function (method) {
-  return typeof this._tr[method] === 'function';
-};
-Transformer.prototype.can = function (method) {
-  return fallbacks[method].some(function (method) {
-    return this._hasMethod(method);
-  }.bind(this));
-};
-
-/* COMPILE */
-
-Transformer.prototype.compile = function (str, options) {
-  if (!this._hasMethod('compile')) {
-    if (this.can('render')) {
-      var _this = this;
-      return {
-        fn: function (locals) {
-          return tr.normalize(_this._tr.render(str, options, locals)).body;
-        },
-        dependencies: []
-      };
-    }
-    if (this.can('compileAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support synchronous compilation');
-    } else if (this.can('compileFileAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support compiling plain strings');
-    } else {
-      throw new Error('The Transform "' + this.name + '" does not support compilation');
-    }
-  }
-  return tr.normalizeFn(this._tr.compile(str, options));
-};
-Transformer.prototype.compileAsync = function (str, options, cb) {
-  if (!this.can('compileAsync')) { // compileFile* || renderFile* || renderAsync || compile*Client*
-    return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling plain strings')).nodeify(cb);
-  }
-  if (this._hasMethod('compileAsync')) {
-    return tr.normalizeFnAsync(this._tr.compileAsync(str, options), cb);
-  } else { // render || compile
-    return tr.normalizeFnAsync(this.compile(str, options), cb);
-  }
-};
-Transformer.prototype.compileFile = function (filename, options) {
-  if (!this.can('compileFile')) { // compile*Client* || compile*Async || render*Async
-    throw new Error('The Transform "' + this.name + '" does not support synchronous compilation');
-  }
-  if (this._hasMethod('compileFile')) {
-    return tr.normalizeFn(this._tr.compileFile(filename, options));
-  } else if (this._hasMethod('renderFile')) {
-    return tr.normalizeFn(function (locals) {
-      return tr.normalize(this._tr.renderFile(filename, options, locals)).body;
-    }.bind(this));
-  } else { // render || compile
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return this.compile(tr.readFileSync(filename, 'utf8'), options);
-  }
-};
-Transformer.prototype.compileFileAsync = function (filename, options, cb) {
-  if (!this.can('compileFileAsync')) {
-    return Promise.reject(new Error('The Transform "' + this.name + '" does not support compilation'));
-  }
-  if (this._hasMethod('compileFileAsync')) {
-    return tr.normalizeFnAsync(this._tr.compileFileAsync(filename, options), cb);
-  } else if (this._hasMethod('compileFile') || this._hasMethod('renderFile')) {
-    return tr.normalizeFnAsync(this.compileFile(filename, options), cb);
-  } else { // compileAsync || compile || render
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return tr.normalizeFnAsync(tr.readFile(filename, 'utf8').then(function (str) {
-      if (this._hasMethod('compileAsync')) {
-        return this._tr.compileAsync(str, options);
-      } else { // compile || render
-        return this.compile(str, options);
-      }
-    }.bind(this)), cb);
-  }
-};
-
-/* COMPILE CLIENT */
-
-
-Transformer.prototype.compileClient = function (str, options) {
-  if (!this.can('compileClient')) {
-    if (this.can('compileClientAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support compiling for the client synchronously.');
-    } else if (this.can('compileFileClientAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support compiling for the client from a string.');
-    } else {
-      throw new Error('The Transform "' + this.name + '" does not support compiling for the client');
-    }
-  }
-  return tr.normalize(this._tr.compileClient(str, options));
-};
-Transformer.prototype.compileClientAsync = function (str, options, cb) {
-  if (!this.can('compileClientAsync')) {
-    if (this.can('compileFileClientAsync')) {
-      return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client from a string.')).nodeify(cb);
-    } else {
-      return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client')).nodeify(cb);
-    }
-  }
-  if (this._hasMethod('compileClientAsync')) {
-    return tr.normalizeAsync(this._tr.compileClientAsync(str, options), cb);
-  } else {
-    return tr.normalizeAsync(this._tr.compileClient(str, options), cb);
-  }
-};
-Transformer.prototype.compileFileClient = function (filename, options) {
-  if (!this.can('compileFileClient')) {
-    if (this.can('compileFileClientAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support compiling for the client synchronously.');
-    } else {
-      throw new Error('The Transform "' + this.name + '" does not support compiling for the client');
-    }
-  }
-  if (this._hasMethod('compileFileClient')) {
-    return tr.normalize(this._tr.compileFileClient(filename, options));
-  } else {
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return tr.normalize(this._tr.compileClient(tr.readFileSync(filename, 'utf8'), options));
-  }
-};
-Transformer.prototype.compileFileClientAsync = function (filename, options, cb) {
-  if (!this.can('compileFileClientAsync')) {
-    return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client')).nodeify(cb)
-  }
-  if (this._hasMethod('compileFileClientAsync')) {
-    return tr.normalizeAsync(this._tr.compileFileClientAsync(filename, options), cb);
-  } else if (this._hasMethod('compileFileClient')) {
-    return tr.normalizeAsync(this._tr.compileFileClient(filename, options), cb);
-  } else {
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return tr.normalizeAsync(tr.readFile(filename, 'utf8').then(function (str) {
-      if (this._hasMethod('compileClientAsync')) {
-        return this._tr.compileClientAsync(str, options);
-      } else {
-        return this._tr.compileClient(str, options);
-      }
-    }.bind(this)), cb);
-  }
-};
-
-/* RENDER */
-
-Transformer.prototype.render = function (str, options, locals) {
-  if (!this.can('render')) {
-    if (this.can('renderAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
-    } else if (this.can('renderFileAsync')) {
-      throw new Error('The Transform "' + this.name + '" does not support rendering from a string.');
-    } else {
-      throw new Error('The Transform "' + this.name + '" does not support rendering');
-    }
-  }
-  if (this._hasMethod('render')) {
-    return tr.normalize(this._tr.render(str, options, locals));
-  } else {
-    var compiled = tr.normalizeFn(this._tr.compile(str, options));
-    var body = compiled.fn(locals || options);
-    if (typeof body !== 'string') {
-      throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
-    }
-    return tr.normalize({body: body, dependencies: compiled.dependencies});
-  }
-};
-Transformer.prototype.renderAsync = function (str, options, locals, cb) {
-  if (typeof locals === 'function') {
-    cb = locals;
-    locals = options;
-  }
-  if (!this.can('renderAsync')) {
-    if (this.can('renderFileAsync')) {
-      return Promise.reject(new Error('The Transform "' + this.name + '" does not support rendering from a string.')).nodeify(cb);
-    } else {
-      return Promise.reject(new Error('The Transform "' + this.name + '" does not support rendering')).nodeify(cb);
-    }
-  }
-  if (this._hasMethod('renderAsync')) {
-    return tr.normalizeAsync(this._tr.renderAsync(str, options, locals), cb);
-  } else if (this._hasMethod('render')) {
-    return tr.normalizeAsync(this._tr.render(str, options, locals), cb);
-  } else {
-    return tr.normalizeAsync(this.compileAsync(str, options).then(function (compiled) {
-      return {body: compiled.fn(locals || options), dependencies: compiled.dependencies};
-    }), cb);
-  }
-};
-Transformer.prototype.renderFile = function (filename, options, locals) {
-  if (!this.can('renderFile')) { // *Async, *Client
-    throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
-  }
-
-  if (this._hasMethod('renderFile')) {
-    return tr.normalize(this._tr.renderFile(filename, options, locals));
-  } else if (this._hasMethod('render')) {
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return tr.normalize(this._tr.render(tr.readFileSync(filename, 'utf8'), options, locals));
-  } else { // compile || compileFile
-    var compiled = this.compileFile(filename, options);
-    return tr.normalize({body: compiled.fn(locals || options), dependencies: compiled.dependencies});
-  }
-};
-Transformer.prototype.renderFileAsync = function (filename, options, locals, cb) {
-  if (!this.can('renderFileAsync')) { // *Client
-    throw new Error('The Transform "' + this.name + '" does not support rendering.');
-  }
-
-  if (typeof locals === 'function') {
-    cb = locals;
-    locals = options;
-  }
-  if (this._hasMethod('renderFileAsync')) {
-    return tr.normalizeAsync(this._tr.renderFileAsync(filename, options, locals), cb);
-  } else if (this._hasMethod('renderFile')) {
-    return tr.normalizeAsync(this._tr.renderFile(filename, options, locals), cb);
-  } else if (this._hasMethod('compile') || this._hasMethod('compileAsync')
-             || this._hasMethod('compileFile') || this._hasMethod('compileFileAsync')) {
-    return tr.normalizeAsync(this.compileFileAsync(filename, options).then(function (compiled) {
-      return {body: compiled.fn(locals || options), dependencies: compiled.dependencies};
-    }), cb);
-  } else { // render || renderAsync
-    if (!options) options = {};
-    if (options.filename === undefined) options.filename = filename;
-    return tr.normalizeAsync(tr.readFile(filename, 'utf8').then(function (str) {
-      return this.renderAsync(str, options, locals);
-    }.bind(this)), cb);
-  }
-};

package/scaffoldTpl/node_modules/jstransformer/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "jstransformer",
-  "version": "1.0.0",
-  "description": "Normalize the API of any jstransformer",
-  "keywords": [
-    "jstransformer"
-  ],
-  "dependencies": {
-    "is-promise": "^2.0.0",
-    "promise": "^7.0.1"
-  },
-  "devDependencies": {
-    "coveralls": "^2.11.2",
-    "istanbul": "^0.4.0",
-    "testit": "^2.0.2"
-  },
-  "scripts": {
-    "test": "node test",
-    "coverage": "istanbul cover test",
-    "coveralls": "npm run coverage && cat ./coverage/lcov.info | coveralls"
-  },
-  "files": [
-    "index.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/jstransformers/jstransformer.git"
-  },
-  "author": "ForbesLindesay",
-  "license": "MIT"
-}

package/scaffoldTpl/node_modules/jwa/LICENSE

@@ -1,17 +0,0 @@
-Copyright (c) 2013 Brian J. Brennan
-
-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/scaffoldTpl/node_modules/jwa/README.md

@@ -1,150 +0,0 @@
-# node-jwa [![Build Status](https://travis-ci.org/brianloveswords/node-jwa.svg?branch=master)](https://travis-ci.org/brianloveswords/node-jwa)
-
-A
-[JSON Web Algorithms](http://tools.ietf.org/id/draft-ietf-jose-json-web-algorithms-08.html)
-implementation focusing (exclusively, at this point) on the algorithms necessary for
-[JSON Web Signatures](http://self-issued.info/docs/draft-ietf-jose-json-web-signature.html).
-
-This library supports all of the required, recommended and optional cryptographic algorithms for JWS:
-
-alg Parameter Value | Digital Signature or MAC Algorithm
-----------------|----------------------------
-HS256 | HMAC using SHA-256 hash algorithm
-HS384 | HMAC using SHA-384 hash algorithm
-HS512 | HMAC using SHA-512 hash algorithm
-RS256 | RSASSA using SHA-256 hash algorithm
-RS384 | RSASSA using SHA-384 hash algorithm
-RS512 | RSASSA using SHA-512 hash algorithm
-PS256 | RSASSA-PSS using SHA-256 hash algorithm
-PS384 | RSASSA-PSS using SHA-384 hash algorithm
-PS512 | RSASSA-PSS using SHA-512 hash algorithm
-ES256 | ECDSA using P-256 curve and SHA-256 hash algorithm
-ES384 | ECDSA using P-384 curve and SHA-384 hash algorithm
-ES512 | ECDSA using P-521 curve and SHA-512 hash algorithm
-none | No digital signature or MAC value included
-
-Please note that PS* only works on Node 6.12+ (excluding 7.x).
-
-# Requirements
-
-In order to run the tests, a recent version of OpenSSL is
-required. **The version that comes with OS X (OpenSSL 0.9.8r 8 Feb
-2011) is not recent enough**, as it does not fully support ECDSA
-keys. You'll need to use a version > 1.0.0; I tested with OpenSSL 1.0.1c 10 May 2012.
-
-# Testing
-
-To run the tests, do
-
-```bash
-$ npm test
-```
-
-This will generate a bunch of keypairs to use in testing. If you want to
-generate new keypairs, do `make clean` before running `npm test` again.
-
-## Methodology
-
-I spawn `openssl dgst -sign` to test OpenSSL sign → JS verify and
-`openssl dgst -verify` to test JS sign → OpenSSL verify for each of the
-RSA and ECDSA algorithms.
-
-# Usage
-
-## jwa(algorithm)
-
-Creates a new `jwa` object with `sign` and `verify` methods for the
-algorithm. Valid values for algorithm can be found in the table above
-(`'HS256'`, `'HS384'`, etc) and are case-insensitive. Passing an invalid
-algorithm value will throw a `TypeError`.
-
-
-## jwa#sign(input, secretOrPrivateKey)
-
-Sign some input with either a secret for HMAC algorithms, or a private
-key for RSA and ECDSA algorithms.
-
-If input is not already a string or buffer, `JSON.stringify` will be
-called on it to attempt to coerce it.
-
-For the HMAC algorithm, `secretOrPrivateKey` should be a string or a
-buffer. For ECDSA and RSA, the value should be a string representing a
-PEM encoded **private** key.
-
-Output [base64url](http://en.wikipedia.org/wiki/Base64#URL_applications)
-formatted. This is for convenience as JWS expects the signature in this
-format. If your application needs the output in a different format,
-[please open an issue](https://github.com/brianloveswords/node-jwa/issues). In
-the meantime, you can use
-[brianloveswords/base64url](https://github.com/brianloveswords/base64url)
-to decode the signature.
-
-As of nodejs *v0.11.8*, SPKAC support was introduce. If your nodeJs
-version satisfies, then you can pass an object `{ key: '..', passphrase: '...' }`
-
-
-## jwa#verify(input, signature, secretOrPublicKey)
-
-Verify a signature. Returns `true` or `false`.
-
-`signature` should be a base64url encoded string.
-
-For the HMAC algorithm, `secretOrPublicKey` should be a string or a
-buffer. For ECDSA and RSA, the value should be a string represented a
-PEM encoded **public** key.
-
-
-# Example
-
-HMAC
-```js
-const jwa = require('jwa');
-
-const hmac = jwa('HS256');
-const input = 'super important stuff';
-const secret = 'shhhhhh';
-
-const signature = hmac.sign(input, secret);
-hmac.verify(input, signature, secret) // === true
-hmac.verify(input, signature, 'trickery!') // === false
-```
-
-With keys
-```js
-const fs = require('fs');
-const jwa = require('jwa');
-const privateKey = fs.readFileSync(__dirname + '/ecdsa-p521-private.pem');
-const publicKey = fs.readFileSync(__dirname + '/ecdsa-p521-public.pem');
-
-const ecdsa = jwa('ES512');
-const input = 'very important stuff';
-
-const signature = ecdsa.sign(input, privateKey);
-ecdsa.verify(input, signature, publicKey) // === true
-```
-## License
-
-MIT
-
-```
-Copyright (c) 2013 Brian J. Brennan
-
-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.
-```