pubo-node 1.0.143 → 1.0.145

package/lib/ftp-client/index.js

@@ -1,268 +1,140 @@
 "use strict";
-
-var _excluded = ["driver"],
-  _excluded2 = ["maxConnection"];
-function _await(value, then, direct) {
-  if (direct) {
-    return then ? then(value) : value;
-  }
-  if (!value || !value.then) {
-    value = Promise.resolve(value);
-  }
-  return then ? value.then(then) : value;
-}
-function _invoke(body, then) {
-  var result = body();
-  if (result && result.then) {
-    return result.then(then);
-  }
-  return then(result);
-}
-function _empty() {}
-function _awaitIgnored(value, direct) {
-  if (!direct) {
-    return value && value.then ? value.then(_empty) : Promise.resolve();
-  }
-}
-function _async(f) {
-  return function () {
-    for (var args = [], i = 0; i < arguments.length; i++) {
-      args[i] = arguments[i];
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FtpClientPool = exports.FtpClient = void 0;
+const pubo_utils_1 = require("pubo-utils");
+class FtpClient {
+    driver;
+    options;
+    state = { running: false, connected: false, destroyed: false, connecting: false };
+    client;
+    _len = 0;
+    id = (0, pubo_utils_1.random)();
+    constructor({ driver, ...options }) {
+        this.driver = driver;
+        this.options = options;
     }
-    try {
-      return Promise.resolve(f.apply(this, args));
-    } catch (e) {
-      return Promise.reject(e);
+    get len() {
+        return this._len;
     }
-  };
-}
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FtpClientPool = exports.FtpClient = void 0;
-var pubo_utils_1 = require("pubo-utils");
-var FtpClient = /*#__PURE__*/function () {
-  function FtpClient(_ref) {
-    var driver = _ref.driver,
-      options = _objectWithoutPropertiesLoose(_ref, _excluded);
-    this.driver = void 0;
-    this.options = void 0;
-    this.state = {
-      running: false,
-      connected: false,
-      destroyed: false,
-      connecting: false
-    };
-    this.client = void 0;
-    this._len = 0;
-    this.id = (0, pubo_utils_1.random)();
-    this.put = this.bind('put');
-    this["delete"] = this.bind('delete');
-    this.list = this.bind('list');
-    this.rename = this.bind('rename');
-    this.driver = driver;
-    this.options = options;
-  }
-  var _proto = FtpClient.prototype;
-  _proto.connect = function connect() {
-    try {
-      var _exit = false;
-      var _this = this;
-      if (!_this.client) {
-        _this.client = new _this.driver();
-      }
-      _this.state.destroyed = false;
-      return _await(_invoke(function () {
-        if (_this.state.connecting) {
-          return _await((0, pubo_utils_1.waitFor)(function () {
-            return _this.state.connected;
-          }, {
-            checkTime: 1000,
-            timeout: 10000
-          }), function () {
-            _exit = true;
-            return 'connected';
-          });
+    set len(n) {
+        this._len = n;
+        if (this._len < 1) {
+            this.close();
         }
-      }, function (_result) {
-        if (_exit) return _result;
-        _this.state.connecting = true;
-        return new Promise(function (resolve, reject) {
-          _this.client.once('ready', function () {
-            _this.state.connected = true;
-            resolve('connected');
-            _this.state.connecting = false;
-          });
-          _this.client.once('error', function (err) {
-            reject(err);
-            _this.close();
-          });
-          _this.client.connect(_extends({}, _this.options));
-        });
-      }));
-    } catch (e) {
-      return Promise.reject(e);
     }
-  };
-  _proto.close = function close() {
-    this.client.end();
-    this.state.connected = false;
-    this.state.destroyed = true;
-    this.state.connecting = false;
-    this.client = null;
-  };
-  _proto.run = function run(_ref2) {
-    var fn = _ref2.fn,
-      args = _ref2.args;
-    try {
-      var _this2 = this;
-      _this2.len += 1;
-      return _await(_invoke(function () {
-        if (!_this2.state.connected) {
-          return _awaitIgnored(_this2.connect());
+    put = this.bind('put');
+    delete = this.bind('delete');
+    list = this.bind('list');
+    rename = this.bind('rename');
+    async connect() {
+        if (!this.client) {
+            this.client = new this.driver();
         }
-      }, function () {
-        return _invoke(function () {
-          if (_this2.state.running) {
-            return _awaitIgnored((0, pubo_utils_1.waitFor)(function () {
-              return !_this2.state.running;
-            }, {
-              checkTime: 1000,
-              timeout: 6000000
-            }));
-          }
-        }, function () {
-          _this2.state.running = true;
-          return new Promise(function (resolve, reject) {
-            var _this2$client;
-            (_this2$client = _this2.client)[fn].apply(_this2$client, args.concat([function (err, res) {
-              if (err) {
+        this.state.destroyed = false;
+        if (this.state.connecting) {
+            await (0, pubo_utils_1.waitFor)(() => this.state.connected, { checkTime: 1000, timeout: 10000 });
+            return 'connected';
+        }
+        this.state.connecting = true;
+        return new Promise((resolve, reject) => {
+            this.client.once('ready', () => {
+                this.state.connected = true;
+                resolve('connected');
+                this.state.connecting = false;
+            });
+            this.client.once('error', (err) => {
                 reject(err);
-              } else {
-                resolve(res);
-              }
-            }]));
-          });
+                this.close();
+            });
+            this.client.connect({ ...this.options });
         });
-      }));
-    } catch (e) {
-      return Promise.reject(e);
     }
-  };
-  _proto.bind = function bind(fn) {
-    var _this3 = this;
-    return _async(function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      return _await(_this3.run({
-        fn: fn,
-        args: args
-      }), function (res) {
-        _this3.state.running = false;
-        _this3.len -= 1;
-        return res;
-      });
-    });
-  };
-  _proto.get = function get() {
-    try {
-      var _this4 = this;
-      var res = Buffer.alloc(0);
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
-      return _await(_this4.run({
-        fn: 'get',
-        args: args
-      }), function (stream) {
-        return new Promise(function (resolve) {
-          stream.on('data', function (chunk) {
-            res = Buffer.concat([res, chunk], res.byteLength + chunk.byteLength);
-          });
-          stream.on('end', function () {
-            resolve(res);
-            _this4.state.running = false;
-            _this4.len -= 1;
-          });
+    close() {
+        this.client.end();
+        this.state.connected = false;
+        this.state.destroyed = true;
+        this.state.connecting = false;
+        this.client = null;
+    }
+    async run({ fn, args }) {
+        this.len += 1;
+        if (!this.state.connected) {
+            await this.connect();
+        }
+        if (this.state.running) {
+            await (0, pubo_utils_1.waitFor)(() => !this.state.running, { checkTime: 1000, timeout: 6000000 });
+        }
+        this.state.running = true;
+        return new Promise((resolve, reject) => {
+            this.client[fn](...args, (err, res) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(res);
+                }
+            });
         });
-      });
-    } catch (e) {
-      return Promise.reject(e);
     }
-  };
-  _createClass(FtpClient, [{
-    key: "len",
-    get: function get() {
-      return this._len;
-    },
-    set: function set(n) {
-      this._len = n;
-      if (this._len < 1) {
-        this.close();
-      }
+    bind(fn) {
+        return async (...args) => {
+            const res = await this.run({ fn, args });
+            this.state.running = false;
+            this.len -= 1;
+            return res;
+        };
+    }
+    async get(...args) {
+        let res = Buffer.alloc(0);
+        const stream = await this.run({ fn: 'get', args });
+        return new Promise((resolve) => {
+            stream.on('data', (chunk) => {
+                res = Buffer.concat([res, chunk], res.byteLength + chunk.byteLength);
+            });
+            stream.on('end', () => {
+                resolve(res);
+                this.state.running = false;
+                this.len -= 1;
+            });
+        });
     }
-  }]);
-  return FtpClient;
-}();
+}
 exports.FtpClient = FtpClient;
-var FtpClientPool = /*#__PURE__*/function () {
-  function FtpClientPool(_ref3) {
-    var _ref3$maxConnection = _ref3.maxConnection,
-      maxConnection = _ref3$maxConnection === void 0 ? 5 : _ref3$maxConnection,
-      options = _objectWithoutPropertiesLoose(_ref3, _excluded2);
-    this.options = void 0;
-    this.maxConnection = void 0;
-    this.pool = [];
-    this.get = this.bind('get');
-    this.put = this.bind('put');
-    this["delete"] = this.bind('delete');
-    this.list = this.bind('list');
-    this.rename = this.bind('rename');
-    this.options = options;
-    this.maxConnection = maxConnection;
-  }
-  var _proto2 = FtpClientPool.prototype;
-  _proto2.bind = function bind(fn) {
-    var _this5 = this;
-    return _async(function () {
-      var client = _this5.client;
-      return _await(client[fn].apply(client, arguments), function (res) {
-        if (client.len < 1) {
-          var index = _this5.pool.findIndex(function (item) {
-            return item.id === client.id;
-          });
-          _this5.pool.splice(index, 1);
+class FtpClientPool {
+    options;
+    maxConnection;
+    pool = [];
+    constructor({ maxConnection = 5, ...options }) {
+        this.options = options;
+        this.maxConnection = maxConnection;
+    }
+    get = this.bind('get');
+    put = this.bind('put');
+    delete = this.bind('delete');
+    list = this.bind('list');
+    rename = this.bind('rename');
+    get len() {
+        return this.pool.length;
+    }
+    get client() {
+        if (this.pool.length < this.maxConnection) {
+            const client = new FtpClient(this.options);
+            this.pool.push(client);
+            return client;
         }
-        return res;
-      });
-    });
-  };
-  _createClass(FtpClientPool, [{
-    key: "len",
-    get: function get() {
-      return this.pool.length;
+        this.pool.sort((a, b) => a.len - b.len);
+        return this.pool[0];
     }
-  }, {
-    key: "client",
-    get: function get() {
-      if (this.pool.length < this.maxConnection) {
-        var client = new FtpClient(this.options);
-        this.pool.push(client);
-        return client;
-      }
-      this.pool.sort(function (a, b) {
-        return a.len - b.len;
-      });
-      return this.pool[0];
+    bind(fn) {
+        return async (...args) => {
+            const client = this.client;
+            const res = await client[fn](...args);
+            if (client.len < 1) {
+                const index = this.pool.findIndex((item) => item.id === client.id);
+                this.pool.splice(index, 1);
+            }
+            return res;
+        };
     }
-  }]);
-  return FtpClientPool;
-}();
-exports.FtpClientPool = FtpClientPool;
+}
+exports.FtpClientPool = FtpClientPool;