pdf-creator-node 2.3.4 → 2.3.5

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/copy/ncp.js

@@ -0,0 +1,232 @@
+// imported from ncp (this is temporary, will rewrite)
+
+var fs = require('graceful-fs')
+var path = require('path')
+var utimes = require('../util/utimes')
+
+function ncp (source, dest, options, callback) {
+  if (!callback) {
+    callback = options
+    options = {}
+  }
+
+  var basePath = process.cwd()
+  var currentPath = path.resolve(basePath, source)
+  var targetPath = path.resolve(basePath, dest)
+
+  var filter = options.filter
+  var transform = options.transform
+  var clobber = options.clobber !== false // default true
+  var dereference = options.dereference
+  var preserveTimestamps = options.preserveTimestamps === true
+
+  var started = 0
+  var finished = 0
+  var running = 0
+
+  var errored = false
+
+  startCopy(currentPath)
+
+  function startCopy (source) {
+    started++
+    if (filter) {
+      if (filter instanceof RegExp) {
+        console.warn('Warning: fs-extra: Passing a RegExp filter is deprecated, use a function')
+        if (!filter.test(source)) {
+          return doneOne(true)
+        }
+      } else if (typeof filter === 'function') {
+        if (!filter(source)) {
+          return doneOne(true)
+        }
+      }
+    }
+    return getStats(source)
+  }
+
+  function getStats (source) {
+    var stat = dereference ? fs.stat : fs.lstat
+    running++
+    stat(source, function (err, stats) {
+      if (err) return onError(err)
+
+      // We need to get the mode from the stats object and preserve it.
+      var item = {
+        name: source,
+        mode: stats.mode,
+        mtime: stats.mtime, // modified time
+        atime: stats.atime, // access time
+        stats: stats // temporary
+      }
+
+      if (stats.isDirectory()) {
+        return onDir(item)
+      } else if (stats.isFile() || stats.isCharacterDevice() || stats.isBlockDevice()) {
+        return onFile(item)
+      } else if (stats.isSymbolicLink()) {
+        // Symlinks don't really need to know about the mode.
+        return onLink(source)
+      }
+    })
+  }
+
+  function onFile (file) {
+    var target = file.name.replace(currentPath, targetPath.replace('$', '$$$$')) // escapes '$' with '$$'
+    isWritable(target, function (writable) {
+      if (writable) {
+        copyFile(file, target)
+      } else {
+        if (clobber) {
+          rmFile(target, function () {
+            copyFile(file, target)
+          })
+        } else {
+          var err = new Error('EEXIST: ' + target + ' already exists.')
+          err.code = 'EEXIST'
+          err.errno = -17
+          err.path = target
+          onError(err)
+        }
+      }
+    })
+  }
+
+  function copyFile (file, target) {
+    var readStream = fs.createReadStream(file.name)
+    var writeStream = fs.createWriteStream(target, { mode: file.mode })
+
+    readStream.on('error', onError)
+    writeStream.on('error', onError)
+
+    if (transform) {
+      transform(readStream, writeStream, file)
+    } else {
+      writeStream.on('open', function () {
+        readStream.pipe(writeStream)
+      })
+    }
+
+    writeStream.once('finish', function () {
+      fs.chmod(target, file.mode, function (err) {
+        if (err) return onError(err)
+        if (preserveTimestamps) {
+          utimes.utimesMillis(target, file.atime, file.mtime, function (err) {
+            if (err) return onError(err)
+            return doneOne()
+          })
+        } else {
+          doneOne()
+        }
+      })
+    })
+  }
+
+  function rmFile (file, done) {
+    fs.unlink(file, function (err) {
+      if (err) return onError(err)
+      return done()
+    })
+  }
+
+  function onDir (dir) {
+    var target = dir.name.replace(currentPath, targetPath.replace('$', '$$$$')) // escapes '$' with '$$'
+    isWritable(target, function (writable) {
+      if (writable) {
+        return mkDir(dir, target)
+      }
+      copyDir(dir.name)
+    })
+  }
+
+  function mkDir (dir, target) {
+    fs.mkdir(target, dir.mode, function (err) {
+      if (err) return onError(err)
+      // despite setting mode in fs.mkdir, doesn't seem to work
+      // so we set it here.
+      fs.chmod(target, dir.mode, function (err) {
+        if (err) return onError(err)
+        copyDir(dir.name)
+      })
+    })
+  }
+
+  function copyDir (dir) {
+    fs.readdir(dir, function (err, items) {
+      if (err) return onError(err)
+      items.forEach(function (item) {
+        startCopy(path.join(dir, item))
+      })
+      return doneOne()
+    })
+  }
+
+  function onLink (link) {
+    var target = link.replace(currentPath, targetPath)
+    fs.readlink(link, function (err, resolvedPath) {
+      if (err) return onError(err)
+      checkLink(resolvedPath, target)
+    })
+  }
+
+  function checkLink (resolvedPath, target) {
+    if (dereference) {
+      resolvedPath = path.resolve(basePath, resolvedPath)
+    }
+    isWritable(target, function (writable) {
+      if (writable) {
+        return makeLink(resolvedPath, target)
+      }
+      fs.readlink(target, function (err, targetDest) {
+        if (err) return onError(err)
+
+        if (dereference) {
+          targetDest = path.resolve(basePath, targetDest)
+        }
+        if (targetDest === resolvedPath) {
+          return doneOne()
+        }
+        return rmFile(target, function () {
+          makeLink(resolvedPath, target)
+        })
+      })
+    })
+  }
+
+  function makeLink (linkPath, target) {
+    fs.symlink(linkPath, target, function (err) {
+      if (err) return onError(err)
+      return doneOne()
+    })
+  }
+
+  function isWritable (path, done) {
+    fs.lstat(path, function (err) {
+      if (err) {
+        if (err.code === 'ENOENT') return done(true)
+        return done(false)
+      }
+      return done(false)
+    })
+  }
+
+  function onError (err) {
+    // ensure callback is defined & called only once:
+    if (!errored && callback !== undefined) {
+      errored = true
+      return callback(err)
+    }
+  }
+
+  function doneOne (skipped) {
+    if (!skipped) running--
+    finished++
+    if ((started === finished) && (running === 0)) {
+      if (callback !== undefined) {
+        return callback(null)
+      }
+    }
+  }
+}
+
+module.exports = ncp

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/copy-sync/copy-file-sync.js

