From 46467680d0e75c95406e46b5e2f754d2b7df1f7b Mon Sep 17 00:00:00 2001 From: Gar Date: Thu, 20 Jun 2024 10:04:39 -0700 Subject: [PATCH] deps: npm-registry-fetch@17.1.0 --- DEPENDENCIES.md | 4 +- node_modules/.gitignore | 4 - node_modules/minipass-json-stream/LICENSE | 27 - node_modules/minipass-json-stream/index.js | 227 ------ .../node_modules/minipass/LICENSE | 15 - .../node_modules/minipass/index.js | 649 ------------------ .../node_modules/minipass/package.json | 56 -- .../minipass-json-stream/package.json | 39 -- node_modules/npm-registry-fetch/lib/index.js | 2 +- .../npm-registry-fetch/lib/json-stream.js | 223 ++++++ node_modules/npm-registry-fetch/package.json | 10 +- package-lock.json | 34 +- package.json | 2 +- 13 files changed, 236 insertions(+), 1056 deletions(-) delete mode 100644 node_modules/minipass-json-stream/LICENSE delete mode 100644 node_modules/minipass-json-stream/index.js delete mode 100644 node_modules/minipass-json-stream/node_modules/minipass/LICENSE delete mode 100644 node_modules/minipass-json-stream/node_modules/minipass/index.js delete mode 100644 node_modules/minipass-json-stream/node_modules/minipass/package.json delete mode 100644 node_modules/minipass-json-stream/package.json create mode 100644 node_modules/npm-registry-fetch/lib/json-stream.js diff --git a/DEPENDENCIES.md b/DEPENDENCIES.md index ac30ca2d466dd..860f219c70703 100644 --- a/DEPENDENCIES.md +++ b/DEPENDENCIES.md @@ -437,8 +437,6 @@ graph LR; minipass-fetch-->minipass; minipass-fetch-->minizlib; minipass-flush-->minipass; - minipass-json-stream-->jsonparse; - minipass-json-stream-->minipass; minipass-pipeline-->minipass; minipass-sized-->minipass; minizlib-->minipass; @@ -560,9 +558,9 @@ graph LR; npm-pick-manifest-->semver; npm-profile-->npm-registry-fetch; npm-profile-->proc-log; + npm-registry-fetch-->jsonparse; npm-registry-fetch-->make-fetch-happen; npm-registry-fetch-->minipass-fetch; - npm-registry-fetch-->minipass-json-stream; npm-registry-fetch-->minipass; npm-registry-fetch-->minizlib; npm-registry-fetch-->npm-package-arg; diff --git a/node_modules/.gitignore b/node_modules/.gitignore index 643a7f949acc3..50a396cdfdfb9 100644 --- a/node_modules/.gitignore +++ b/node_modules/.gitignore @@ -121,10 +121,6 @@ !/minipass-flush/node_modules/ /minipass-flush/node_modules/* !/minipass-flush/node_modules/minipass -!/minipass-json-stream -!/minipass-json-stream/node_modules/ -/minipass-json-stream/node_modules/* -!/minipass-json-stream/node_modules/minipass !/minipass-pipeline !/minipass-pipeline/node_modules/ /minipass-pipeline/node_modules/* diff --git a/node_modules/minipass-json-stream/LICENSE b/node_modules/minipass-json-stream/LICENSE deleted file mode 100644 index 2781a897b60fe..0000000000000 --- a/node_modules/minipass-json-stream/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -The MIT License - -Copyright (c) Isaac Z. Schlueter and Contributors -Copyright (c) 2011 Dominic Tarr - -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. - ----- -This is a derivative work based on JSONStream by Dominic Tarr, modified and -redistributed according to the terms of the MIT license above. -https://github.com/dominictarr/JSONStream diff --git a/node_modules/minipass-json-stream/index.js b/node_modules/minipass-json-stream/index.js deleted file mode 100644 index 5168d1322ac20..0000000000000 --- a/node_modules/minipass-json-stream/index.js +++ /dev/null @@ -1,227 +0,0 @@ -// put javascript in here -'use strict' - -const Parser = require('jsonparse') -const Minipass = require('minipass') - -class JSONStreamError extends Error { - constructor (err, caller) { - super(err.message) - Error.captureStackTrace(this, caller || this.constructor) - } - get name () { - return 'JSONStreamError' - } - set name (n) {} -} - -const check = (x, y) => - typeof x === 'string' ? String(y) === x - : x && typeof x.test === 'function' ? x.test(y) - : typeof x === 'boolean' || typeof x === 'object' ? x - : typeof x === 'function' ? x(y) - : false - -const _parser = Symbol('_parser') -const _onValue = Symbol('_onValue') -const _onTokenOriginal = Symbol('_onTokenOriginal') -const _onToken = Symbol('_onToken') -const _onError = Symbol('_onError') -const _count = Symbol('_count') -const _path = Symbol('_path') -const _map = Symbol('_map') -const _root = Symbol('_root') -const _header = Symbol('_header') -const _footer = Symbol('_footer') -const _setHeaderFooter = Symbol('_setHeaderFooter') -const _ending = Symbol('_ending') - -class JSONStream extends Minipass { - constructor (opts = {}) { - super({ - ...opts, - objectMode: true, - }) - - this[_ending] = false - const parser = this[_parser] = new Parser() - parser.onValue = value => this[_onValue](value) - this[_onTokenOriginal] = parser.onToken - parser.onToken = (token, value) => this[_onToken](token, value) - parser.onError = er => this[_onError](er) - - this[_count] = 0 - this[_path] = typeof opts.path === 'string' - ? opts.path.split('.').map(e => - e === '$*' ? { emitKey: true } - : e === '*' ? true - : e === '' ? { recurse: true } - : e) - : Array.isArray(opts.path) && opts.path.length ? opts.path - : null - - this[_map] = typeof opts.map === 'function' ? opts.map : null - this[_root] = null - this[_header] = null - this[_footer] = null - this[_count] = 0 - } - - [_setHeaderFooter] (key, value) { - // header has not been emitted yet - if (this[_header] !== false) { - this[_header] = this[_header] || {} - this[_header][key] = value - } - - // footer has not been emitted yet but header has - if (this[_footer] !== false && this[_header] === false) { - this[_footer] = this[_footer] || {} - this[_footer][key] = value - } - } - - [_onError] (er) { - // error will always happen during a write() call. - const caller = this[_ending] ? this.end : this.write - this[_ending] = false - return this.emit('error', new JSONStreamError(er, caller)) - } - - [_onToken] (token, value) { - const parser = this[_parser] - this[_onTokenOriginal].call(parser, token, value) - if (parser.stack.length === 0) { - if (this[_root]) { - const root = this[_root] - if (!this[_path]) - super.write(root) - this[_root] = null - this[_count] = 0 - } - } - } - - [_onValue] (value) { - const parser = this[_parser] - // the LAST onValue encountered is the root object. - // just overwrite it each time. - this[_root] = value - - if(!this[_path]) return - - let i = 0 // iterates on path - let j = 0 // iterates on stack - let emitKey = false - let emitPath = false - while (i < this[_path].length) { - const key = this[_path][i] - j++ - - if (key && !key.recurse) { - const c = (j === parser.stack.length) ? parser : parser.stack[j] - if (!c) return - if (!check(key, c.key)) { - this[_setHeaderFooter](c.key, value) - return - } - emitKey = !!key.emitKey; - emitPath = !!key.emitPath; - i++ - } else { - i++ - if (i >= this[_path].length) - return - const nextKey = this[_path][i] - if (!nextKey) - return - while (true) { - const c = (j === parser.stack.length) ? parser : parser.stack[j] - if (!c) return - if (check(nextKey, c.key)) { - i++ - if (!Object.isFrozen(parser.stack[j])) - parser.stack[j].value = null - break - } else { - this[_setHeaderFooter](c.key, value) - } - j++ - } - } - } - - // emit header - if (this[_header]) { - const header = this[_header] - this[_header] = false - this.emit('header', header) - } - if (j !== parser.stack.length) return - - this[_count] ++ - const actualPath = parser.stack.slice(1) - .map(e => e.key).concat([parser.key]) - if (value !== null && value !== undefined) { - const data = this[_map] ? this[_map](value, actualPath) : value - if (data !== null && data !== undefined) { - const emit = emitKey || emitPath ? { value: data } : data - if (emitKey) - emit.key = parser.key - if (emitPath) - emit.path = actualPath - super.write(emit) - } - } - - if (parser.value) - delete parser.value[parser.key] - - for (const k of parser.stack) { - k.value = null - } - } - - write (chunk, encoding, cb) { - if (typeof encoding === 'function') - cb = encoding, encoding = null - if (typeof chunk === 'string') - chunk = Buffer.from(chunk, encoding) - else if (!Buffer.isBuffer(chunk)) - return this.emit('error', new TypeError( - 'Can only parse JSON from string or buffer input')) - this[_parser].write(chunk) - if (cb) - cb() - return this.flowing - } - - end (chunk, encoding, cb) { - this[_ending] = true - if (typeof encoding === 'function') - cb = encoding, encoding = null - if (typeof chunk === 'function') - cb = chunk, chunk = null - if (chunk) - this.write(chunk, encoding) - if (cb) - this.once('end', cb) - - const h = this[_header] - this[_header] = null - const f = this[_footer] - this[_footer] = null - if (h) - this.emit('header', h) - if (f) - this.emit('footer', f) - return super.end() - } - - static get JSONStreamError () { return JSONStreamError } - static parse (path, map) { - return new JSONStream({path, map}) - } -} - -module.exports = JSONStream diff --git a/node_modules/minipass-json-stream/node_modules/minipass/LICENSE b/node_modules/minipass-json-stream/node_modules/minipass/LICENSE deleted file mode 100644 index bf1dece2e1f12..0000000000000 --- a/node_modules/minipass-json-stream/node_modules/minipass/LICENSE +++ /dev/null @@ -1,15 +0,0 @@ -The ISC License - -Copyright (c) 2017-2022 npm, Inc., 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. diff --git a/node_modules/minipass-json-stream/node_modules/minipass/index.js b/node_modules/minipass-json-stream/node_modules/minipass/index.js deleted file mode 100644 index e8797aab6cc27..0000000000000 --- a/node_modules/minipass-json-stream/node_modules/minipass/index.js +++ /dev/null @@ -1,649 +0,0 @@ -'use strict' -const proc = typeof process === 'object' && process ? process : { - stdout: null, - stderr: null, -} -const EE = require('events') -const Stream = require('stream') -const SD = require('string_decoder').StringDecoder - -const EOF = Symbol('EOF') -const MAYBE_EMIT_END = Symbol('maybeEmitEnd') -const EMITTED_END = Symbol('emittedEnd') -const EMITTING_END = Symbol('emittingEnd') -const EMITTED_ERROR = Symbol('emittedError') -const CLOSED = Symbol('closed') -const READ = Symbol('read') -const FLUSH = Symbol('flush') -const FLUSHCHUNK = Symbol('flushChunk') -const ENCODING = Symbol('encoding') -const DECODER = Symbol('decoder') -const FLOWING = Symbol('flowing') -const PAUSED = Symbol('paused') -const RESUME = Symbol('resume') -const BUFFERLENGTH = Symbol('bufferLength') -const BUFFERPUSH = Symbol('bufferPush') -const BUFFERSHIFT = Symbol('bufferShift') -const OBJECTMODE = Symbol('objectMode') -const DESTROYED = Symbol('destroyed') -const EMITDATA = Symbol('emitData') -const EMITEND = Symbol('emitEnd') -const EMITEND2 = Symbol('emitEnd2') -const ASYNC = Symbol('async') - -const defer = fn => Promise.resolve().then(fn) - -// TODO remove when Node v8 support drops -const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1' -const ASYNCITERATOR = doIter && Symbol.asyncIterator - || Symbol('asyncIterator not implemented') -const ITERATOR = doIter && Symbol.iterator - || Symbol('iterator not implemented') - -// events that mean 'the stream is over' -// these are treated specially, and re-emitted -// if they are listened for after emitting. -const isEndish = ev => - ev === 'end' || - ev === 'finish' || - ev === 'prefinish' - -const isArrayBuffer = b => b instanceof ArrayBuffer || - typeof b === 'object' && - b.constructor && - b.constructor.name === 'ArrayBuffer' && - b.byteLength >= 0 - -const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b) - -class Pipe { - constructor (src, dest, opts) { - this.src = src - this.dest = dest - this.opts = opts - this.ondrain = () => src[RESUME]() - dest.on('drain', this.ondrain) - } - unpipe () { - this.dest.removeListener('drain', this.ondrain) - } - // istanbul ignore next - only here for the prototype - proxyErrors () {} - end () { - this.unpipe() - if (this.opts.end) - this.dest.end() - } -} - -class PipeProxyErrors extends Pipe { - unpipe () { - this.src.removeListener('error', this.proxyErrors) - super.unpipe() - } - constructor (src, dest, opts) { - super(src, dest, opts) - this.proxyErrors = er => dest.emit('error', er) - src.on('error', this.proxyErrors) - } -} - -module.exports = class Minipass extends Stream { - constructor (options) { - super() - this[FLOWING] = false - // whether we're explicitly paused - this[PAUSED] = false - this.pipes = [] - this.buffer = [] - this[OBJECTMODE] = options && options.objectMode || false - if (this[OBJECTMODE]) - this[ENCODING] = null - else - this[ENCODING] = options && options.encoding || null - if (this[ENCODING] === 'buffer') - this[ENCODING] = null - this[ASYNC] = options && !!options.async || false - this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null - this[EOF] = false - this[EMITTED_END] = false - this[EMITTING_END] = false - this[CLOSED] = false - this[EMITTED_ERROR] = null - this.writable = true - this.readable = true - this[BUFFERLENGTH] = 0 - this[DESTROYED] = false - } - - get bufferLength () { return this[BUFFERLENGTH] } - - get encoding () { return this[ENCODING] } - set encoding (enc) { - if (this[OBJECTMODE]) - throw new Error('cannot set encoding in objectMode') - - if (this[ENCODING] && enc !== this[ENCODING] && - (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH])) - throw new Error('cannot change encoding') - - if (this[ENCODING] !== enc) { - this[DECODER] = enc ? new SD(enc) : null - if (this.buffer.length) - this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk)) - } - - this[ENCODING] = enc - } - - setEncoding (enc) { - this.encoding = enc - } - - get objectMode () { return this[OBJECTMODE] } - set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om } - - get ['async'] () { return this[ASYNC] } - set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a } - - write (chunk, encoding, cb) { - if (this[EOF]) - throw new Error('write after end') - - if (this[DESTROYED]) { - this.emit('error', Object.assign( - new Error('Cannot call write after a stream was destroyed'), - { code: 'ERR_STREAM_DESTROYED' } - )) - return true - } - - if (typeof encoding === 'function') - cb = encoding, encoding = 'utf8' - - if (!encoding) - encoding = 'utf8' - - const fn = this[ASYNC] ? defer : f => f() - - // convert array buffers and typed array views into buffers - // at some point in the future, we may want to do the opposite! - // leave strings and buffers as-is - // anything else switches us into object mode - if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) { - if (isArrayBufferView(chunk)) - chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength) - else if (isArrayBuffer(chunk)) - chunk = Buffer.from(chunk) - else if (typeof chunk !== 'string') - // use the setter so we throw if we have encoding set - this.objectMode = true - } - - // handle object mode up front, since it's simpler - // this yields better performance, fewer checks later. - if (this[OBJECTMODE]) { - /* istanbul ignore if - maybe impossible? */ - if (this.flowing && this[BUFFERLENGTH] !== 0) - this[FLUSH](true) - - if (this.flowing) - this.emit('data', chunk) - else - this[BUFFERPUSH](chunk) - - if (this[BUFFERLENGTH] !== 0) - this.emit('readable') - - if (cb) - fn(cb) - - return this.flowing - } - - // at this point the chunk is a buffer or string - // don't buffer it up or send it to the decoder - if (!chunk.length) { - if (this[BUFFERLENGTH] !== 0) - this.emit('readable') - if (cb) - fn(cb) - return this.flowing - } - - // fast-path writing strings of same encoding to a stream with - // an empty buffer, skipping the buffer/decoder dance - if (typeof chunk === 'string' && - // unless it is a string already ready for us to use - !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) { - chunk = Buffer.from(chunk, encoding) - } - - if (Buffer.isBuffer(chunk) && this[ENCODING]) - chunk = this[DECODER].write(chunk) - - // Note: flushing CAN potentially switch us into not-flowing mode - if (this.flowing && this[BUFFERLENGTH] !== 0) - this[FLUSH](true) - - if (this.flowing) - this.emit('data', chunk) - else - this[BUFFERPUSH](chunk) - - if (this[BUFFERLENGTH] !== 0) - this.emit('readable') - - if (cb) - fn(cb) - - return this.flowing - } - - read (n) { - if (this[DESTROYED]) - return null - - if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) { - this[MAYBE_EMIT_END]() - return null - } - - if (this[OBJECTMODE]) - n = null - - if (this.buffer.length > 1 && !this[OBJECTMODE]) { - if (this.encoding) - this.buffer = [this.buffer.join('')] - else - this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])] - } - - const ret = this[READ](n || null, this.buffer[0]) - this[MAYBE_EMIT_END]() - return ret - } - - [READ] (n, chunk) { - if (n === chunk.length || n === null) - this[BUFFERSHIFT]() - else { - this.buffer[0] = chunk.slice(n) - chunk = chunk.slice(0, n) - this[BUFFERLENGTH] -= n - } - - this.emit('data', chunk) - - if (!this.buffer.length && !this[EOF]) - this.emit('drain') - - return chunk - } - - end (chunk, encoding, cb) { - if (typeof chunk === 'function') - cb = chunk, chunk = null - if (typeof encoding === 'function') - cb = encoding, encoding = 'utf8' - if (chunk) - this.write(chunk, encoding) - if (cb) - this.once('end', cb) - this[EOF] = true - this.writable = false - - // if we haven't written anything, then go ahead and emit, - // even if we're not reading. - // we'll re-emit if a new 'end' listener is added anyway. - // This makes MP more suitable to write-only use cases. - if (this.flowing || !this[PAUSED]) - this[MAYBE_EMIT_END]() - return this - } - - // don't let the internal resume be overwritten - [RESUME] () { - if (this[DESTROYED]) - return - - this[PAUSED] = false - this[FLOWING] = true - this.emit('resume') - if (this.buffer.length) - this[FLUSH]() - else if (this[EOF]) - this[MAYBE_EMIT_END]() - else - this.emit('drain') - } - - resume () { - return this[RESUME]() - } - - pause () { - this[FLOWING] = false - this[PAUSED] = true - } - - get destroyed () { - return this[DESTROYED] - } - - get flowing () { - return this[FLOWING] - } - - get paused () { - return this[PAUSED] - } - - [BUFFERPUSH] (chunk) { - if (this[OBJECTMODE]) - this[BUFFERLENGTH] += 1 - else - this[BUFFERLENGTH] += chunk.length - this.buffer.push(chunk) - } - - [BUFFERSHIFT] () { - if (this.buffer.length) { - if (this[OBJECTMODE]) - this[BUFFERLENGTH] -= 1 - else - this[BUFFERLENGTH] -= this.buffer[0].length - } - return this.buffer.shift() - } - - [FLUSH] (noDrain) { - do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]())) - - if (!noDrain && !this.buffer.length && !this[EOF]) - this.emit('drain') - } - - [FLUSHCHUNK] (chunk) { - return chunk ? (this.emit('data', chunk), this.flowing) : false - } - - pipe (dest, opts) { - if (this[DESTROYED]) - return - - const ended = this[EMITTED_END] - opts = opts || {} - if (dest === proc.stdout || dest === proc.stderr) - opts.end = false - else - opts.end = opts.end !== false - opts.proxyErrors = !!opts.proxyErrors - - // piping an ended stream ends immediately - if (ended) { - if (opts.end) - dest.end() - } else { - this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts) - : new PipeProxyErrors(this, dest, opts)) - if (this[ASYNC]) - defer(() => this[RESUME]()) - else - this[RESUME]() - } - - return dest - } - - unpipe (dest) { - const p = this.pipes.find(p => p.dest === dest) - if (p) { - this.pipes.splice(this.pipes.indexOf(p), 1) - p.unpipe() - } - } - - addListener (ev, fn) { - return this.on(ev, fn) - } - - on (ev, fn) { - const ret = super.on(ev, fn) - if (ev === 'data' && !this.pipes.length && !this.flowing) - this[RESUME]() - else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) - super.emit('readable') - else if (isEndish(ev) && this[EMITTED_END]) { - super.emit(ev) - this.removeAllListeners(ev) - } else if (ev === 'error' && this[EMITTED_ERROR]) { - if (this[ASYNC]) - defer(() => fn.call(this, this[EMITTED_ERROR])) - else - fn.call(this, this[EMITTED_ERROR]) - } - return ret - } - - get emittedEnd () { - return this[EMITTED_END] - } - - [MAYBE_EMIT_END] () { - if (!this[EMITTING_END] && - !this[EMITTED_END] && - !this[DESTROYED] && - this.buffer.length === 0 && - this[EOF]) { - this[EMITTING_END] = true - this.emit('end') - this.emit('prefinish') - this.emit('finish') - if (this[CLOSED]) - this.emit('close') - this[EMITTING_END] = false - } - } - - emit (ev, data, ...extra) { - // error and close are only events allowed after calling destroy() - if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED]) - return - else if (ev === 'data') { - return !data ? false - : this[ASYNC] ? defer(() => this[EMITDATA](data)) - : this[EMITDATA](data) - } else if (ev === 'end') { - return this[EMITEND]() - } else if (ev === 'close') { - this[CLOSED] = true - // don't emit close before 'end' and 'finish' - if (!this[EMITTED_END] && !this[DESTROYED]) - return - const ret = super.emit('close') - this.removeAllListeners('close') - return ret - } else if (ev === 'error') { - this[EMITTED_ERROR] = data - const ret = super.emit('error', data) - this[MAYBE_EMIT_END]() - return ret - } else if (ev === 'resume') { - const ret = super.emit('resume') - this[MAYBE_EMIT_END]() - return ret - } else if (ev === 'finish' || ev === 'prefinish') { - const ret = super.emit(ev) - this.removeAllListeners(ev) - return ret - } - - // Some other unknown event - const ret = super.emit(ev, data, ...extra) - this[MAYBE_EMIT_END]() - return ret - } - - [EMITDATA] (data) { - for (const p of this.pipes) { - if (p.dest.write(data) === false) - this.pause() - } - const ret = super.emit('data', data) - this[MAYBE_EMIT_END]() - return ret - } - - [EMITEND] () { - if (this[EMITTED_END]) - return - - this[EMITTED_END] = true - this.readable = false - if (this[ASYNC]) - defer(() => this[EMITEND2]()) - else - this[EMITEND2]() - } - - [EMITEND2] () { - if (this[DECODER]) { - const data = this[DECODER].end() - if (data) { - for (const p of this.pipes) { - p.dest.write(data) - } - super.emit('data', data) - } - } - - for (const p of this.pipes) { - p.end() - } - const ret = super.emit('end') - this.removeAllListeners('end') - return ret - } - - // const all = await stream.collect() - collect () { - const buf = [] - if (!this[OBJECTMODE]) - buf.dataLength = 0 - // set the promise first, in case an error is raised - // by triggering the flow here. - const p = this.promise() - this.on('data', c => { - buf.push(c) - if (!this[OBJECTMODE]) - buf.dataLength += c.length - }) - return p.then(() => buf) - } - - // const data = await stream.concat() - concat () { - return this[OBJECTMODE] - ? Promise.reject(new Error('cannot concat in objectMode')) - : this.collect().then(buf => - this[OBJECTMODE] - ? Promise.reject(new Error('cannot concat in objectMode')) - : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength)) - } - - // stream.promise().then(() => done, er => emitted error) - promise () { - return new Promise((resolve, reject) => { - this.on(DESTROYED, () => reject(new Error('stream destroyed'))) - this.on('error', er => reject(er)) - this.on('end', () => resolve()) - }) - } - - // for await (let chunk of stream) - [ASYNCITERATOR] () { - const next = () => { - const res = this.read() - if (res !== null) - return Promise.resolve({ done: false, value: res }) - - if (this[EOF]) - return Promise.resolve({ done: true }) - - let resolve = null - let reject = null - const onerr = er => { - this.removeListener('data', ondata) - this.removeListener('end', onend) - reject(er) - } - const ondata = value => { - this.removeListener('error', onerr) - this.removeListener('end', onend) - this.pause() - resolve({ value: value, done: !!this[EOF] }) - } - const onend = () => { - this.removeListener('error', onerr) - this.removeListener('data', ondata) - resolve({ done: true }) - } - const ondestroy = () => onerr(new Error('stream destroyed')) - return new Promise((res, rej) => { - reject = rej - resolve = res - this.once(DESTROYED, ondestroy) - this.once('error', onerr) - this.once('end', onend) - this.once('data', ondata) - }) - } - - return { next } - } - - // for (let chunk of stream) - [ITERATOR] () { - const next = () => { - const value = this.read() - const done = value === null - return { value, done } - } - return { next } - } - - destroy (er) { - if (this[DESTROYED]) { - if (er) - this.emit('error', er) - else - this.emit(DESTROYED) - return this - } - - this[DESTROYED] = true - - // throw away all buffered data, it's never coming out - this.buffer.length = 0 - this[BUFFERLENGTH] = 0 - - if (typeof this.close === 'function' && !this[CLOSED]) - this.close() - - if (er) - this.emit('error', er) - else // if no error to emit, still reject pending promises - this.emit(DESTROYED) - - return this - } - - static isStream (s) { - return !!s && (s instanceof Minipass || s instanceof Stream || - s instanceof EE && ( - typeof s.pipe === 'function' || // readable - (typeof s.write === 'function' && typeof s.end === 'function') // writable - )) - } -} diff --git a/node_modules/minipass-json-stream/node_modules/minipass/package.json b/node_modules/minipass-json-stream/node_modules/minipass/package.json deleted file mode 100644 index 548d03fa6d5d4..0000000000000 --- a/node_modules/minipass-json-stream/node_modules/minipass/package.json +++ /dev/null @@ -1,56 +0,0 @@ -{ - "name": "minipass", - "version": "3.3.6", - "description": "minimal implementation of a PassThrough stream", - "main": "index.js", - "types": "index.d.ts", - "dependencies": { - "yallist": "^4.0.0" - }, - "devDependencies": { - "@types/node": "^17.0.41", - "end-of-stream": "^1.4.0", - "prettier": "^2.6.2", - "tap": "^16.2.0", - "through2": "^2.0.3", - "ts-node": "^10.8.1", - "typescript": "^4.7.3" - }, - "scripts": { - "test": "tap", - "preversion": "npm test", - "postversion": "npm publish", - "postpublish": "git push origin --follow-tags" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/isaacs/minipass.git" - }, - "keywords": [ - "passthrough", - "stream" - ], - "author": "Isaac Z. Schlueter (http://blog.izs.me/)", - "license": "ISC", - "files": [ - "index.d.ts", - "index.js" - ], - "tap": { - "check-coverage": true - }, - "engines": { - "node": ">=8" - }, - "prettier": { - "semi": false, - "printWidth": 80, - "tabWidth": 2, - "useTabs": false, - "singleQuote": true, - "jsxSingleQuote": false, - "bracketSameLine": true, - "arrowParens": "avoid", - "endOfLine": "lf" - } -} diff --git a/node_modules/minipass-json-stream/package.json b/node_modules/minipass-json-stream/package.json deleted file mode 100644 index 19d1f358fce62..0000000000000 --- a/node_modules/minipass-json-stream/package.json +++ /dev/null @@ -1,39 +0,0 @@ -{ - "name": "minipass-json-stream", - "version": "1.0.1", - "description": "Like JSONStream, but using Minipass streams", - "author": "Isaac Z. Schlueter (https://izs.me)", - "license": "MIT", - "scripts": { - "test": "tap", - "snap": "tap", - "preversion": "npm test", - "postversion": "npm publish", - "postpublish": "git push origin --follow-tags" - }, - "tap": { - "check-coverage": true - }, - "devDependencies": { - "JSONStream": "^1.3.5", - "tap": "^14.6.9" - }, - "dependencies": { - "jsonparse": "^1.3.1", - "minipass": "^3.0.0" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/npm/minipass-json-stream.git" - }, - "keywords": [ - "stream", - "json", - "parse", - "minipass", - "JSONStream" - ], - "files": [ - "index.js" - ] -} diff --git a/node_modules/npm-registry-fetch/lib/index.js b/node_modules/npm-registry-fetch/lib/index.js index bce6e6b1aae0a..898c8125bfe0e 100644 --- a/node_modules/npm-registry-fetch/lib/index.js +++ b/node_modules/npm-registry-fetch/lib/index.js @@ -4,7 +4,7 @@ const { HttpErrorAuthOTP } = require('./errors.js') const checkResponse = require('./check-response.js') const getAuth = require('./auth.js') const fetch = require('make-fetch-happen') -const JSONStream = require('minipass-json-stream') +const JSONStream = require('./json-stream') const npa = require('npm-package-arg') const qs = require('querystring') const url = require('url') diff --git a/node_modules/npm-registry-fetch/lib/json-stream.js b/node_modules/npm-registry-fetch/lib/json-stream.js new file mode 100644 index 0000000000000..36b05ad4a20b9 --- /dev/null +++ b/node_modules/npm-registry-fetch/lib/json-stream.js @@ -0,0 +1,223 @@ +const Parser = require('jsonparse') +const { Minipass } = require('minipass') + +class JSONStreamError extends Error { + constructor (err, caller) { + super(err.message) + Error.captureStackTrace(this, caller || this.constructor) + } + + get name () { + return 'JSONStreamError' + } +} + +const check = (x, y) => + typeof x === 'string' ? String(y) === x + : x && typeof x.test === 'function' ? x.test(y) + : typeof x === 'boolean' || typeof x === 'object' ? x + : typeof x === 'function' ? x(y) + : false + +class JSONStream extends Minipass { + #count = 0 + #ending = false + #footer = null + #header = null + #map = null + #onTokenOriginal + #parser + #path = null + #root = null + + constructor (opts) { + super({ + ...opts, + objectMode: true, + }) + + const parser = this.#parser = new Parser() + parser.onValue = value => this.#onValue(value) + this.#onTokenOriginal = parser.onToken + parser.onToken = (token, value) => this.#onToken(token, value) + parser.onError = er => this.#onError(er) + + this.#path = typeof opts.path === 'string' + ? opts.path.split('.').map(e => + e === '$*' ? { emitKey: true } + : e === '*' ? true + : e === '' ? { recurse: true } + : e) + : Array.isArray(opts.path) && opts.path.length ? opts.path + : null + + if (typeof opts.map === 'function') { + this.#map = opts.map + } + } + + #setHeaderFooter (key, value) { + // header has not been emitted yet + if (this.#header !== false) { + this.#header = this.#header || {} + this.#header[key] = value + } + + // footer has not been emitted yet but header has + if (this.#footer !== false && this.#header === false) { + this.#footer = this.#footer || {} + this.#footer[key] = value + } + } + + #onError (er) { + // error will always happen during a write() call. + const caller = this.#ending ? this.end : this.write + this.#ending = false + return this.emit('error', new JSONStreamError(er, caller)) + } + + #onToken (token, value) { + const parser = this.#parser + this.#onTokenOriginal.call(this.#parser, token, value) + if (parser.stack.length === 0) { + if (this.#root) { + const root = this.#root + if (!this.#path) { + super.write(root) + } + this.#root = null + this.#count = 0 + } + } + } + + #onValue (value) { + const parser = this.#parser + // the LAST onValue encountered is the root object. + // just overwrite it each time. + this.#root = value + + if (!this.#path) { + return + } + + let i = 0 // iterates on path + let j = 0 // iterates on stack + let emitKey = false + while (i < this.#path.length) { + const key = this.#path[i] + j++ + + if (key && !key.recurse) { + const c = (j === parser.stack.length) ? parser : parser.stack[j] + if (!c) { + return + } + if (!check(key, c.key)) { + this.#setHeaderFooter(c.key, value) + return + } + emitKey = !!key.emitKey + i++ + } else { + i++ + if (i >= this.#path.length) { + return + } + const nextKey = this.#path[i] + if (!nextKey) { + return + } + while (true) { + const c = (j === parser.stack.length) ? parser : parser.stack[j] + if (!c) { + return + } + if (check(nextKey, c.key)) { + i++ + if (!Object.isFrozen(parser.stack[j])) { + parser.stack[j].value = null + } + break + } else { + this.#setHeaderFooter(c.key, value) + } + j++ + } + } + } + + // emit header + if (this.#header) { + const header = this.#header + this.#header = false + this.emit('header', header) + } + if (j !== parser.stack.length) { + return + } + + this.#count++ + const actualPath = parser.stack.slice(1) + .map(e => e.key).concat([parser.key]) + if (value !== null && value !== undefined) { + const data = this.#map ? this.#map(value, actualPath) : value + if (data !== null && data !== undefined) { + const emit = emitKey ? { value: data } : data + if (emitKey) { + emit.key = parser.key + } + super.write(emit) + } + } + + if (parser.value) { + delete parser.value[parser.key] + } + + for (const k of parser.stack) { + k.value = null + } + } + + write (chunk, encoding) { + if (typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding) + } else if (!Buffer.isBuffer(chunk)) { + return this.emit('error', new TypeError( + 'Can only parse JSON from string or buffer input')) + } + this.#parser.write(chunk) + return this.flowing + } + + end (chunk, encoding) { + this.#ending = true + if (chunk) { + this.write(chunk, encoding) + } + + const h = this.#header + this.#header = null + const f = this.#footer + this.#footer = null + if (h) { + this.emit('header', h) + } + if (f) { + this.emit('footer', f) + } + return super.end() + } + + static get JSONStreamError () { + return JSONStreamError + } + + static parse (path, map) { + return new JSONStream({ path, map }) + } +} + +module.exports = JSONStream diff --git a/node_modules/npm-registry-fetch/package.json b/node_modules/npm-registry-fetch/package.json index 567dedb40f70b..07ea620d15317 100644 --- a/node_modules/npm-registry-fetch/package.json +++ b/node_modules/npm-registry-fetch/package.json @@ -1,6 +1,6 @@ { "name": "npm-registry-fetch", - "version": "17.0.1", + "version": "17.1.0", "description": "Fetch-based http client for use with npm registry APIs", "main": "lib", "files": [ @@ -21,7 +21,7 @@ }, "repository": { "type": "git", - "url": "https://github.com/npm/npm-registry-fetch.git" + "url": "git+https://github.com/npm/npm-registry-fetch.git" }, "keywords": [ "npm", @@ -32,17 +32,17 @@ "license": "ISC", "dependencies": { "@npmcli/redact": "^2.0.0", + "jsonparse": "^1.3.1", "make-fetch-happen": "^13.0.0", "minipass": "^7.0.2", "minipass-fetch": "^3.0.0", - "minipass-json-stream": "^1.0.1", "minizlib": "^2.1.2", "npm-package-arg": "^11.0.0", "proc-log": "^4.0.0" }, "devDependencies": { "@npmcli/eslint-config": "^4.0.0", - "@npmcli/template-oss": "4.21.4", + "@npmcli/template-oss": "4.22.0", "cacache": "^18.0.0", "nock": "^13.2.4", "require-inject": "^1.4.4", @@ -62,7 +62,7 @@ }, "templateOSS": { "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", - "version": "4.21.4", + "version": "4.22.0", "publish": "true" } } diff --git a/package-lock.json b/package-lock.json index 03c1ffb10f476..996c649c01cf8 100644 --- a/package-lock.json +++ b/package-lock.json @@ -135,7 +135,7 @@ "npm-package-arg": "^11.0.2", "npm-pick-manifest": "^9.0.1", "npm-profile": "^10.0.0", - "npm-registry-fetch": "^17.0.1", + "npm-registry-fetch": "^17.1.0", "npm-user-validate": "^2.0.1", "p-map": "^4.0.0", "pacote": "^18.0.6", @@ -9123,30 +9123,6 @@ "node": ">=8" } }, - "node_modules/minipass-json-stream": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/minipass-json-stream/-/minipass-json-stream-1.0.1.tgz", - "integrity": "sha512-ODqY18UZt/I8k+b7rl2AENgbWE8IDYam+undIJONvigAz8KR5GWblsFTEfQs0WODsjbSXWlm+JHEv8Gr6Tfdbg==", - "inBundle": true, - "license": "MIT", - "dependencies": { - "jsonparse": "^1.3.1", - "minipass": "^3.0.0" - } - }, - "node_modules/minipass-json-stream/node_modules/minipass": { - "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", - "inBundle": true, - "license": "ISC", - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/minipass-pipeline": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", @@ -9591,17 +9567,17 @@ } }, "node_modules/npm-registry-fetch": { - "version": "17.0.1", - "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-17.0.1.tgz", - "integrity": "sha512-fLu9MTdZTlJAHUek/VLklE6EpIiP3VZpTiuN7OOMCt2Sd67NCpSEetMaxHHEZiZxllp8ZLsUpvbEszqTFEc+wA==", + "version": "17.1.0", + "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-17.1.0.tgz", + "integrity": "sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==", "inBundle": true, "license": "ISC", "dependencies": { "@npmcli/redact": "^2.0.0", + "jsonparse": "^1.3.1", "make-fetch-happen": "^13.0.0", "minipass": "^7.0.2", "minipass-fetch": "^3.0.0", - "minipass-json-stream": "^1.0.1", "minizlib": "^2.1.2", "npm-package-arg": "^11.0.0", "proc-log": "^4.0.0" diff --git a/package.json b/package.json index b2387fd145964..4cff4eac43c23 100644 --- a/package.json +++ b/package.json @@ -100,7 +100,7 @@ "npm-package-arg": "^11.0.2", "npm-pick-manifest": "^9.0.1", "npm-profile": "^10.0.0", - "npm-registry-fetch": "^17.0.1", + "npm-registry-fetch": "^17.1.0", "npm-user-validate": "^2.0.1", "p-map": "^4.0.0", "pacote": "^18.0.6",