@oneblink/release-cli 1.2.0-beta.3 → 1.2.0-beta.4

package/node_modules/klaw-sync/README.md

@@ -1,164 +0,0 @@
-node-klaw-sync
-==============
-
-[![npm Package](https://img.shields.io/npm/v/klaw-sync.svg?style=flat-square)](https://www.npmjs.com/package/klaw-sync)
-[![Build Status](https://travis-ci.org/manidlou/node-klaw-sync.svg?branch=master)](https://travis-ci.org/manidlou/node-klaw-sync)
-[![windows Build status](https://ci.appveyor.com/api/projects/status/braios34k6qw4h5p/branch/master?svg=true)](https://ci.appveyor.com/project/manidlou/node-klaw-sync/branch/master)
-[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
-[![Known Vulnerabilities](https://snyk.io/test/npm/klaw-sync/badge.svg?style=flat-square)](https://snyk.io/test/npm/klaw-sync)
-
-`klaw-sync` is a Node.js recursive and fast file system walker, which is the synchronous counterpart of [klaw](https://github.com/jprichardson/node-klaw). It lists all files and directories inside a directory recursively and returns an array of objects that each object has two properties: `path` and `stats`. `path` is the full path of the file or directory and `stats` is an instance of [fs.Stats](https://nodejs.org/api/fs.html#fs_class_fs_stats).
-
-Install
--------
-
-    npm i klaw-sync
-
-Usage
------
-
-### klawSync(directory[, options])
-
-- `directory` `<String>`
-- `options` `<Object>` (optional) _all options are `false` by default_
-  - `nodir` `<Boolean>`
-    - return only files (ignore directories).
-  - `nofile` `<Boolean>`
-    - return only directories (ignore files).
-  - `depthLimit`: `<Number>`
-    - the number of times to recurse before stopping. `-1` for unlimited.
-  - `fs`: `<Object>`
-    - custom `fs`, useful when mocking `fs` object.
-  - `filter` `<Function>`
-    - function that gets one argument `fn({path: '', stats: {}})` and returns true to include or false to exclude the item.
-  - `traverseAll` `<Boolean>`
-    - traverse all subdirectories, regardless of `filter` option. (When set to `true`, `traverseAll` produces similar behavior to the default behavior prior to v4.0.0. The current default of  `traverseAll: false` is equivalent to the old `noRecurseOnFailedFilter: true`).
-- **Return:** `<Array<Object>>` `[{path: '', stats: {}}]`
-
-Examples
---------
-
-```js
-const klawSync = require('klaw-sync')
-
-const paths = klawSync('/some/dir')
-// paths = [{path: '/some/dir/dir1', stats: {}}, {path: '/some/dir/file1', stats: {}}]
-```
-
-_**catch error**_
-
-```js
-const klawSync = require('klaw-sync')
-
-let paths
-try {
-  paths = klawSync('/some/dir')
-} catch (er) {
-  console.error(er)
-}
-console.dir(paths)
-```
-
-_**files only**_
-
-```js
-const klawSync = require('klaw-sync')
-
-const files = klawSync('/some/dir', {nodir: true})
-// files = [{path: '/some/dir/file1', stats: {}}, {path: '/some/dir/file2', stats: {}}]
-```
-
-_**directories only**_
-
-```js
-const klawSync = require('klaw-sync')
-
-const dirs = klawSync('/some/dir', {nofile: true})
-// dirs = [{path: '/some/dir/dir1', stats: {}}, {path: '/some/dir/dir2', stats: {}}]
-```
-
-_**ignore hidden directories**_
-
-
-```js
-const path = require('path')
-const klawSync = require('klaw-sync')
-
-const filterFn = item => {
-  const basename = path.basename(item.path)
-  return basename === '.' || basename[0] !== '.'
-}
-
-const paths = klawSync('/some/dir', { filter: filterFn})
-```
-
-_**filter based on stats**_
-
-Here `traverseAll` option is required since we still want to read all directories even if they don't pass the `filter` function, to see if their contents do pass the `filter` function.
-
-```js
-const klawSync = require('klaw-sync')
-
-const refTime = new Date(2017, 3, 24).getTime()
-const filterFn = item => item.stats.mtime.getTime() > refTime
-
-const paths = klawSync('/some/dir', { filter: filterFn })
-```
-
-Run tests
----------
-
-lint: `npm run lint`
-
-unit test: `npm run unit`
-
-lint & unit: `npm test`
-
-benchmark: `npm run benchmark`
-
-Performance compare to other similar modules
------------------------------------------------
-
-Running some [benchmark](https://github.com/bestiejs/benchmark.js) tests on these modules:
-
-- `klaw-sync`
-- [walk-sync](https://github.com/joliss/node-walk-sync)
-
-(as of Jan 25, 2017) `klaw-sync` is the fastest module!
-
-##### results (tested on Ubuntu 18.04, Intel(R) Core(TM) i7-2630QM CPU @ 2.00GHz, 8 CPUs, 8g RAM, node v10.9.0)
-
-```bash
-Running benchmark tests..
-
-root dir length: 1110
-walk-sync x 139 ops/sec ±2.48% (76 runs sampled)
-klaw-sync x 163 ops/sec ±1.20% (80 runs sampled)
-Fastest is klaw-sync
-
-root dir length: 11110
-walk-sync x 13.23 ops/sec ±1.10% (37 runs sampled)
-klaw-sync x 15.10 ops/sec ±1.06% (41 runs sampled)
-Fastest is klaw-sync
-
-root dir length: 111110
-walk-sync x 1.17 ops/sec ±2.06% (7 runs sampled)
-klaw-sync x 1.25 ops/sec ±2.10% (8 runs sampled)
-Fastest is klaw-sync
-```
-
-Credit
-------
-
-Special thanks to:
-
-- [agnivade](https://github.com/agnivade)
-- [jprichardson](https://github.com/jprichardson)
-- [RyanZim](https://github.com/RyanZim)
-
-for their contribution and support.
-
-License
--------
-
-Licensed under MIT

package/node_modules/klaw-sync/klaw-sync.js

@@ -1,29 +0,0 @@
-'use strict'
-const fs = require('graceful-fs')
-const path = require('path')
-
-function klawSync (dir, opts, ls) {
-  if (!ls) {
-    ls = []
-    dir = path.resolve(dir)
-    opts = opts || {}
-    opts.fs = opts.fs || fs
-    if (opts.depthLimit > -1) opts.rootDepth = dir.split(path.sep).length + 1
-  }
-  const paths = opts.fs.readdirSync(dir).map(p => dir + path.sep + p)
-  for (var i = 0; i < paths.length; i += 1) {
-    const pi = paths[i]
-    const st = opts.fs.statSync(pi)
-    const item = {path: pi, stats: st}
-    const isUnderDepthLimit = (!opts.rootDepth || pi.split(path.sep).length - opts.rootDepth < opts.depthLimit)
-    const filterResult = opts.filter ? opts.filter(item) : true
-    const isDir = st.isDirectory()
-    const shouldAdd = filterResult && (isDir ? !opts.nodir : !opts.nofile)
-    const shouldTraverse = isDir && isUnderDepthLimit && (opts.traverseAll || filterResult)
-    if (shouldAdd) ls.push(item)
-    if (shouldTraverse) ls = klawSync(pi, opts, ls)
-  }
-  return ls
-}
-
-module.exports = klawSync

package/node_modules/klaw-sync/package.json

@@ -1,51 +0,0 @@
-{
-  "name": "klaw-sync",
-  "version": "6.0.0",
-  "description": "Recursive, synchronous, and fast file system walker",
-  "main": "klaw-sync.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/manidlou/node-klaw-sync.git"
-  },
-  "keywords": [
-    "fs",
-    "walk",
-    "walker",
-    "walk-sync",
-    "klaw",
-    "readdir-sync"
-  ],
-  "author": "Mani Maghsoudlou",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/manidlou/node-klaw-sync/issues"
-  },
-  "homepage": "https://github.com/manidlou/node-klaw-sync#readme",
-  "dependencies": {
-    "graceful-fs": "^4.1.11"
-  },
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "fs-extra": "^5.0.0",
-    "memory-fs": "^0.4.1",
-    "mkp": "^1.0.1",
-    "mocha": "^5.1.1",
-    "standard": "^11.0.1",
-    "walk-sync": "^0.3.3"
-  },
-  "standard": {
-    "env": [
-      "mocha"
-    ]
-  },
-  "scripts": {
-    "lint": "standard",
-    "unit": "mocha",
-    "test": "npm run lint && npm run unit",
-    "benchmark": "node ./benchmark/bm.js"
-  }
-
-,"_resolved": "https://registry.npmjs.org/klaw-sync/-/klaw-sync-6.0.0.tgz"
-,"_integrity": "sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ=="
-,"_from": "klaw-sync@6.0.0"
-}

package/node_modules/lru-cache/LICENSE

@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/lru-cache/README.md

@@ -1,166 +0,0 @@
-# lru cache
-
-A cache object that deletes the least-recently-used items.
-
-[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
-
-## Installation:
-
-```javascript
-npm install lru-cache --save
-```
-
-## Usage:
-
-```javascript
-var LRU = require("lru-cache")
-  , options = { max: 500
-              , length: function (n, key) { return n * 2 + key.length }
-              , dispose: function (key, n) { n.close() }
-              , maxAge: 1000 * 60 * 60 }
-  , cache = new LRU(options)
-  , otherCache = new LRU(50) // sets just the max size
-
-cache.set("key", "value")
-cache.get("key") // "value"
-
-// non-string keys ARE fully supported
-// but note that it must be THE SAME object, not
-// just a JSON-equivalent object.
-var someObject = { a: 1 }
-cache.set(someObject, 'a value')
-// Object keys are not toString()-ed
-cache.set('[object Object]', 'a different value')
-assert.equal(cache.get(someObject), 'a value')
-// A similar object with same keys/values won't work,
-// because it's a different object identity
-assert.equal(cache.get({ a: 1 }), undefined)
-
-cache.reset()    // empty the cache
-```
-
-If you put more stuff in it, then items will fall out.
-
-If you try to put an oversized thing in it, then it'll fall out right
-away.
-
-## Options
-
-* `max` The maximum size of the cache, checked by applying the length
-  function to all values in the cache.  Not setting this is kind of
-  silly, since that's the whole purpose of this lib, but it defaults
-  to `Infinity`.  Setting it to a non-number or negative number will
-  throw a `TypeError`.  Setting it to 0 makes it be `Infinity`.
-* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
-  as they age, but if you try to get an item that is too old, it'll
-  drop it and return undefined instead of giving it to you.
-  Setting this to a negative value will make everything seem old!
-  Setting it to a non-number will throw a `TypeError`.
-* `length` Function that is used to calculate the length of stored
-  items.  If you're storing strings or buffers, then you probably want
-  to do something like `function(n, key){return n.length}`.  The default is
-  `function(){return 1}`, which is fine if you want to store `max`
-  like-sized things.  The item is passed as the first argument, and
-  the key is passed as the second argumnet.
-* `dispose` Function that is called on items when they are dropped
-  from the cache.  This can be handy if you want to close file
-  descriptors or do other cleanup tasks when items are no longer
-  accessible.  Called with `key, value`.  It's called *before*
-  actually removing the item from the internal cache, so if you want
-  to immediately put it back in, you'll have to do that in a
-  `nextTick` or `setTimeout` callback or it won't do anything.
-* `stale` By default, if you set a `maxAge`, it'll only actually pull
-  stale items out of the cache when you `get(key)`.  (That is, it's
-  not pre-emptively doing a `setTimeout` or anything.)  If you set
-  `stale:true`, it'll return the stale value before deleting it.  If
-  you don't set this, then it'll return `undefined` when you try to
-  get a stale entry, as if it had already been deleted.
-* `noDisposeOnSet` By default, if you set a `dispose()` method, then
-  it'll be called whenever a `set()` operation overwrites an existing
-  key.  If you set this option, `dispose()` will only be called when a
-  key falls out of the cache, not when it is overwritten.
-* `updateAgeOnGet` When using time-expiring entries with `maxAge`,
-  setting this to `true` will make each item's effective time update
-  to the current time whenever it is retrieved from cache, causing it
-  to not expire.  (It can still fall out of cache based on recency of
-  use, of course.)
-
-## API
-
-* `set(key, value, maxAge)`
-* `get(key) => value`
-
-    Both of these will update the "recently used"-ness of the key.
-    They do what you think. `maxAge` is optional and overrides the
-    cache `maxAge` option if provided.
-
-    If the key is not found, `get()` will return `undefined`.
-
-    The key and val can be any value.
-
-* `peek(key)`
-
-    Returns the key value (or `undefined` if not found) without
-    updating the "recently used"-ness of the key.
-
-    (If you find yourself using this a lot, you *might* be using the
-    wrong sort of data structure, but there are some use cases where
-    it's handy.)
-
-* `del(key)`
-
-    Deletes a key out of the cache.
-
-* `reset()`
-
-    Clear the cache entirely, throwing away all values.
-
-* `has(key)`
-
-    Check if a key is in the cache, without updating the recent-ness
-    or deleting it for being stale.
-
-* `forEach(function(value,key,cache), [thisp])`
-
-    Just like `Array.prototype.forEach`.  Iterates over all the keys
-    in the cache, in order of recent-ness.  (Ie, more recently used
-    items are iterated over first.)
-
-* `rforEach(function(value,key,cache), [thisp])`
-
-    The same as `cache.forEach(...)` but items are iterated over in
-    reverse order.  (ie, less recently used items are iterated over
-    first.)
-
-* `keys()`
-
-    Return an array of the keys in the cache.
-
-* `values()`
-
-    Return an array of the values in the cache.
-
-* `length`
-
-    Return total length of objects in cache taking into account
-    `length` options function.
-
-* `itemCount`
-
-    Return total quantity of objects currently in cache. Note, that
-    `stale` (see options) items are returned as part of this item
-    count.
-
-* `dump()`
-
-    Return an array of the cache entries ready for serialization and usage
-    with 'destinationCache.load(arr)`.
-
-* `load(cacheEntriesArray)`
-
-    Loads another cache entries array, obtained with `sourceCache.dump()`,
-    into the cache. The destination cache is reset before loading new entries
-
-* `prune()`
-
-    Manually iterates over the entire cache proactively pruning old entries