@@ -0,0 +1,42 @@
+var fs = require('graceful-fs')
+
+var BUF_LENGTH = 64 * 1024
+var _buff = new Buffer(BUF_LENGTH)
+
+function copyFileSync (srcFile, destFile, options) {
+  var clobber = options.clobber
+  var preserveTimestamps = options.preserveTimestamps
+
+  if (fs.existsSync(destFile)) {
+    if (clobber) {
+      fs.unlinkSync(destFile)
+    } else {
+      var err = new Error('EEXIST: ' + destFile + ' already exists.')
+      err.code = 'EEXIST'
+      err.errno = -17
+      err.path = destFile
+      throw err
+    }
+  }
+
+  var fdr = fs.openSync(srcFile, 'r')
+  var stat = fs.fstatSync(fdr)
+  var fdw = fs.openSync(destFile, 'w', stat.mode)
+  var bytesRead = 1
+  var pos = 0
+
+  while (bytesRead > 0) {
+    bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
+    fs.writeSync(fdw, _buff, 0, bytesRead)
+    pos += bytesRead
+  }
+
+  if (preserveTimestamps) {
+    fs.futimesSync(fdw, stat.atime, stat.mtime)
+  }
+
+  fs.closeSync(fdr)
+  fs.closeSync(fdw)
+}
+
+module.exports = copyFileSync

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/copy-sync/copy-sync.js

