pubo-node 1.0.156 → 1.0.157

package/es/ftp-client/index.js

@@ -1,260 +1,135 @@
-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];
+import { random, waitFor } from 'pubo-utils';
+export class FtpClient {
+    driver;
+    options;
+    state = { running: false, connected: false, destroyed: false, connecting: false };
+    client;
+    _len = 0;
+    id = 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); }
-import { random, waitFor } from 'pubo-utils';
-export 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 = 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(waitFor(function () {
-            return _this.state.connected;
-          }, {
-            checkTime: 1000,
-            timeout: 10000
-          }), function () {
-            _exit = true;
+    set len(n) {
+        this._len = n;
+        if (this._len < 1) {
+            this.close();
+        }
+    }
+    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();
+        }
+        this.state.destroyed = false;
+        if (this.state.connecting) {
+            await waitFor(() => this.state.connected, { checkTime: 1000, timeout: 10000 });
             return 'connected';
-          });
         }
-      }, 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));
+        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);
+                this.close();
+            });
+            this.client.connect({ ...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());
+    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();
         }
-      }, function () {
-        return _invoke(function () {
-          if (_this2.state.running) {
-            return _awaitIgnored(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) {
-                reject(err);
-              } else {
-                resolve(res);
-              }
-            }]));
-          });
+        if (this.state.running) {
+            await 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);
     }
-  };
-  _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;
-          });
+    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;
+            });
         });
-      });
-    } 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();
-      }
+}
+export 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;
     }
-  }]);
-  return FtpClient;
-}();
-export 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);
+    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;
-}();
+}

package/es/grpc/index.js

