cwchristerw/musix-oss
1
0
Fork 0
mirror of https://github.com/musix-org/musix-oss synced 2025-06-17 01:16:00 +00:00
Code Activity

opus

Browse Source
This commit is contained in:
MatteZ02
2020-03-04 13:43:21 +02:00
parent 79f8a18164
commit da84fcfed1
1292 changed files with 93623 additions and 35760 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
node_modules/npmlog/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,49 @@
### v4.0.2
* Added installation instructions.
### v4.0.1
* Fix bugs where `log.progressEnabled` got out of sync with how `gauge` kept
track of these things resulting in a progressbar that couldn't be disabled.
### v4.0.0
* Allow creating log levels that are an empty string or 0.
### v3.1.2
* Update to `gauge@1.6.0` adding support for default values for template
items.
### v3.1.1
* Update to `gauge@1.5.3` to fix to `1.x` compatibility when it comes to
when a progress bar is enabled. In `1.x` if you didn't have a TTY the
progress bar was never shown. In `2.x` it merely defaults to disabled,
but you can enable it explicitly if you still want progress updates.
### v3.1.0
* Update to `gauge@2.5.2`:
* Updates the `signal-exit` dependency which fixes an incompatibility with
the node profiler.
* Uses externalizes its ansi code generation in `console-control-strings`
* Make the default progress bar include the last line printed, colored as it
would be when printing to a tty.
### v3.0.0
* Switch to `gauge@2.0.0`, for better performance, better look.
* Set stderr/stdout blocking if they're tty's, so that we can hide a
progress bar going to stderr and then safely print to stdout. Without
this the two can end up overlapping producing confusing and sometimes
corrupted output.
### v2.0.0
* Make the `error` event non-fatal so that folks can use it as a prefix.
### v1.0.0
* Add progress bar with `gauge@1.1.0`

15
node_modules/npmlog/LICENSE generated vendored Normal file
View File

@ -0,0 +1,15 @@
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.

216
node_modules/npmlog/README.md generated vendored Normal file
View File