@@ -0,0 +1,56 @@
+var fs = require('graceful-fs')
+var path = require('path')
+var copyFileSync = require('./copy-file-sync')
+var mkdir = require('../mkdirs')
+
+function copySync (src, dest, options) {
+  if (typeof options === 'function' || options instanceof RegExp) {
+    options = {filter: options}
+  }
+
+  options = options || {}
+  options.recursive = !!options.recursive
+
+  // default to true for now
+  options.clobber = 'clobber' in options ? !!options.clobber : true
+  options.dereference = 'dereference' in options ? !!options.dereference : false
+  options.preserveTimestamps = 'preserveTimestamps' in options ? !!options.preserveTimestamps : false
+
+  options.filter = options.filter || function () { return true }
+
+  // Warn about using preserveTimestamps on 32-bit node:
+  if (options.preserveTimestamps && process.arch === 'ia32') {
+    console.warn('fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n' +
+    'see https://github.com/jprichardson/node-fs-extra/issues/269')
+  }
+
+  var stats = (options.recursive && !options.dereference) ? fs.lstatSync(src) : fs.statSync(src)
+  var destFolder = path.dirname(dest)
+  var destFolderExists = fs.existsSync(destFolder)
+  var performCopy = false
+
+  if (stats.isFile()) {
+    if (options.filter instanceof RegExp) {
+      console.warn('Warning: fs-extra: Passing a RegExp filter is deprecated, use a function')
+      performCopy = options.filter.test(src)
+    } else if (typeof options.filter === 'function') performCopy = options.filter(src)
+
+    if (performCopy) {
+      if (!destFolderExists) mkdir.mkdirsSync(destFolder)
+      copyFileSync(src, dest, {clobber: options.clobber, preserveTimestamps: options.preserveTimestamps})
+    }
+  } else if (stats.isDirectory()) {
+    if (!fs.existsSync(dest)) mkdir.mkdirsSync(dest)
+    var contents = fs.readdirSync(src)
+    contents.forEach(function (content) {
+      var opts = options
+      opts.recursive = true
+      copySync(path.join(src, content), path.join(dest, content), opts)
+    })
+  } else if (options.recursive && stats.isSymbolicLink()) {
+    var srcPath = fs.readlinkSync(src)
+    fs.symlinkSync(srcPath, dest)
+  }
+}
+
+module.exports = copySync

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/copy-sync/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  copySync: require('./copy-sync')
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/empty/index.js

