cline 1.0.0 → 1.0.2

package/node_modules/tar-stream/pack.js

@@ -1,255 +1,287 @@
-var constants = require('fs-constants')
-var eos = require('end-of-stream')
-var inherits = require('inherits')
-var alloc = Buffer.alloc
+const { Readable, Writable, getStreamError } = require('streamx')
+const b4a = require('b4a')
 
-var Readable = require('readable-stream').Readable
-var Writable = require('readable-stream').Writable
-var StringDecoder = require('string_decoder').StringDecoder
+const constants = require('./constants')
+const headers = require('./headers')
 
-var headers = require('./headers')
+const DMODE = 0o755
+const FMODE = 0o644
 
-var DMODE = parseInt('755', 8)
-var FMODE = parseInt('644', 8)
+const END_OF_TAR = b4a.alloc(1024)
 
-var END_OF_TAR = alloc(1024)
+class Sink extends Writable {
+  constructor (pack, header, callback) {
+    super({ mapWritable, eagerOpen: true })
 
-var noop = function () {}
+    this.written = 0
+    this.header = header
 
-var overflow = function (self, size) {
-  size &= 511
-  if (size) self.push(END_OF_TAR.slice(0, 512 - size))
-}
+    this._callback = callback
+    this._linkname = null
+    this._isLinkname = header.type === 'symlink' && !header.linkname
+    this._isVoid = header.type !== 'file' && header.type !== 'contiguous-file'
+    this._finished = false
+    this._pack = pack
+    this._openCallback = null
 
-function modeToType (mode) {
-  switch (mode & constants.S_IFMT) {
-    case constants.S_IFBLK: return 'block-device'
-    case constants.S_IFCHR: return 'character-device'
-    case constants.S_IFDIR: return 'directory'
-    case constants.S_IFIFO: return 'fifo'
-    case constants.S_IFLNK: return 'symlink'
+    if (this._pack._stream === null) this._pack._stream = this
+    else this._pack._pending.push(this)
   }
 
-  return 'file'
-}
+  _open (cb) {
+    this._openCallback = cb
+    if (this._pack._stream === this) this._continueOpen()
+  }
 
-var Sink = function (to) {
-  Writable.call(this)
-  this.written = 0
-  this._to = to
-  this._destroyed = false
-}
+  _continuePack (err) {
+    if (this._callback === null) return
 
-inherits(Sink, Writable)
+    const callback = this._callback
+    this._callback = null
 
-Sink.prototype._write = function (data, enc, cb) {
-  this.written += data.length
-  if (this._to.push(data)) return cb()
-  this._to._drain = cb
-}
+    callback(err)
+  }
 
-Sink.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
+  _continueOpen () {
+    if (this._pack._stream === null) this._pack._stream = this
 
-var LinkSink = function () {
-  Writable.call(this)
-  this.linkname = ''
-  this._decoder = new StringDecoder('utf-8')
-  this._destroyed = false
-}
+    const cb = this._openCallback
+    this._openCallback = null
+    if (cb === null) return
 
-inherits(LinkSink, Writable)
+    if (this._pack.destroying) return cb(new Error('pack stream destroyed'))
+    if (this._pack._finalized) return cb(new Error('pack stream is already finalized'))
 
-LinkSink.prototype._write = function (data, enc, cb) {
-  this.linkname += this._decoder.write(data)
-  cb()
-}
+    this._pack._stream = this
 
-LinkSink.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
+    if (!this._isLinkname) {
+      this._pack._encode(this.header)
+    }
 
-var Void = function () {
-  Writable.call(this)
-  this._destroyed = false
-}
+    if (this._isVoid) {
+      this._finish()
+      this._continuePack(null)
+    }
 
-inherits(Void, Writable)
+    cb(null)
+  }
 
-Void.prototype._write = function (data, enc, cb) {
-  cb(new Error('No body allowed for this entry'))
-}
+  _write (data, cb) {
+    if (this._isLinkname) {
+      this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data
+      return cb(null)
+    }
 
-Void.prototype.destroy = function () {
-  if (this._destroyed) return
-  this._destroyed = true
-  this.emit('close')
-}
+    if (this._isVoid) {
+      if (data.byteLength > 0) {
+        return cb(new Error('No body allowed for this entry'))
+      }
+      return cb()
+    }
 
-var Pack = function (opts) {
-  if (!(this instanceof Pack)) return new Pack(opts)
-  Readable.call(this, opts)
+    this.written += data.byteLength
+    if (this._pack.push(data)) return cb()
+    this._pack._drain = cb
+  }
 
-  this._drain = noop
-  this._finalized = false
-  this._finalizing = false
-  this._destroyed = false
-  this._stream = null
-}
+  _finish () {
+    if (this._finished) return
+    this._finished = true
 
-inherits(Pack, Readable)
+    if (this._isLinkname) {
+      this.header.linkname = this._linkname ? b4a.toString(this._linkname, 'utf-8') : ''
+      this._pack._encode(this.header)
+    }
 
-Pack.prototype.entry = function (header, buffer, callback) {
-  if (this._stream) throw new Error('already piping an entry')
-  if (this._finalized || this._destroyed) return
+    overflow(this._pack, this.header.size)
 
-  if (typeof buffer === 'function') {
-    callback = buffer
-    buffer = null
+    this._pack._done(this)
   }
 
-  if (!callback) callback = noop
+  _final (cb) {
+    if (this.written !== this.header.size) { // corrupting tar
+      return cb(new Error('Size mismatch'))
+    }
 
-  var self = this
+    this._finish()
+    cb(null)
+  }
 
-  if (!header.size || header.type === 'symlink') header.size = 0
-  if (!header.type) header.type = modeToType(header.mode)
-  if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE
-  if (!header.uid) header.uid = 0
-  if (!header.gid) header.gid = 0
-  if (!header.mtime) header.mtime = new Date()
+  _getError () {
+    return getStreamError(this) || new Error('tar entry destroyed')
+  }
 
-  if (typeof buffer === 'string') buffer = Buffer.from(buffer)
-  if (Buffer.isBuffer(buffer)) {
-    header.size = buffer.length
-    this._encode(header)
-    var ok = this.push(buffer)
-    overflow(self, header.size)
-    if (ok) process.nextTick(callback)
-    else this._drain = callback
-    return new Void()
+  _predestroy () {
+    this._pack.destroy(this._getError())
   }
 
-  if (header.type === 'symlink' && !header.linkname) {
-    var linkSink = new LinkSink()
-    eos(linkSink, function (err) {
-      if (err) { // stream was closed
-        self.destroy()
-        return callback(err)
-      }
+  _destroy (cb) {
+    this._pack._done(this)
 
-      header.linkname = linkSink.linkname
-      self._encode(header)
-      callback()
-    })
+    this._continuePack(this._finished ? null : this._getError())
 
-    return linkSink
+    cb()
   }
+}
 
-  this._encode(header)
-
-  if (header.type !== 'file' && header.type !== 'contiguous-file') {
-    process.nextTick(callback)
-    return new Void()
+class Pack extends Readable {
+  constructor (opts) {
+    super(opts)
+    this._drain = noop
+    this._finalized = false
+    this._finalizing = false
+    this._pending = []
+    this._stream = null
   }
 
-  var sink = new Sink(this)
+  entry (header, buffer, callback) {
+    if (this._finalized || this.destroying) throw new Error('already finalized or destroyed')
+
+    if (typeof buffer === 'function') {
+      callback = buffer
+      buffer = null
+    }
+
+    if (!callback) callback = noop
+
+    if (!header.size || header.type === 'symlink') header.size = 0
+    if (!header.type) header.type = modeToType(header.mode)
+    if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE
+    if (!header.uid) header.uid = 0
+    if (!header.gid) header.gid = 0
+    if (!header.mtime) header.mtime = new Date()
 
-  this._stream = sink
+    if (typeof buffer === 'string') buffer = b4a.from(buffer)
 
-  eos(sink, function (err) {
-    self._stream = null
+    const sink = new Sink(this, header, callback)
 
-    if (err) { // stream was closed
-      self.destroy()
-      return callback(err)
+    if (b4a.isBuffer(buffer)) {
+      header.size = buffer.byteLength
+      sink.write(buffer)
+      sink.end()
+      return sink
     }
 
-    if (sink.written !== header.size) { // corrupting tar
-      self.destroy()
-      return callback(new Error('size mismatch'))
+    if (sink._isVoid) {
+      return sink
     }
 
-    overflow(self, header.size)
-    if (self._finalizing) self.finalize()
-    callback()
-  })
+    return sink
+  }
 
-  return sink
-}
+  finalize () {
+    if (this._stream || this._pending.length > 0) {
+      this._finalizing = true
+      return
+    }
+
+    if (this._finalized) return
+    this._finalized = true
 
-Pack.prototype.finalize = function () {
-  if (this._stream) {
-    this._finalizing = true
-    return
+    this.push(END_OF_TAR)
+    this.push(null)
   }
 
-  if (this._finalized) return
-  this._finalized = true
-  this.push(END_OF_TAR)
-  this.push(null)
-}
+  _done (stream) {
+    if (stream !== this._stream) return
 
-Pack.prototype.destroy = function (err) {
-  if (this._destroyed) return
-  this._destroyed = true
+    this._stream = null
 
-  if (err) this.emit('error', err)
-  this.emit('close')
-  if (this._stream && this._stream.destroy) this._stream.destroy()
-}
+    if (this._finalizing) this.finalize()
+    if (this._pending.length) this._pending.shift()._continueOpen()
+  }
 
-Pack.prototype._encode = function (header) {
-  if (!header.pax) {
-    var buf = headers.encode(header)
-    if (buf) {
-      this.push(buf)
-      return
+  _encode (header) {
+    if (!header.pax) {
+      const buf = headers.encode(header)
+      if (buf) {
+        this.push(buf)
+        return
+      }
+    }
+    this._encodePax(header)
+  }
+
+  _encodePax (header) {
+    const paxHeader = headers.encodePax({
+      name: header.name,
+      linkname: header.linkname,
+      pax: header.pax
+    })
+
+    const newHeader = {
+      name: 'PaxHeader',
+      mode: header.mode,
+      uid: header.uid,
+      gid: header.gid,
+      size: paxHeader.byteLength,
+      mtime: header.mtime,
+      type: 'pax-header',
+      linkname: header.linkname && 'PaxHeader',
+      uname: header.uname,
+      gname: header.gname,
+      devmajor: header.devmajor,
+      devminor: header.devminor
+    }
+
+    this.push(headers.encode(newHeader))
+    this.push(paxHeader)
+    overflow(this, paxHeader.byteLength)
+
+    newHeader.size = header.size
+    newHeader.type = header.type
+    this.push(headers.encode(newHeader))
+  }
+
+  _doDrain () {
+    const drain = this._drain
+    this._drain = noop
+    drain()
+  }
+
+  _predestroy () {
+    const err = getStreamError(this)
+
+    if (this._stream) this._stream.destroy(err)
+
+    while (this._pending.length) {
+      const stream = this._pending.shift()
+      stream.destroy(err)
+      stream._continueOpen()
     }
+
+    this._doDrain()
+  }
+
+  _read (cb) {
+    this._doDrain()
+    cb()
   }
-  this._encodePax(header)
 }
 
-Pack.prototype._encodePax = function (header) {
-  var paxHeader = headers.encodePax({
-    name: header.name,
-    linkname: header.linkname,
-    pax: header.pax
-  })
-
-  var newHeader = {
-    name: 'PaxHeader',
-    mode: header.mode,
-    uid: header.uid,
-    gid: header.gid,
-    size: paxHeader.length,
-    mtime: header.mtime,
-    type: 'pax-header',
-    linkname: header.linkname && 'PaxHeader',
-    uname: header.uname,
-    gname: header.gname,
-    devmajor: header.devmajor,
-    devminor: header.devminor
-  }
-
-  this.push(headers.encode(newHeader))
-  this.push(paxHeader)
-  overflow(this, paxHeader.length)
-
-  newHeader.size = header.size
-  newHeader.type = header.type
-  this.push(headers.encode(newHeader))
+module.exports = function pack (opts) {
+  return new Pack(opts)
 }
 
-Pack.prototype._read = function (n) {
-  var drain = this._drain
-  this._drain = noop
-  drain()
+function modeToType (mode) {
+  switch (mode & constants.S_IFMT) {
+    case constants.S_IFBLK: return 'block-device'
+    case constants.S_IFCHR: return 'character-device'
+    case constants.S_IFDIR: return 'directory'
+    case constants.S_IFIFO: return 'fifo'
+    case constants.S_IFLNK: return 'symlink'
+  }
+
+  return 'file'
 }
 
-module.exports = Pack
+function noop () {}
+
+function overflow (self, size) {
+  size &= 511
+  if (size) self.push(END_OF_TAR.subarray(0, 512 - size))
+}
+
+function mapWritable (buf) {
+  return b4a.isBuffer(buf) ? buf : b4a.from(buf)
+}

package/node_modules/tar-stream/package.json

@@ -1,58 +1,35 @@
 {
   "name": "tar-stream",
-  "version": "2.2.0",
-  "description": "tar-stream is a streaming tar parser and generator and nothing else. It is streams2 and operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
-  "author": "Mathias Buus <mathiasbuus@gmail.com>",
-  "dependencies": {
-    "bl": "^4.0.3",
-    "end-of-stream": "^1.4.1",
-    "fs-constants": "^1.0.0",
-    "inherits": "^2.0.3",
-    "readable-stream": "^3.1.1"
-  },
-  "devDependencies": {
-    "concat-stream": "^2.0.0",
-    "standard": "^12.0.1",
-    "tape": "^4.9.2"
-  },
-  "scripts": {
-    "test": "standard && tape test/extract.js test/pack.js",
-    "test-all": "standard && tape test/*.js"
-  },
-  "keywords": [
-    "tar",
-    "tarball",
-    "parse",
-    "parser",
-    "generate",
-    "generator",
-    "stream",
-    "stream2",
-    "streams",
-    "streams2",
-    "streaming",
-    "pack",
-    "extract",
-    "modify"
-  ],
-  "bugs": {
-    "url": "https://github.com/mafintosh/tar-stream/issues"
-  },
-  "homepage": "https://github.com/mafintosh/tar-stream",
+  "version": "3.1.7",
+  "description": "tar-stream is a streaming tar parser and generator and nothing else. It operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
   "main": "index.js",
   "files": [
-    "*.js",
-    "LICENSE"
+    "*.js"
   ],
-  "directories": {
-    "test": "test"
+  "browser": {
+    "fs": false
+  },
+  "scripts": {
+    "test": "standard && brittle test/*.js"
   },
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mafintosh/tar-stream.git"
   },
-  "engines": {
-    "node": ">=6"
+  "author": "Mathias Buus <mathiasbuus@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/tar-stream/issues"
+  },
+  "homepage": "https://github.com/mafintosh/tar-stream",
+  "dependencies": {
+    "b4a": "^1.6.4",
+    "fast-fifo": "^1.2.0",
+    "streamx": "^2.15.0"
+  },
+  "devDependencies": {
+    "brittle": "^3.3.2",
+    "concat-stream": "^2.0.0",
+    "standard": "^17.0.1"
   }
 }