@alexgyver/serial 1.0.4 → 1.0.6

package/README.md

@@ -5,7 +5,11 @@
 - Буферизация отправки
 - Буферизация приёма, разделение текста по разделителю
 
-> npm i @alexgyver/serial
+[demo](https://gyverlibs.github.io/Serial.js/test/)
+
+> **Browser**: https://gyverlibs.github.io/Serial.js/Serial.min.js
+
+> **Node**: npm i @alexgyver/serial
 
 ## Дока
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexgyver/serial",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Web Serial API wrapper",
   "main": "./serial.js",
   "module": "./serial.js",
@@ -14,13 +14,14 @@
     "url": "git+https://github.com/GyverLibs/Serial.js.git"
   },
   "devDependencies": {
-    "webpack": "^5.103.0",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.2",
-    "html-webpack-plugin": "^5.6.5"
+    "webpack": "^5.106.2",
+    "webpack-cli": "^7.0.2",
+    "webpack-dev-server": "^5.2.4",
+    "style-loader": "^4.0.0",
+    "css-loader": "^7.1.4"
   },
   "dependencies": {
-    "@alexgyver/utils": "^1.2.4"
+    "@alexgyver/utils": "^1.2.6"
   },
   "author": "AlexGyver <alex@alexgyver.ru>",
   "license": "MIT"

package/serial.js