@@ -0,0 +1,47 @@
+var fs = require('fs')
+var path = require('path')
+var mkdir = require('../mkdirs')
+var remove = require('../remove')
+
+function emptyDir (dir, callback) {
+  callback = callback || function () {}
+  fs.readdir(dir, function (err, items) {
+    if (err) return mkdir.mkdirs(dir, callback)
+
+    items = items.map(function (item) {
+      return path.join(dir, item)
+    })
+
+    deleteItem()
+
+    function deleteItem () {
+      var item = items.pop()
+      if (!item) return callback()
+      remove.remove(item, function (err) {
+        if (err) return callback(err)
+        deleteItem()
+      })
+    }
+  })
+}
+
+function emptyDirSync (dir) {
+  var items
+  try {
+    items = fs.readdirSync(dir)
+  } catch (err) {
+    return mkdir.mkdirsSync(dir)
+  }
+
+  items.forEach(function (item) {
+    item = path.join(dir, item)
+    remove.removeSync(item)
+  })
+}
+
+module.exports = {
+  emptyDirSync: emptyDirSync,
+  emptydirSync: emptyDirSync,
+  emptyDir: emptyDir,
+  emptydir: emptyDir
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/file.js

@@ -0,0 +1,43 @@
+var path = require('path')
+var fs = require('graceful-fs')
+var mkdir = require('../mkdirs')
+
+function createFile (file, callback) {
+  function makeFile () {
+    fs.writeFile(file, '', function (err) {
+      if (err) return callback(err)
+      callback()
+    })
+  }
+
+  fs.exists(file, function (fileExists) {
+    if (fileExists) return callback()
+    var dir = path.dirname(file)
+    fs.exists(dir, function (dirExists) {
+      if (dirExists) return makeFile()
+      mkdir.mkdirs(dir, function (err) {
+        if (err) return callback(err)
+        makeFile()
+      })
+    })
+  })
+}
+
+function createFileSync (file) {
+  if (fs.existsSync(file)) return
+
+  var dir = path.dirname(file)
+  if (!fs.existsSync(dir)) {
+    mkdir.mkdirsSync(dir)
+  }
+
+  fs.writeFileSync(file, '')
+}
+
+module.exports = {
+  createFile: createFile,
+  createFileSync: createFileSync,
+  // alias
+  ensureFile: createFile,
+  ensureFileSync: createFileSync
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/index.js

@@ -0,0 +1,21 @@
+var file = require('./file')
+var link = require('./link')
+var symlink = require('./symlink')
+
+module.exports = {
+  // file
+  createFile: file.createFile,
+  createFileSync: file.createFileSync,
+  ensureFile: file.createFile,
+  ensureFileSync: file.createFileSync,
+  // link
+  createLink: link.createLink,
+  createLinkSync: link.createLinkSync,
+  ensureLink: link.createLink,
+  ensureLinkSync: link.createLinkSync,
+  // symlink
+  createSymlink: symlink.createSymlink,
+  createSymlinkSync: symlink.createSymlinkSync,
+  ensureSymlink: symlink.createSymlink,
+  ensureSymlinkSync: symlink.createSymlinkSync
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/link.js

@@ -0,0 +1,58 @@
+var path = require('path')
+var fs = require('graceful-fs')
+var mkdir = require('../mkdirs')
+
+function createLink (srcpath, dstpath, callback) {
+  function makeLink (srcpath, dstpath) {
+    fs.link(srcpath, dstpath, function (err) {
+      if (err) return callback(err)
+      callback(null)
+    })
+  }
+
+  fs.exists(dstpath, function (destinationExists) {
+    if (destinationExists) return callback(null)
+    fs.lstat(srcpath, function (err, stat) {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureLink')
+        return callback(err)
+      }
+
+      var dir = path.dirname(dstpath)
+      fs.exists(dir, function (dirExists) {
+        if (dirExists) return makeLink(srcpath, dstpath)
+        mkdir.mkdirs(dir, function (err) {
+          if (err) return callback(err)
+          makeLink(srcpath, dstpath)
+        })
+      })
+    })
+  })
+}
+
+function createLinkSync (srcpath, dstpath, callback) {
+  var destinationExists = fs.existsSync(dstpath)
+  if (destinationExists) return undefined
+
+  try {
+    fs.lstatSync(srcpath)
+  } catch (err) {
+    err.message = err.message.replace('lstat', 'ensureLink')
+    throw err
+  }
+
+  var dir = path.dirname(dstpath)
+  var dirExists = fs.existsSync(dir)
+  if (dirExists) return fs.linkSync(srcpath, dstpath)
+  mkdir.mkdirsSync(dir)
+
+  return fs.linkSync(srcpath, dstpath)
+}
+
+module.exports = {
+  createLink: createLink,
+  createLinkSync: createLinkSync,
+  // alias
+  ensureLink: createLink,
+  ensureLinkSync: createLinkSync
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/symlink-paths.js

@@ -0,0 +1,96 @@
+var path = require('path')
+// path.isAbsolute shim for Node.js 0.10 support
+var fs = require('graceful-fs')
+
+/**
+ * Function that returns two types of paths, one relative to symlink, and one
+ * relative to the current working directory. Checks if path is absolute or
+ * relative. If the path is relative, this function checks if the path is
+ * relative to symlink or relative to current working directory. This is an
+ * initiative to find a smarter `srcpath` to supply when building symlinks.
+ * This allows you to determine which path to use out of one of three possible
+ * types of source paths. The first is an absolute path. This is detected by
+ * `path.isAbsolute()`. When an absolute path is provided, it is checked to
+ * see if it exists. If it does it's used, if not an error is returned
+ * (callback)/ thrown (sync). The other two options for `srcpath` are a
+ * relative url. By default Node's `fs.symlink` works by creating a symlink
+ * using `dstpath` and expects the `srcpath` to be relative to the newly
+ * created symlink. If you provide a `srcpath` that does not exist on the file
+ * system it results in a broken symlink. To minimize this, the function
+ * checks to see if the 'relative to symlink' source file exists, and if it
+ * does it will use it. If it does not, it checks if there's a file that
+ * exists that is relative to the current working directory, if does its used.
+ * This preserves the expectations of the original fs.symlink spec and adds
+ * the ability to pass in `relative to current working direcotry` paths.
+ */
+
+function symlinkPaths (srcpath, dstpath, callback) {
+  if (path.isAbsolute(srcpath)) {
+    return fs.lstat(srcpath, function (err, stat) {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureSymlink')
+        return callback(err)
+      }
+      return callback(null, {
+        'toCwd': srcpath,
+        'toDst': srcpath
+      })
+    })
+  } else {
+    var dstdir = path.dirname(dstpath)
+    var relativeToDst = path.join(dstdir, srcpath)
+    return fs.exists(relativeToDst, function (exists) {
+      if (exists) {
+        return callback(null, {
+          'toCwd': relativeToDst,
+          'toDst': srcpath
+        })
+      } else {
+        return fs.lstat(srcpath, function (err, stat) {
+          if (err) {
+            err.message = err.message.replace('lstat', 'ensureSymlink')
+            return callback(err)
+          }
+          return callback(null, {
+            'toCwd': srcpath,
+            'toDst': path.relative(dstdir, srcpath)
+          })
+        })
+      }
+    })
+  }
+}
+
+function symlinkPathsSync (srcpath, dstpath) {
+  var exists
+  if (path.isAbsolute(srcpath)) {
+    exists = fs.existsSync(srcpath)
+    if (!exists) throw new Error('absolute srcpath does not exist')
+    return {
+      'toCwd': srcpath,
+      'toDst': srcpath
+    }
+  } else {
+    var dstdir = path.dirname(dstpath)
+    var relativeToDst = path.join(dstdir, srcpath)
+    exists = fs.existsSync(relativeToDst)
+    if (exists) {
+      return {
+        'toCwd': relativeToDst,
+        'toDst': srcpath
+      }
+    } else {
+      exists = fs.existsSync(srcpath)
+      if (!exists) throw new Error('relative srcpath does not exist')
+      return {
+        'toCwd': srcpath,
+        'toDst': path.relative(dstdir, srcpath)
+      }
+    }
+  }
+}
+
+module.exports = {
+  'symlinkPaths': symlinkPaths,
+  'symlinkPathsSync': symlinkPathsSync
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/symlink-type.js

@@ -0,0 +1,27 @@
+var fs = require('graceful-fs')
+
+function symlinkType (srcpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback
+  type = (typeof type === 'function') ? false : type
+  if (type) return callback(null, type)
+  fs.lstat(srcpath, function (err, stats) {
+    if (err) return callback(null, 'file')
+    type = (stats && stats.isDirectory()) ? 'dir' : 'file'
+    callback(null, type)
+  })
+}
+
+function symlinkTypeSync (srcpath, type) {
+  if (type) return type
+  try {
+    var stats = fs.lstatSync(srcpath)
+  } catch (e) {
+    return 'file'
+  }
+  return (stats && stats.isDirectory()) ? 'dir' : 'file'
+}
+
+module.exports = {
+  symlinkType: symlinkType,
+  symlinkTypeSync: symlinkTypeSync
+}

package/example/node_modules/pdf-creator-node/example/node_modules/pdf-creator-node/example/node_modules/fs-extra/lib/ensure/symlink.js

@@ -0,0 +1,62 @@
+var path = require('path')
+var fs = require('graceful-fs')
+var _mkdirs = require('../mkdirs')
+var mkdirs = _mkdirs.mkdirs
+var mkdirsSync = _mkdirs.mkdirsSync
+
+var _symlinkPaths = require('./symlink-paths')
+var symlinkPaths = _symlinkPaths.symlinkPaths
+var symlinkPathsSync = _symlinkPaths.symlinkPathsSync
+
+var _symlinkType = require('./symlink-type')
+var symlinkType = _symlinkType.symlinkType
+var symlinkTypeSync = _symlinkType.symlinkTypeSync
+
+function createSymlink (srcpath, dstpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback
+  type = (typeof type === 'function') ? false : type
+
+  fs.exists(dstpath, function (destinationExists) {
+    if (destinationExists) return callback(null)
+    symlinkPaths(srcpath, dstpath, function (err, relative) {
+      if (err) return callback(err)
+      srcpath = relative.toDst
+      symlinkType(relative.toCwd, type, function (err, type) {
+        if (err) return callback(err)
+        var dir = path.dirname(dstpath)
+        fs.exists(dir, function (dirExists) {
+          if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
+          mkdirs(dir, function (err) {
+            if (err) return callback(err)
+            fs.symlink(srcpath, dstpath, type, callback)
+          })
+        })
+      })
+    })
+  })
+}
+
+function createSymlinkSync (srcpath, dstpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback
+  type = (typeof type === 'function') ? false : type
+
+  var destinationExists = fs.existsSync(dstpath)
+  if (destinationExists) return undefined
+
+  var relative = symlinkPathsSync(srcpath, dstpath)
+  srcpath = relative.toDst
+  type = symlinkTypeSync(relative.toCwd, type)
+  var dir = path.dirname(dstpath)
+  var exists = fs.existsSync(dir)
+  if (exists) return fs.symlinkSync(srcpath, dstpath, type)
+  mkdirsSync(dir)
+  return fs.symlinkSync(srcpath, dstpath, type)
+}
+
+module.exports = {
+  createSymlink: createSymlink,
+  createSymlinkSync: createSymlinkSync,
+  // alias
+  ensureSymlink: createSymlink,
+  ensureSymlinkSync: createSymlinkSync
+}