npm - w-ftp - Versions diffs - 1.0.0 - Mend

w-ftp 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

package/.editorconfig +9 -0
package/.eslintignore +3 -0
package/.eslintrc.js +54 -0
package/.jsdoc +25 -0
package/LICENSE +21 -0
package/README.md +163 -0
package/SECURITY.md +5 -0
package/babel.config.js +14 -0
package/docs/WFtp.mjs.html +665 -0
package/docs/fonts/Montserrat/Montserrat-Bold.eot +0 -0
package/docs/fonts/Montserrat/Montserrat-Bold.ttf +0 -0
package/docs/fonts/Montserrat/Montserrat-Bold.woff +0 -0
package/docs/fonts/Montserrat/Montserrat-Bold.woff2 +0 -0
package/docs/fonts/Montserrat/Montserrat-Regular.eot +0 -0
package/docs/fonts/Montserrat/Montserrat-Regular.ttf +0 -0
package/docs/fonts/Montserrat/Montserrat-Regular.woff +0 -0
package/docs/fonts/Montserrat/Montserrat-Regular.woff2 +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-light-webfont.eot +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-light-webfont.svg +978 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-light-webfont.ttf +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-light-webfont.woff +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-light-webfont.woff2 +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-regular-webfont.eot +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-regular-webfont.svg +1049 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-regular-webfont.ttf +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-regular-webfont.woff +0 -0
package/docs/fonts/Source-Sans-Pro/sourcesanspro-regular-webfont.woff2 +0 -0
package/docs/global.html +439 -0
package/docs/index.html +81 -0
package/docs/jsftp.js.html +925 -0
package/docs/scripts/collapse.js +20 -0
package/docs/scripts/linenumber.js +25 -0
package/docs/scripts/nav.js +12 -0
package/docs/scripts/polyfill.js +4 -0
package/docs/scripts/prettify/Apache-License-2.0.txt +202 -0
package/docs/scripts/prettify/lang-css.js +2 -0
package/docs/scripts/prettify/prettify.js +28 -0
package/docs/scripts/search.js +83 -0
package/docs/styles/jsdoc.css +765 -0
package/docs/styles/prettify.css +79 -0
package/g-download.mjs +84 -0
package/g-upload.mjs +65 -0
package/package.json +30 -0
package/src/WFtp.mjs +596 -0
package/src/jsftp.js +856 -0
package/test/all.test.mjs +10 -0
package/toolg/addVersion.mjs +4 -0
package/toolg/cleanFolder.mjs +4 -0
package/toolg/gDistRollup.mjs +27 -0
package/toolg/modifyReadme.mjs +4 -0

package/docs/jsftp.js.html ADDED Viewed