@ -0,0 +1,216 @@
# npmlog
The logger util that npm uses.
This logger is very basic. It does the logging for npm. It supports
custom levels and colored output.
By default, logs are written to stderr. If you want to send log messages
to outputs other than streams, then you can change the `log.stream`
member, or you can just listen to the events that it emits, and do
whatever you want with them.
# Installation
```console
npm install npmlog --save
```
# Basic Usage
```javascript
var log = require('npmlog')
// additional stuff ---------------------------+
// message ----------+ |
// prefix ----+ | |
// level -+ | | |
// v v v v
log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
```
## log.level
* {String}
The level to display logs at. Any logs at or above this level will be
displayed. The special level `silent` will prevent anything from being
displayed ever.
## log.record
* {Array}
An array of all the log messages that have been entered.
## log.maxRecordSize
* {Number}
The maximum number of records to keep. If log.record gets bigger than
10% over this value, then it is sliced down to 90% of this value.
The reason for the 10% window is so that it doesn't have to resize a
large array on every log entry.
## log.prefixStyle
* {Object}
A style object that specifies how prefixes are styled. (See below)
## log.headingStyle
* {Object}
A style object that specifies how the heading is styled. (See below)
## log.heading
* {String} Default: ""
If set, a heading that is printed at the start of every line.
## log.stream
* {Stream} Default: `process.stderr`
The stream where output is written.
## log.enableColor()
Force colors to be used on all messages, regardless of the output
stream.
## log.disableColor()
Disable colors on all messages.
## log.enableProgress()
Enable the display of log activity spinner and progress bar
## log.disableProgress()
Disable the display of a progress bar
## log.enableUnicode()
Force the unicode theme to be used for the progress bar.
## log.disableUnicode()
Disable the use of unicode in the progress bar.
## log.setGaugeTemplate(template)
Set a template for outputting the progress bar. See the [gauge documentation] for details.
[gauge documentation]: https://npmjs.com/package/gauge
## log.setGaugeThemeset(themes)
Select a themeset to pick themes from for the progress bar. See the [gauge documentation] for details.
## log.pause()
Stop emitting messages to the stream, but do not drop them.
## log.resume()
Emit all buffered messages that were written while paused.
## log.log(level, prefix, message, ...)
* `level` {String} The level to emit the message at
* `prefix` {String} A string prefix. Set to "" to skip.
* `message...` Arguments to `util.format`
Emit a log message at the specified level.
## log\[level](prefix, message, ...)
For example,
* log.silly(prefix, message, ...)
* log.verbose(prefix, message, ...)
* log.info(prefix, message, ...)
* log.http(prefix, message, ...)
* log.warn(prefix, message, ...)
* log.error(prefix, message, ...)
Like `log.log(level, prefix, message, ...)`. In this way, each level is
given a shorthand, so you can do `log.info(prefix, message)`.
## log.addLevel(level, n, style, disp)
* `level` {String} Level indicator
* `n` {Number} The numeric level
* `style` {Object} Object with fg, bg, inverse, etc.
* `disp` {String} Optional replacement for `level` in the output.
Sets up a new level with a shorthand function and so forth.
Note that if the number is `Infinity`, then setting the level to that
will cause all log messages to be suppressed. If the number is
`-Infinity`, then the only way to show it is to enable all log messages.
## log.newItem(name, todo, weight)
* `name` {String} Optional; progress item name.
* `todo` {Number} Optional; total amount of work to be done. Default 0.
* `weight` {Number} Optional; the weight of this item relative to others. Default 1.
This adds a new `are-we-there-yet` item tracker to the progress tracker. The
object returned has the `log[level]` methods but is otherwise an
`are-we-there-yet` `Tracker` object.
## log.newStream(name, todo, weight)
This adds a new `are-we-there-yet` stream tracker to the progress tracker. The
object returned has the `log[level]` methods but is otherwise an
`are-we-there-yet` `TrackerStream` object.
## log.newGroup(name, weight)
This adds a new `are-we-there-yet` tracker group to the progress tracker. The
object returned has the `log[level]` methods but is otherwise an
`are-we-there-yet` `TrackerGroup` object.
# Events
Events are all emitted with the message object.
* `log` Emitted for all messages
* `log.<level>` Emitted for all messages with the `<level>` level.
* `<prefix>` Messages with prefixes also emit their prefix as an event.
# Style Objects
Style objects can have the following fields:
* `fg` {String} Color for the foreground text
* `bg` {String} Color for the background
* `bold`, `inverse`, `underline` {Boolean} Set the associated property
* `bell` {Boolean} Make a noise (This is pretty annoying, probably.)
# Message Objects
Every log event is emitted with a message object, and the `log.record`
list contains all of them that have been created. They have the
following fields:
* `id` {Number}
* `level` {String}
* `prefix` {String}
* `message` {String} Result of `util.format()`
* `messageRaw` {Array} Arguments to `util.format()`
# Blocking TTYs
We use [`set-blocking`](https://npmjs.com/package/set-blocking) to set
stderr and stdout blocking if they are tty's and have the setBlocking call.
This is a work around for an issue in early versions of Node.js 6.x, which
made stderr and stdout non-blocking on OSX. (They are always blocking
Windows and were never blocking on Linux.) `npmlog` needs them to be blocking
so that it can allow output to stdout and stderr to be interlaced.

309
node_modules/npmlog/log.js generated vendored Normal file
View File

@ -0,0 +1,309 @@
'use strict'
var Progress = require('are-we-there-yet')
var Gauge = require('gauge')
var EE = require('events').EventEmitter
var log = exports = module.exports = new EE()
var util = require('util')
var setBlocking = require('set-blocking')
var consoleControl = require('console-control-strings')
setBlocking(true)
var stream = process.stderr
Object.defineProperty(log, 'stream', {
set: function (newStream) {
stream = newStream
if (this.gauge) this.gauge.setWriteTo(stream, stream)
},
get: function () {
return stream
}
})
// by default, decide based on tty-ness.
var colorEnabled
log.useColor = function () {
return colorEnabled != null ? colorEnabled : stream.isTTY
}
log.enableColor = function () {
colorEnabled = true
this.gauge.setTheme({hasColor: colorEnabled, hasUnicode: unicodeEnabled})
}
log.disableColor = function () {
colorEnabled = false
this.gauge.setTheme({hasColor: colorEnabled, hasUnicode: unicodeEnabled})
}
// default level
log.level = 'info'
log.gauge = new Gauge(stream, {
enabled: false, // no progress bars unless asked
theme: {hasColor: log.useColor()},
template: [
{type: 'progressbar', length: 20},
{type: 'activityIndicator', kerning: 1, length: 1},
{type: 'section', default: ''},
':',
{type: 'logline', kerning: 1, default: ''}
]
})
log.tracker = new Progress.TrackerGroup()
// we track this separately as we may need to temporarily disable the
// display of the status bar for our own loggy purposes.
log.progressEnabled = log.gauge.isEnabled()
var unicodeEnabled
log.enableUnicode = function () {
unicodeEnabled = true
this.gauge.setTheme({hasColor: this.useColor(), hasUnicode: unicodeEnabled})
}
log.disableUnicode = function () {
unicodeEnabled = false
this.gauge.setTheme({hasColor: this.useColor(), hasUnicode: unicodeEnabled})
}
log.setGaugeThemeset = function (themes) {
this.gauge.setThemeset(themes)
}
log.setGaugeTemplate = function (template) {
this.gauge.setTemplate(template)
}
log.enableProgress = function () {
if (this.progressEnabled) return
this.progressEnabled = true
this.tracker.on('change', this.showProgress)
if (this._pause) return
this.gauge.enable()
}
log.disableProgress = function () {
if (!this.progressEnabled) return
this.progressEnabled = false
this.tracker.removeListener('change', this.showProgress)
this.gauge.disable()
}
var trackerConstructors = ['newGroup', 'newItem', 'newStream']
var mixinLog = function (tracker) {
// mixin the public methods from log into the tracker
// (except: conflicts and one's we handle specially)
Object.keys(log).forEach(function (P) {
if (P[0] === '_') return
if (trackerConstructors.filter(function (C) { return C === P }).length) return
if (tracker[P]) return
if (typeof log[P] !== 'function') return
var func = log[P]
tracker[P] = function () {
return func.apply(log, arguments)
}
})
// if the new tracker is a group, make sure any subtrackers get
// mixed in too
if (tracker instanceof Progress.TrackerGroup) {
trackerConstructors.forEach(function (C) {
var func = tracker[C]
tracker[C] = function () { return mixinLog(func.apply(tracker, arguments)) }
})
}
return tracker
}
// Add tracker constructors to the top level log object
trackerConstructors.forEach(function (C) {
log[C] = function () { return mixinLog(this.tracker[C].apply(this.tracker, arguments)) }
})
log.clearProgress = function (cb) {
if (!this.progressEnabled) return cb && process.nextTick(cb)
this.gauge.hide(cb)
}
log.showProgress = function (name, completed) {
if (!this.progressEnabled) return
var values = {}
if (name) values.section = name
var last = log.record[log.record.length - 1]
if (last) {
values.subsection = last.prefix
var disp = log.disp[last.level] || last.level
var logline = this._format(disp, log.style[last.level])
if (last.prefix) logline += ' ' + this._format(last.prefix, this.prefixStyle)
logline += ' ' + last.message.split(/\r?\n/)[0]
values.logline = logline
}
values.completed = completed || this.tracker.completed()
this.gauge.show(values)
}.bind(log) // bind for use in tracker's on-change listener
// temporarily stop emitting, but don't drop
log.pause = function () {
this._paused = true
if (this.progressEnabled) this.gauge.disable()
}
log.resume = function () {
if (!this._paused) return
this._paused = false
var b = this._buffer
this._buffer = []
b.forEach(function (m) {
this.emitLog(m)
}, this)
if (this.progressEnabled) this.gauge.enable()
}
log._buffer = []
var id = 0
log.record = []
log.maxRecordSize = 10000
log.log = function (lvl, prefix, message) {
var l = this.levels[lvl]
if (l === undefined) {
return this.emit('error', new Error(util.format(
'Undefined log level: %j', lvl)))
}
var a = new Array(arguments.length - 2)
var stack = null
for (var i = 2; i < arguments.length; i++) {
var arg = a[i - 2] = arguments[i]
// resolve stack traces to a plain string.
if (typeof arg === 'object' && arg &&
(arg instanceof Error) && arg.stack) {
Object.defineProperty(arg, 'stack', {
value: stack = arg.stack + '',
enumerable: true,
writable: true
})
}
}
if (stack) a.unshift(stack + '\n')
message = util.format.apply(util, a)
var m = { id: id++,
level: lvl,
prefix: String(prefix || ''),
message: message,
messageRaw: a }
this.emit('log', m)
this.emit('log.' + lvl, m)
if (m.prefix) this.emit(m.prefix, m)
this.record.push(m)
var mrs = this.maxRecordSize
var n = this.record.length - mrs
if (n > mrs / 10) {
var newSize = Math.floor(mrs * 0.9)
this.record = this.record.slice(-1 * newSize)
}
this.emitLog(m)
}.bind(log)
log.emitLog = function (m) {
if (this._paused) {
this._buffer.push(m)
return
}
if (this.progressEnabled) this.gauge.pulse(m.prefix)
var l = this.levels[m.level]
if (l === undefined) return
if (l < this.levels[this.level]) return
if (l > 0 && !isFinite(l)) return
// If 'disp' is null or undefined, use the lvl as a default
// Allows: '', 0 as valid disp
var disp = log.disp[m.level] != null ? log.disp[m.level] : m.level
this.clearProgress()
m.message.split(/\r?\n/).forEach(function (line) {
if (this.heading) {
this.write(this.heading, this.headingStyle)
this.write(' ')
}
this.write(disp, log.style[m.level])
var p = m.prefix || ''
if (p) this.write(' ')
this.write(p, this.prefixStyle)
this.write(' ' + line + '\n')
}, this)
this.showProgress()
}
log._format = function (msg, style) {
if (!stream) return
var output = ''
if (this.useColor()) {
style = style || {}
var settings = []
if (style.fg) settings.push(style.fg)
if (style.bg) settings.push('bg' + style.bg[0].toUpperCase() + style.bg.slice(1))
if (style.bold) settings.push('bold')
if (style.underline) settings.push('underline')
if (style.inverse) settings.push('inverse')
if (settings.length) output += consoleControl.color(settings)
if (style.beep) output += consoleControl.beep()
}
output += msg
if (this.useColor()) {
output += consoleControl.color('reset')
}
return output
}
log.write = function (msg, style) {
if (!stream) return
stream.write(this._format(msg, style))
}
log.addLevel = function (lvl, n, style, disp) {
// If 'disp' is null or undefined, use the lvl as a default
if (disp == null) disp = lvl
this.levels[lvl] = n
this.style[lvl] = style
if (!this[lvl]) {
this[lvl] = function () {
var a = new Array(arguments.length + 1)
a[0] = lvl
for (var i = 0; i < arguments.length; i++) {
a[i + 1] = arguments[i]
}
return this.log.apply(this, a)
}.bind(this)
}
this.disp[lvl] = disp
}
log.prefixStyle = { fg: 'magenta' }
log.headingStyle = { fg: 'white', bg: 'black' }
log.style = {}
log.levels = {}
log.disp = {}
log.addLevel('silly', -Infinity, { inverse: true }, 'sill')
log.addLevel('verbose', 1000, { fg: 'blue', bg: 'black' }, 'verb')
log.addLevel('info', 2000, { fg: 'green' })
log.addLevel('timing', 2500, { fg: 'green', bg: 'black' })
log.addLevel('http', 3000, { fg: 'green', bg: 'black' })
log.addLevel('notice', 3500, { fg: 'blue', bg: 'black' })
log.addLevel('warn', 4000, { fg: 'black', bg: 'yellow' }, 'WARN')
log.addLevel('error', 5000, { fg: 'red', bg: 'black' }, 'ERR!')
log.addLevel('silent', Infinity)
// allow 'error' prefix
log.on('error', function () {})

61
node_modules/npmlog/package.json generated vendored Normal file
View File

@ -0,0 +1,61 @@
{
"_from": "npmlog@^4.0.2",
"_id": "npmlog@4.1.2",
"_inBundle": false,
"_integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==",
"_location": "/npmlog",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "npmlog@^4.0.2",
"name": "npmlog",
"escapedName": "npmlog",
"rawSpec": "^4.0.2",
"saveSpec": null,
"fetchSpec": "^4.0.2"
},
"_requiredBy": [
"/node-pre-gyp"
],
"_resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz",
"_shasum": "08a7f2a8bf734604779a9efa4ad5cc717abb954b",
"_spec": "npmlog@^4.0.2",
"_where": "C:\\Users\\matia\\Documents\\GitHub\\Musix-V3\\node_modules\\node-pre-gyp",
"author": {
"name": "Isaac Z. Schlueter",
"email": "i@izs.me",
"url": "http://blog.izs.me/"
},
"bugs": {
"url": "https://github.com/npm/npmlog/issues"
},
"bundleDependencies": false,
"dependencies": {
"are-we-there-yet": "~1.1.2",
"console-control-strings": "~1.1.0",
"gauge": "~2.7.3",
"set-blocking": "~2.0.0"
},
"deprecated": false,
"description": "logger for npm",
"devDependencies": {
"standard": "~7.1.2",
"tap": "~5.7.3"
},
"files": [
"log.js"
],
"homepage": "https://github.com/npm/npmlog#readme",
"license": "ISC",
"main": "log.js",
"name": "npmlog",
"repository": {
"type": "git",
"url": "git+https://github.com/npm/npmlog.git"
},
"scripts": {
"test": "standard && tap test/*.js"
},
"version": "4.1.2"
}