@@ -1,169 +1,103 @@
-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 _catch(body, recover) {
-  try {
-    var result = body();
-  } catch (e) {
-    return recover(e);
-  }
-  if (result && result.then) {
-    return result.then(void 0, recover);
-  }
-  return result;
-}
-function _continue(value, then) {
-  return value && value.then ? value.then(then) : then(value);
-}
-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); }
-var passThrough = function passThrough(argument) {
-  return argument;
-};
-var GrpcClient = /*#__PURE__*/function () {
-  function GrpcClient(_ref) {
-    var _this$options$timeout;
-    var url = _ref.url,
-      _ref$options = _ref.options,
-      options = _ref$options === void 0 ? {} : _ref$options,
-      Grpc = _ref.Grpc,
-      cert = _ref.cert;
-    this.url = void 0;
-    this.options = void 0;
-    this.Grpc = void 0;
-    this.credentials = void 0;
-    this.client = void 0;
-    this._timeout = void 0;
-    this.connections = 0;
-    var opt = _extends({
-      'grpc.max_send_message_length': -1,
-      'grpc.max_receive_message_length': -1
-    }, options);
-    var credentials = cert ? Grpc.credentials.createSsl(cert) : Grpc.credentials.createInsecure();
-    this.url = url;
-    this.Grpc = Grpc;
-    this.credentials = credentials;
-    this.options = opt;
-    this.options.timeout = (_this$options$timeout = this.options.timeout) != null ? _this$options$timeout : 10000;
-    Grpc = null;
-    options = null;
-    cert = null;
-  }
-  var _proto = GrpcClient.prototype;
-  _proto.request = function request(service, method, data) {
-    try {
-      var _this = this;
-      if (_this._timeout) {
-        clearTimeout(_this._timeout);
-        _this._timeout = null;
-      }
-      _this.connections += 1;
-      if (!_this.client) {
-        _this.client = new _this.Grpc.Client(_this.url, _this.credentials, _this.options);
-      }
-      var error;
-      var result = Buffer.alloc(0);
-      return _await(_continue(_catch(function () {
-        return _await(_this._request({
-          service: service,
-          method: method,
-          data: data
-        }), function (_this$_request) {
-          result = _this$_request;
-        });
-      }, function (err) {
-        error = err;
-      }), function () {
+const passThrough = (argument) => argument;
+class GrpcClient {
+    url;
+    options;
+    Grpc;
+    credentials;
+    client;
+    _timeout;
+    connections = 0;
+    constructor({ url, options = {}, Grpc, cert }) {
+        const opt = { 'grpc.max_send_message_length': -1, 'grpc.max_receive_message_length': -1, ...options };
+        const credentials = cert ? Grpc.credentials.createSsl(cert) : Grpc.credentials.createInsecure();
+        this.url = url;
+        this.Grpc = Grpc;
+        this.credentials = credentials;
+        this.options = opt;
+        this.options.timeout = this.options.timeout ?? 10000;
+        Grpc = null;
+        options = null;
+        cert = null;
+    }
+    async request(service, method, data) {
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+            this._timeout = null;
+        }
+        this.connections += 1;
+        if (!this.client) {
+            this.client = new this.Grpc.Client(this.url, this.credentials, this.options);
+        }
+        let error;
+        let result = Buffer.alloc(0);
+        try {
+            result = await this._request({ service, method, data });
+        }
+        catch (err) {
+            error = err;
+        }
         service = null;
         method = null;
         data = null;
-        _this.connections -= 1;
-        if (_this.connections < 0) {
-          _this.connections = 0;
+        this.connections -= 1;
+        if (this.connections < 0) {
+            this.connections = 0;
         }
-        if (_this.connections < 1) {
-          if (_this._timeout) {
-            clearTimeout(_this._timeout);
-            _this._timeout = null;
-          }
-          _this._timeout = setTimeout(function () {
-            return _this.close();
-          }, 60000);
+        if (this.connections < 1) {
+            if (this._timeout) {
+                clearTimeout(this._timeout);
+                this._timeout = null;
+            }
+            this._timeout = setTimeout(() => this.close(), 60000);
         }
         if (error) {
-          console.log(error);
-          _this.close();
-          throw new Error('grpc connection error.');
+            console.log(error);
+            this.close();
+            throw new Error('grpc connection error.');
         }
         return result;
-      }));
-    } catch (e) {
-      return Promise.reject(e);
     }
-  };
-  _proto._request = function _request(_ref2) {
-    var _this2 = this;
-    var service = _ref2.service,
-      method = _ref2.method,
-      data = _ref2.data;
-    return new Promise(function (resolve, reject) {
-      var _ended = false;
-      var _timeout = setTimeout(function () {
-        _ended = true;
-        _this2.close();
-        console.log('rpc request timeout');
-        reject(new Error('timeout'));
-      }, _this2.options.timeout);
-      var onResponse = function onResponse(err, res) {
-        if (_ended) {
-          return;
-        } else {
-          clearTimeout(_timeout);
-        }
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res);
+    _request({ service, method, data }) {
+        return new Promise((resolve, reject) => {
+            let _ended = false;
+            const _timeout = setTimeout(() => {
+                _ended = true;
+                this.close();
+                console.log('rpc request timeout');
+                reject(new Error('timeout'));
+            }, this.options.timeout);
+            const onResponse = (err, res) => {
+                if (_ended) {
+                    return;
+                }
+                else {
+                    clearTimeout(_timeout);
+                }
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(res);
+                }
+            };
+            this.client.makeUnaryRequest(`/${service}/${method}`, passThrough, passThrough, data ? Buffer.from(data) : Buffer.alloc(0), onResponse);
+        });
+    }
+    close() {
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+            delete this._timeout;
         }
-      };
-      _this2.client.makeUnaryRequest("/" + service + "/" + method, passThrough, passThrough, data ? Buffer.from(data) : Buffer.alloc(0), onResponse);
-    });
-  };
-  _proto.close = function close() {
-    var _this$client;
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-      delete this._timeout;
+        this.client?.close();
+        this.client = null;
+        delete this.client;
     }
-    (_this$client = this.client) == null ? void 0 : _this$client.close();
-    this.client = null;
-    delete this.client;
-  };
-  return GrpcClient;
-}();
-export var GrpcList = [];
-export function createRpcClient(_ref3) {
-  var url = _ref3.url,
-    _ref3$options = _ref3.options,
-    options = _ref3$options === void 0 ? {} : _ref3$options,
-    ServiceImp = _ref3.ServiceImp,
-    Grpc = _ref3.Grpc,
-    cert = _ref3.cert;
-  var client = new GrpcClient({
-    url: url,
-    options: options,
-    Grpc: Grpc,
-    cert: cert
-  });
-  GrpcList.push(client);
-  Grpc = null;
-  options = null;
-  return new ServiceImp({
-    request: client.request.bind(client)
-  });
-}
+}
+export const GrpcList = [];
+export function createRpcClient({ url, options = {}, ServiceImp, Grpc, cert }) {
+    const client = new GrpcClient({ url, options, Grpc, cert });
+    GrpcList.push(client);
+    Grpc = null;
+    options = null;
+    return new ServiceImp({ request: client.request.bind(client) });
+}

package/es/index.d.ts

@@ -1,8 +1,8 @@
 export { JsonStorage } from './storage/json';
 export { FtpClient, FtpClientPool, FtpConnectOptions, FtpFile } from './ftp-client';
 export { createRpcClient, GrpcList } from './grpc';
-export { PuboFileSystem } from './file-system';
 export { SIGKILL, isProcessDied, getProcessName, getProcessTree, getProcessByPpid, getProcessCpuUseByPid, getProcessCommandByPid, heartbeat, } from './child-process';
 export { isPortAvailable } from './utils';
 export { getWifiName, getNetworks } from './utils/network';
 export { RosTopicManager, RosTopic } from './ros/topic';
+export { PuboFileSystem } from './file-system';