@@ -1,4 +1,4 @@
-import { sleep, ShiftBuffer, StreamSplitter } from "@alexgyver/utils";
+import { sleep, StreamSplitter, SerialExecutor } from "@alexgyver/utils";
 
 export default class SerialJS {
     static State = {
@@ -8,17 +8,14 @@ export default class SerialJS {
         Closing: 'closing',
     };
 
-    //#region handlers
-    onbin = null;
     ontext = null;
-
+    onbin(b) { }
     onopen() { }
     onclose() { }
     onchange(s) { }
     onselect(name) { }
     onerror(e) { }
 
-    //#region constructor
     constructor(params = {}) {
         const def = {
             eol: /\r?\n/,
@@ -26,14 +23,21 @@ export default class SerialJS {
             auto_open: false,
             reconnect: 1000,
         };
+
         this.cfg = { ...def, ...params };
 
-        this._setLastPort().then(() => this.onselect(this.getName()));
         this.splitter = new StreamSplitter(this.cfg.eol);
-        this.splitter.ontext = (t) => this.ontext(t);
+        this.splitter.ontext = (t) => {
+            try {
+                if (this.ontext) this.ontext(t);
+            } catch (e) {
+                this._error(e);
+            }
+        };
+
+        this._setLastPort().then(() => this.onselect(this.getName()));
     }
 
-    //#region methods
     config(params = {}) {
         this.cfg = { ...this.cfg, ...params };
         this.splitter.eol = this.cfg.eol;
@@ -44,7 +48,7 @@ export default class SerialJS {
     }
 
     opened() {
-        return this._state == SerialJS.State.Open;
+        return this._state === SerialJS.State.Open;
     }
 
     selected() {
@@ -62,133 +66,211 @@ export default class SerialJS {
             case 0x0402: case 0x0403: case 0x0404: case 0x0405: case 0x6001: case 0x0602: case 0x6010: return 'FT232';
             case 0x9500: case 0x0102: case 0x0501: case 0x80a9: case 0xea60: case 0xea61: case 0xea63: return 'CP210x';
         }
+
         return 'Unknown';
     }
 
     async select() {
         try {
             await this.close();
+
             this._port = null;
-            let ports = await navigator.serial.getPorts();
-            for (let p of ports) await p.forget();
+
+            const ports = await navigator.serial.getPorts();
+            for (const p of ports) await p.forget();
+
             await sleep(50);
             await navigator.serial.requestPort();
             await this._setLastPort();
         } catch (e) {
             this._error(e);
         }
+
         this.onselect(this.getName());
+
         if (this.cfg.auto_open) this.open();
+
         return this.selected();
     }
 
     async open() {
-        if (this.cfg.reconnect) this.retry = true;
-        await this._open();
+        return this._lifecycle.runNothrow(async () => {
+            const ports = await navigator.serial.getPorts();
+            if (!ports.length) return false;
+
+            if (this.cfg.reconnect) this.retry = true;
+
+            await this._open();
+
+            return this.opened();
+        });
     }
+
     async _open() {
-        if (this.opened()) return;
+        if (this.opened() || this._state === SerialJS.State.Opening) return;
+
         this._change(SerialJS.State.Opening);
 
         try {
             await this._close();
             await this._setLastPort();
+
+            if (!this._port) {
+                this._change(SerialJS.State.Closed);
+                return;
+            }
+
             await this._port.open({ baudRate: this.cfg.baud });
+
             this.writer = this._port.writable.getWriter();
             this.reader = this._port.readable.getReader();
-            this._buffer.clear();
+
+            this._sender.reset();
             this._change(SerialJS.State.Open);
 
-            while (this._state == SerialJS.State.Open) {
+            while (this._state === SerialJS.State.Open) {
                 const { value, done } = await this.reader.read();
+
                 if (done) break;
+
                 if (value) {
-                    if (this.onbin) this.onbin(value);
-                    if (this.ontext) this.splitter.write(this._decoder.decode(value, { stream: true }));
+                    try {
+                        this.onbin(value);
+                    } catch (e) {
+                        this._error(e);
+                    }
+
+                    if (this.ontext) {
+                        this.splitter.write(
+                            this._decoder.decode(value, { stream: true })
+                        );
+                    }
                 }
             }
         } catch (e) {
             this._error(e);
-            this._change(SerialJS.State.Closed);
-            if (this.retry) setTimeout(() => this._open(), this.cfg.reconnect);
         }
 
-        if (this.reader) this.reader.releaseLock();
-        if (this.writer) this.writer.releaseLock();
+        this._sender.reset();
+
+        if (this._state !== SerialJS.State.Closing) {
+            this._change(SerialJS.State.Closing);
+        }
+
+        try {
+            if (this.reader) this.reader.releaseLock();
+        } catch (e) { }
+
+        try {
+            if (this.writer) this.writer.releaseLock();
+        } catch (e) { }
+
         this.reader = null;
         this.writer = null;
 
         try {
-            await this._port.close();
-            this._change(SerialJS.State.Closed);
+            if (this._port) await this._port.close();
         } catch (e) { }
+
+        this._change(SerialJS.State.Closed);
+
+        if (this.retry) {
+            setTimeout(() => this._lifecycle.runNothrow(() => this._open()), this.cfg.reconnect);
+        }
     }
 
     async close() {
-        this.retry = false;
-        await this._close();
+        return this._lifecycle.runNothrow(async () => {
+            this.retry = false;
+            this._sender.reset();
+            await this._close();
+            return true;
+        });
     }
+
     async _close() {
         switch (this._state) {
-            case SerialJS.State.Closed: return;
+            case SerialJS.State.Closed:
+                return;
+
+            case SerialJS.State.Opening:
             case SerialJS.State.Open:
-                if (this.reader) await this.reader.cancel();
                 this._change(SerialJS.State.Closing);
+
+                if (this.reader) {
+                    try {
+                        await this.reader.cancel();
+                    } catch (e) { }
+                }
+
+                break;
+
+            case SerialJS.State.Closing:
                 break;
         }
 
         let i = 0;
-        while (this._state == SerialJS.State.Closing) {
+
+        while (this._state === SerialJS.State.Closing) {
             await sleep(10);
+
             if (++i > 200) {
                 this._error('Close timeout');
                 this._change(SerialJS.State.Closed);
                 break;
             }
         }
-
     }
 
     async sendText(text) {
-        await this.sendBin((new TextEncoder()).encode(text));
+        return this.sendBin(new TextEncoder().encode(text));
     }
 
     async sendBin(data) {
-        this._buffer.push(data);
-        this._send();
+        if (!this.opened() || !this.writer) return false;
+
+        return this._sender.runNothrow(async () => {
+            if (!this.opened() || !this.writer) return false;
+
+            await this.writer.write(data);
+            return true;
+        });
     }
 
-    //#region private
     _port = null;
     _state = SerialJS.State.Closed;
-    _buffer = new ShiftBuffer();
+
+    reader = null;
+    writer = null;
+    retry = false;
+
     _decoder = new TextDecoder();
+    _sender = new SerialExecutor();
+    _lifecycle = new SerialExecutor();
 
-    async _send() {
-        if (this._busy) return;
-        this._busy = true;
-        while (this._buffer.length && this.writer) {
-            let d = this._buffer.shiftAll();
-            try {
-                await this.writer.write(d);
-            } catch (e) { }
-        }
-        this._busy = false;
-    }
     async _setLastPort() {
-        let ports = await navigator.serial.getPorts();
+        const ports = await navigator.serial.getPorts();
         this._port = ports.length ? ports[0] : null;
     }
 
     _error(e) {
         this.onerror('[SerialJS] ' + e);
     }
+
     _change(s) {
+        if (this._state === s) return;
+
         this._state = s;
         this.onchange(s);
+
         switch (s) {
-            case SerialJS.State.Open: this.onopen(); break;
-            case SerialJS.State.Closed: this.onclose(); break;
+            case SerialJS.State.Open:
+                this.onopen();
+                break;
+
+            case SerialJS.State.Closed:
+                this.onclose();
+                break;
         }
     }
 }

package/test/index.html

@@ -3,8 +3,7 @@
 
 <head>
   <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-  <script src="script.js" type="module" defer="defer"></script>
+  <script src="./script.js" type="module"></script>
   <title>Serial test</title>
 </head>
 

package/test/script.js

@@ -1,4 +1,5 @@
-import SerialJS from "https://gyverlibs.github.io/Serial.js/serial.min.js";
+import SerialJS from 'https://gyverlibs.github.io/Serial.js/Serial.min.js'
+// import SerialJS from "../serial";
 
 let i = 0;
 let ser = new SerialJS();

package/webpack.dev.config.js

@@ -1,39 +1,24 @@
 const path = require('path');
-const PACKAGE = require('./package.json');
-const HtmlWebpackPlugin = require('html-webpack-plugin');
 
 module.exports = {
-    entry: {
-        index: './test_dev/script.js',
-    },
-
+    entry: './test/script.js',
     output: {
         filename: 'script.js',
-        path: path.resolve(__dirname, 'dev'),
-        clean: true,
+        path: path.resolve(__dirname, 'test'),
+        clean: false,
+    },
+    module: {
+        rules: [
+            {
+                test: /\.css$/,
+                use: ['style-loader', 'css-loader'],
+            }
+        ]
     },
-
-    plugins: [
-        new HtmlWebpackPlugin({
-            template: `./test_dev/index.html`,
-            filename: `index.html`,
-            inject: true,
-            minify: false,
-            version: PACKAGE.version,
-            title: PACKAGE.title,
-        }),
-    ],
-
     devServer: {
-        watchFiles: ['test_dev/*.html'],
-        static: path.resolve(__dirname, './dev'),
+        static: path.resolve(__dirname, 'test'),
         hot: true,
         open: true,
     },
-
-    watchOptions: {
-        poll: 1000,
-    },
-
     mode: 'development',
 };

package/test_dev/index.html

@@ -1,18 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-  <script src="script.js" type="module" defer="defer"></script>
-  <title>Serial test</title>
-</head>
-
-<body>
-  <button id="select_b">select</button>
-  <button id="open_b">open</button>
-  <button id="close_b">close</button>
-  <button id="send_b">send</button>
-</body>
-
-</html>

package/test_dev/script.js

@@ -1,31 +0,0 @@
-import SerialJS from "../serial";
-
-let i = 0;
-let ser = new SerialJS();
-
-// control
-select_b.onclick = () => ser.select();
-open_b.onclick = () => ser.open();
-close_b.onclick = () => ser.close();
-send_b.onclick = () => ser.sendText('Hello ' + i++);
-
-// read
-// ser.onbin = b => console.log(b);
-ser.ontext = t => console.log(t);
-
-// state
-// ser.onopen = () => {
-//     console.log('Opened', ser.getName());
-// }
-// ser.onclose = () => {
-//     console.log('Closed');
-// }
-ser.onchange = s => {
-    console.log(s);
-}
-ser.onerror = e => {
-    console.log(e);
-}
-ser.onselect = (port) => {
-    console.log('select', port);
-}