@@ -0,0 +1,925 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>jsftp.js - Documentation</title>
+    <script src="scripts/prettify/prettify.js"></script>
+    <script src="scripts/prettify/lang-css.js"></script>
+    <!--[if lt IE 9]>
+      <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
+    <![endif]-->
+    <link type="text/css" rel="stylesheet" href="styles/prettify.css">
+    <link type="text/css" rel="stylesheet" href="styles/jsdoc.css">
+    <script src="scripts/nav.js" defer></script>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body>
+<input type="checkbox" id="nav-trigger" class="nav-trigger" />
+<label for="nav-trigger" class="navicon-button x">
+  <div class="navicon"></div>
+</label>
+<label for="nav-trigger" class="overlay"></label>
+<nav >
+    <h2><a href="index.html">Home</a></h2><h3>Global</h3><ul><li><a href="global.html#WFtp">WFtp</a></li></ul>
+</nav>
+<div id="main">
+    <h1 class="page-title">jsftp.js</h1>
+    <section>
+        <article>
+            <pre class="prettyprint source linenums"><code>//fork from: https://github.com/sergi/jsftp
+'use strict'
+const createConnection = require('net').createConnection
+const EventEmitter = require('events').EventEmitter
+const inherits = require('util').inherits
+const stream = require('stream')
+const fs = require('fs')
+const combine = require('stream-combiner')
+const ResponseParser = require('ftp-response-parser')
+const ListingParser = require('parse-listing')
+const once = require('once')
+const nfc = require('unorm').nfc
+const debug = require('debug')('jsftp:general')
+const dbgCommand = require('debug')('jsftp:command')
+const dbgResponse = require('debug')('jsftp:response')
+const FTP_HOST = 'localhost'
+const FTP_PORT = 21
+const TIMEOUT = 10 * 60 * 1000
+const IDLE_TIME = 30000
+const NOOP = function() {}
+const expectedMarks = {
+    marks: [125, 150],
+    ignore: 226
+}
+const RE_PASV = /([-\d]+,[-\d]+,[-\d]+,[-\d]+),([-\d]+),([-\d]+)/
+const FTP_NEWLINE = /\r\n|\n/
+function runCmd(name, ...params) {
+    let callback = NOOP
+    let completeCmd = name + ' '
+    if (typeof params[params.length - 1] === 'function') {
+        callback = params.pop()
+    }
+    completeCmd += params.join(' ')
+    this.execute(completeCmd.trim(), callback)
+}
+function Ftp(cfg) {
+    this.host = cfg.host || FTP_HOST
+    this.port = cfg.port || FTP_PORT
+    this.user = cfg.user || 'anonymous'
+    this.pass = cfg.pass || '@anonymous'
+    this.createSocket = cfg.createSocket
+    // True if the server doesn't support the `stat` command. Since listing a
+    // directory or retrieving file properties is quite a common operation, it is
+    // more efficient to avoid the round-trip to the server.
+    this.useList = cfg.useList || false
+    this.commandQueue = []
+    EventEmitter.call(this)
+    this.on('data', dbgResponse)
+    this.on('error', dbgResponse)
+    this._createSocket(this.port, this.host)
+}
+inherits(Ftp, EventEmitter)
+// Generate generic methods from parameter names. they can easily be
+// overriden if we need special behavior. they accept any parameters given,
+// it is the responsibility of the user to validate the parameters.
+Ftp.prototype.raw = function() {
+    runCmd.apply(this, arguments)
+}
+Ftp.prototype.reemit = function(event) {
+    return data => {
+        this.emit(event, data)
+        debug(`event:${event}`, data || {})
+    }
+}
+Ftp.prototype._createSocket = function(port, host, firstAction = NOOP) {
+    if (this.socket &amp;&amp; this.socket.destroy) {
+        this.socket.destroy()
+    }
+    if (this.resParser) {
+        this.resParser.end()
+    }
+    this.resParser = new ResponseParser()
+    this.authenticated = false
+    this.socket = this.createSocket
+        ? this.createSocket({ port, host }, firstAction)
+        : createConnection(port, host, firstAction)
+    this.socket.on('connect', this.reemit('connect'))
+    this.socket.on('timeout', this.reemit('timeout'))
+    this.pipeline = combine(this.socket, this.resParser)
+    this.pipeline.on('data', data => {
+        this.emit('data', data)
+        dbgResponse(data.text)
+        this.parseResponse(data)
+    })
+    this.pipeline.on('error', this.reemit('error'))
+}
+Ftp.prototype.parseResponse = function(response) {
+    if (this.commandQueue.length === 0) {
+        return
+    }
+    if ([220].indexOf(response.code) > -1) {
+        return
+    }
+    const next = this.commandQueue[0].callback
+    if (response.isMark) {
+    // If we receive a Mark and it is not expected, we ignore that command
+        if (
+            !next.expectsMark ||
+      next.expectsMark.marks.indexOf(response.code) === -1
+        ) {
+            return
+        }
+        // We might have to ignore the command that comes after the mark.
+        if (next.expectsMark.ignore) {
+            this.ignoreCmdCode = next.expectsMark.ignore
+        }
+    }
+    if (this.ignoreCmdCode === response.code) {
+        this.ignoreCmdCode = null
+        return
+    }
+    this.parse(response, this.commandQueue.shift())
+}
+/**
+ * Sends a new command to the server.
+ *
+ * @param {String} command Command to write in the FTP socket
+ */
+Ftp.prototype.send = function(command) {
+    if (!command) {
+        return
+    }
+    dbgCommand(command)
+    this.pipeline.write(command + '\r\n')
+    dbgCommand(command)
+}
+Ftp.prototype.nextCmd = function() {
+    const cmd = this.commandQueue[0]
+    if (!this.inProgress &amp;&amp; cmd) {
+        this.send(cmd.action)
+        this.inProgress = true
+    }
+}
+/**
+ * Check whether the ftp user is authenticated at the moment of the
+ * enqueing. ideally this should happen in the `push` method, just
+ * before writing to the socket, but that would be complicated,
+ * since we would have to 'unshift' the auth chain into the queue
+ * or play the raw auth commands (that is, without enqueuing in
+ * order to not mess up the queue order. ideally, that would be
+ * built into the queue object. all this explanation to justify a
+ * slight slopiness in the code flow.
+ *
+ * @param {string} action
+ * @param {function} callback
+ */
+Ftp.prototype.execute = function(action, callback = NOOP) {
+    if (this.socket &amp;&amp; this.socket.writable) {
+        return this.runCommand({ action, callback })
+    }
+    this.authenticated = false
+    this._createSocket(this.port, this.host, () => {
+        this.runCommand({ action, callback })
+    })
+}
+Ftp.prototype.runCommand = function(cmd) {
+    if (this.authenticated || /^(feat|syst|user|pass)/.test(cmd.action)) {
+        this.commandQueue.push(cmd)
+        this.nextCmd()
+        return
+    }
+    this.getFeatures(() => {
+        this.auth(this.user, this.pass, () => {
+            this.commandQueue.push(cmd)
+            this.nextCmd()
+        })
+    })
+}
+/**
+ * Parse is called each time that a comand and a request are paired
+ * together. That is, each time that there is a round trip of actions
+ * between the client and the server.
+ *
+ * @param {Object} response Response from the server (contains text and code)
+ * @param {Array} command Contains the command executed and a callback (if any)
+ */
+Ftp.prototype.parse = function(response, command) {
+    let err = null
+    if (response.isError) {
+        err = new Error(response.text || 'Unknown FTP error.')
+        err.code = response.code
+    }
+    this.inProgress = false
+    command.callback(err, response)
+    this.nextCmd()
+}
+Ftp.prototype.getPasvPort = function(text) {
+    const match = RE_PASV.exec(text)
+    if (!match) {
+        return null
+    }
+    let host = match[1].replace(/,/g, '.')
+    if (host === '127.0.0.1') {
+        host = this.host
+    }
+    return {
+        host,
+        port: (parseInt(match[2], 10) &amp; 255) * 256 + (parseInt(match[3], 10) &amp; 255)
+    }
+}
+/**
+ * Returns true if the current server has the requested feature.
+ *
+ * @param {String} feature Feature to look for
+ * @return {Boolean} Whether the current server has the feature
+ */
+Ftp.prototype.hasFeat = function(feature) {
+    return !!feature &amp;&amp; this.features.indexOf(feature.toLowerCase()) > -1
+}
+/**
+ * Returns an array of features supported by the current FTP server
+ *
+ * @param {String} features Server response for the 'FEAT' command
+ * @return {String[]} Array of feature names
+ */
+Ftp.prototype._parseFeats = function(features) {
+    // Split and ignore header and footer
+    const featureLines = features.split(FTP_NEWLINE).slice(1, -1)
+    return featureLines
+        .map(feat => feat.trim().toLowerCase())
+        .filter(feat => !!feat)
+}
+// Below this point all the methods are action helpers for FTP that compose
+// several actions in one command
+Ftp.prototype.getFeatures = function(callback) {
+    if (this.features) {
+        return callback(null, this.features)
+    }
+    this.raw('feat', (err, response) => {
+        this.features = err ? [] : this._parseFeats(response.text)
+        this.raw('syst', (err, res) => {
+            if (!err &amp;&amp; res.code === 215) {
+                this.system = res.text.toLowerCase()
+            }
+            callback(null, this.features)
+        })
+    })
+}
+/**
+ * Authenticates the user.
+ *
+ * @param {String} user Username
+ * @param {String} pass Password
+ * @param {Function} callback Follow-up function.
+ */
+Ftp.prototype.auth = function(user, pass, callback) {
+    if (this.authenticating === true) {
+        return callback(new Error('This client is already authenticating'))
+    }
+    if (typeof user !== 'string') {
+        user = this.user
+    }
+    if (typeof pass !== 'string') {
+        pass = this.pass
+    }
+    this.authenticating = true
+    this.raw('user', user, (err, res) => {
+        if (err || [230, 331, 332].indexOf(res.code) === -1) {
+            this.authenticating = false
+            callback(err)
+            return
+        }
+        this.raw('pass', pass, (err, res) => {
+            this.authenticating = false
+            if (err) {
+                callback(err)
+            }
+            else if ([230, 202].indexOf(res.code) > -1) {
+                this.authenticated = true
+                this.user = user
+                this.pass = pass
+                this.raw('type', 'I', () => {
+                    callback(undefined, res)
+                })
+            }
+            else if (res.code === 332) {
+                this.raw('acct', '') // ACCT not really supported
+            }
+        })
+    })
+}
+Ftp.prototype.setType = function(type, callback) {
+    type = type.toUpperCase()
+    if (this.type === type) {
+        return callback()
+    }
+    this.raw('type', type, (err, data) => {
+        if (!err) {
+            this.type = type
+        }
+        callback(err, data)
+    })
+}
+/**
+ * Lists a folder's contents using a passive connection.
+ *
+ * @param {String} path Remote path for the file/folder to retrieve
+ * @param {Function} callback Function to call with errors or results
+ */
+Ftp.prototype.list = function(path, callback) {
+    if (arguments.length === 1) {
+        callback = arguments[0]
+        path = ''
+    }
+    let listing = ''
+    callback = once(callback)
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            return callback(err)
+        }
+        socket.setEncoding('utf8')
+        socket.on('data', data => {
+            listing += data
+        })
+        this.pasvTimeout(socket, callback)
+        socket.once('close', err => {
+            if (err) {
+                return callback(err)
+            }
+            else if (!listing) {
+                // Some servers return empty string
+                return callback({
+                    code: 451,
+                    text: `Could not retrieve a file listing for ${path}.`,
+                    isMark: false,
+                    isError: true
+                })
+            }
+            callback(null, listing)
+        })
+        socket.once('error', callback)
+        function cmdCallback(err, res) {
+            if (err) {
+                return callback(err)
+            }
+            const isExpectedMark = expectedMarks.marks.some(
+                mark => mark === res.code
+            )
+            if (!isExpectedMark) {
+                callback(
+                    new Error(
+                        `Expected marks ${expectedMarks.toString()} instead of: ${res.text}`
+                    )
+                )
+            }
+        }
+        cmdCallback.expectsMark = expectedMarks
+        this.execute(`list ${path || ''}`, cmdCallback)
+    })
+}
+Ftp.prototype.emitProgress = function(data) {
+    this.emit('progress', {
+        filename: data.filename,
+        action: data.action,
+        total: data.totalSize || 0,
+        transferred:
+      data.socket[data.action === 'get' ? 'bytesRead' : 'bytesWritten']
+    })
+}
+/**
+ * Depending on the number of parameters, returns the content of the specified
+ * file or directly saves a file into the specified destination. In the latter
+ * case, an optional callback can be provided, which will receive the error in
+ * case the operation was not successful.
+ *
+ * @param {String} remotePath File to be retrieved from the FTP server
+ * @param {Function|String} localPath Local path where we create the new file
+ * @param {Function} [callback] Gets called on either success or failure
+ */
+Ftp.prototype.get = function(remotePath, localPath, callback = NOOP) {
+    let finalCallback
+    const typeofLocalPath = typeof localPath
+    if (typeofLocalPath === 'function') {
+        finalCallback = localPath
+    }
+    else if (typeofLocalPath === 'string') {
+        callback = once(callback)
+        finalCallback = (err, socket) => {
+            if (err) {
+                return callback(err)
+            }
+            const writeStream = fs.createWriteStream(localPath)
+            writeStream.on('error', callback)
+            socket.on('readable', () => {
+                this.emitProgress({
+                    filename: remotePath,
+                    action: 'get',
+                    socket: socket
+                })
+            })
+            // This ensures that any expected outcome is handled. There is no
+            // danger of the callback being executed several times, because it is
+            // wrapped in `once`.
+            socket.on('error', callback)
+            socket.on('end', callback)
+            socket.on('close', callback)
+            socket.pipe(writeStream)
+        }
+    }
+    this.getGetSocket(remotePath, once(finalCallback))
+}
+/**
+ * Returns a socket for a get (RETR) on a path. The socket is ready to be
+ * streamed, but it is returned in a paused state. It is left to the user to
+ * resume it.
+ *
+ * @param {String} path Path to the file to be retrieved
+ * @param {Function} callback Function to call when finalized, with the socket
+ * as a parameter
+ */
+Ftp.prototype.getGetSocket = function(path, callback) {
+    callback = once(callback)
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            return cmdCallback(err)
+        }
+        socket.on('error', err => {
+            if (err.code === 'ECONNREFUSED') {
+                err.msg = 'Probably trying a PASV operation while one is in progress'
+            }
+            cmdCallback(err)
+        })
+        this.pasvTimeout(socket, cmdCallback)
+        socket.pause()
+        function cmdCallback(err, res) {
+            if (err) {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return callback(err)
+            }
+            if (!socket) {
+                return callback(new Error('Error when retrieving PASV socket'))
+            }
+            if (res.code === 125 || res.code === 150) {
+                return callback(null, socket)
+            }
+            // close the socket since it won't be used
+            socket.destroy()
+            return callback(new Error('Unexpected command ' + res.text))
+        }
+        cmdCallback.expectsMark = expectedMarks
+        this.execute('retr ' + path, cmdCallback)
+    })
+}
+/**
+ * Uploads contents on a FTP server. The `from` parameter can be a Buffer or the
+ * path for a local file to be uploaded.
+ *
+ * @param {String|Buffer} from Contents to be uploaded.
+ * @param {String} destination path for the remote destination.
+ * @param {Function} callback Function to execute on error or success.
+ */
+Ftp.prototype.put = function(from, destination, callback) {
+    const putReadable = (from, to, totalSize) => {
+        from.on('readable', () => {
+            this.emitProgress({
+                filename: to,
+                action: 'put',
+                socket: from,
+                totalSize
+            })
+        })
+        this.getPutSocket(from, to, callback)
+    }
+    if (from instanceof Buffer) {
+        // this.getPutSocket(from, destination, callback)
+        // let self = this
+        this.getPutSocket(from, destination, (err, socket) => {
+            if (err) {
+                return callback(new Error(err))
+            }
+            let pointer = 0
+            let SLICE = 1024 * 1024
+            let done = false
+            let newBuf
+            newBuf = from.slice(pointer, pointer + SLICE)
+            pointer += SLICE
+            callback(null, newBuf)
+            socket.write(from.slice(0, SLICE))
+            //check
+            if (newBuf.length === from.length) {
+                socket.end()
+                callback(null, [])
+            }
+            // socket.on('error', (msg) => {
+            //     console.log('socket err', msg)
+            // })
+            // socket.on('end', (msg) => {
+            //     console.log('socket end', msg)
+            // })
+            // socket.on('close', (msg) => {
+            //     console.log('socket close', msg)
+            // })
+            socket.on('drain', () => {
+                console.log('drain')
+                if (from.length > pointer + SLICE) {
+                    newBuf = from.slice(pointer, pointer + SLICE)
+                    pointer += SLICE
+                }
+                else {
+                    newBuf = from.slice(pointer)
+                    done = true
+                    // console.log('done', done)
+                }
+                callback(null, newBuf)
+                socket.write(newBuf)
+                // self.emit('progress', {
+                //     filename: 'BUFFER',
+                //     action: 'put',
+                //     transferred: pointer,
+                //     total: from.length
+                // })
+                //check
+                if (done) {
+                    socket.end()
+                    callback(null, [])
+                }
+            })
+        })
+    }
+    else if (typeof from === 'string') {
+        fs.stat(from, (err, stats) => {
+            if (err &amp;&amp; err.code === 'ENOENT') {
+                return callback(new Error('Local file doesn\'t exist.'))
+            }
+            if (stats.isDirectory()) {
+                return callback(new Error('Local path cannot be a directory'))
+            }
+            const totalSize = err ? 0 : stats.size
+            putReadable(fs.createReadStream(from), destination, totalSize)
+        })
+    }
+    else if (from instanceof stream.Readable) {
+        putReadable(from, destination, 0)
+    }
+    else {
+        callback(
+            new Error('Expected `from` parameter to be a Buffer, Stream, or a String')
+        )
+    }
+}
+Ftp.prototype.getPutSocket = function(from, path, next) {
+    next = once(next || NOOP)
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            if (socket) {
+                // close the socket since it won't be used
+                socket.destroy()
+            }
+            return next(err)
+        }
+        socket.on('close', next)
+        socket.on('error', next)
+        // socket.on('error', (msg) => {
+        //     console.log('s error', msg)
+        // })
+        // socket.on('end', (msg) => {
+        //     console.log('s end', msg)
+        // })
+        // socket.on('close', (msg) => {
+        //     console.log('s close', msg)
+        // })
+        // socket.on('data', (msg) => {
+        //     console.log('s data', msg)
+        // })
+        const callback = once((err, res) => {
+            if (err) {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return next(err)
+            }
+            // Mark 150 indicates that the 'STOR' socket is ready to receive data.
+            // Anything else is not relevant.
+            if (res.code === 125 || res.code === 150) {
+                this.pasvTimeout(socket, next)
+                if (from instanceof Buffer) {
+                    next(null, socket)
+                    // socket.end(from)
+                }
+                else if (from instanceof stream.Readable) {
+                    next(null, socket)
+                    from.pipe(socket)
+                    // //resume
+                    // socket.resume()
+                }
+            }
+            else {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return next(new Error('Unexpected command ' + res.text))
+            }
+        })
+        callback.expectsMark = expectedMarks
+        this.execute(`stor ${path}`, callback)
+    })
+}
+Ftp.prototype.pasvTimeout = function(socket, callback) {
+    socket.once('timeout', () => {
+        debug('PASV socket timeout')
+        this.emit('timeout')
+        socket.end()
+        callback(new Error('Passive socket timeout'))
+    })
+}
+Ftp.prototype.getPasvSocket = function(callback = NOOP) {
+    callback = once(callback)
+    this.execute('pasv', (err, res) => {
+        if (err) {
+            return callback(err)
+        }
+        const options = this.getPasvPort(res.text)
+        if (!options) {
+            return callback(new Error('Bad passive host/port combination'))
+        }
+        const socket = (this._pasvSocket = this.createSocket
+            ? this.createSocket(options)
+            : createConnection(options))
+        socket.setTimeout(this.timeout || TIMEOUT)
+        socket.once('close', () => {
+            this._pasvSocket = undefined
+        })
+        callback(null, socket)
+    })
+}
+/**
+ * Provides information about files. It lists a directory contents or
+ * a single file and yields an array of file objects. The file objects
+ * contain several properties. The main difference between this method and
+ * 'list' or 'stat' is that it returns objects with the file properties
+ * already parsed.
+ *
+ * Example of file object:
+ *
+ *  {
+ *      name: 'README.txt',
+ *      type: 0,
+ *      time: 996052680000,
+ *      size: '2582',
+ *      owner: 'sergi',
+ *      group: 'staff',
+ *      userPermissions: { read: true, write: true, exec: false },
+ *      groupPermissions: { read: true, write: false, exec: false },
+ *      otherPermissions: { read: true, write: false, exec: false }
+ *  }
+ *
+ * The constants used in the object are defined in ftpParser.js
+ *
+ * @param {String} filePath Path to the file or directory to list
+ * @param {Function} callback Function to call with the proper data when
+ * the listing is finished.
+ */
+Ftp.prototype.ls = function(filePath, callback) {
+    function entriesToList(err, entries) {
+        if (err) {
+            return callback(err)
+        }
+        ListingParser.parseFtpEntries(entries.text || entries, (err, files) => {
+            if (err) {
+                return callback(err)
+            }
+            files.forEach(file => {
+                // Normalize UTF8 doing canonical decomposition, followed by
+                // canonical Composition
+                file.name = nfc(file.name)
+            })
+            callback(null, files)
+        })
+    }
+    if (this.useList) {
+        this.list(filePath, entriesToList)
+    }
+    else {
+        this.raw('stat', filePath, (err, data) => {
+            // We might be connected to a server that doesn't support the
+            // 'STAT' command, which is set as default. We use 'LIST' instead,
+            // and we set the variable `useList` to true, to avoid extra round
+            // trips to the server to check.
+            const errored = err &amp;&amp; (err.code === 502 || err.code === 500)
+            const isHummingbird =
+        this.system &amp;&amp; this.system.indexOf('hummingbird') > -1
+            if (errored || isHummingbird) {
+                // Not sure if the 'hummingbird' system check ^^^ is still
+                // necessary. If they support any standards, the 500 error
+                // should have us covered. Let's leave it for now.
+                this.useList = true
+                this.list(filePath, entriesToList)
+            }
+            else {
+                entriesToList(err, data)
+            }
+        })
+    }
+}
+Ftp.prototype.rename = function(from, to, callback) {
+    this.raw('rnfr', from, err => {
+        if (err) {
+            return callback(err)
+        }
+        this.raw('rnto', to, callback)
+    })
+}
+Ftp.prototype.keepAlive = function(wait) {
+    if (this._keepAliveInterval) {
+        clearInterval(this._keepAliveInterval)
+    }
+    this._keepAliveInterval = setInterval(
+        this.raw.bind(this, 'noop'),
+        wait || IDLE_TIME
+    )
+}
+Ftp.prototype.destroy = function() {
+    if (this._keepAliveInterval) {
+        clearInterval(this._keepAliveInterval)
+    }
+    if (this.socket &amp;&amp; this.socket.writable) {
+        this.socket.end()
+    }
+    if (this._pasvSocket &amp;&amp; this._pasvSocket.writable) {
+        this._pasvSocket.end()
+    }
+    this.resParser.end()
+    this.socket = undefined
+    this._pasvSocket = undefined
+    this.features = null
+    this.authenticated = false
+}
+module.exports = Ftp
+</code></pre>
+        </article>
+    </section>
+</div>
+<br class="clear">
+<footer>
+    Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.6.10</a> on Sat Jul 23 2022 13:03:06 GMT+0800 (台北標準時間) using the <a href="https://github.com/clenemt/docdash">docdash</a> theme.
+</footer>
+<script>prettyPrint();</script>
+<script src="scripts/polyfill.js"></script>
+<script src="scripts/linenumber.js"></script>
+</body>
+</html>