@maiyunnet/kebab 2.0.0

package/lib/ws.js

@@ -0,0 +1,373 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = exports.EOpcode = exports.EFrameReceiveMode = void 0;
+exports.connect = connect;
+exports.createServer = createServer;
+exports.mproxy = mproxy;
+exports.rproxy = rproxy;
+const liws = __importStar(require("@litert/websocket"));
+const lText = __importStar(require("~/lib/text"));
+const lNet = __importStar(require("~/lib/net"));
+var EFrameReceiveMode;
+(function (EFrameReceiveMode) {
+    EFrameReceiveMode[EFrameReceiveMode["STANDARD"] = 0] = "STANDARD";
+    EFrameReceiveMode[EFrameReceiveMode["LITE"] = 1] = "LITE";
+    EFrameReceiveMode[EFrameReceiveMode["SIMPLE"] = 2] = "SIMPLE";
+})(EFrameReceiveMode || (exports.EFrameReceiveMode = EFrameReceiveMode = {}));
+var EOpcode;
+(function (EOpcode) {
+    EOpcode[EOpcode["CONTINUATION"] = 0] = "CONTINUATION";
+    EOpcode[EOpcode["TEXT"] = 1] = "TEXT";
+    EOpcode[EOpcode["BINARY"] = 2] = "BINARY";
+    EOpcode[EOpcode["CLOSE"] = 8] = "CLOSE";
+    EOpcode[EOpcode["PING"] = 9] = "PING";
+    EOpcode[EOpcode["PONG"] = 10] = "PONG";
+})(EOpcode || (exports.EOpcode = EOpcode = {}));
+const liwsServer = liws.createServer();
+class Socket {
+    constructor(request, socket, options = {}) {
+        this._waitMsg = [];
+        this._error = null;
+        this._close = false;
+        this._on = {
+            message: (msg) => {
+                this._waitMsg.push(msg);
+            },
+            drain: () => {
+            },
+            error: (e) => {
+                this._error = e;
+            },
+            close: () => {
+                this._close = true;
+            },
+            end: () => {
+            }
+        };
+        if (!request || !socket) {
+            return;
+        }
+        this._ws = liwsServer.accept({
+            'request': request,
+            'socket': socket,
+            'headers': options.headers,
+            'timeout': options.timeout
+        });
+        this._bindEvent();
+    }
+    async connect(u, opt = {}) {
+        const uri = lText.parseUrl(u);
+        if (!uri.hostname) {
+            return null;
+        }
+        const puri = opt.mproxy ? lText.parseUrl(opt.mproxy.url) : null;
+        const timeout = opt.timeout ?? 10;
+        const hosts = opt.hosts ?? {};
+        const local = opt.local;
+        const mode = opt.mode ?? EFrameReceiveMode.SIMPLE;
+        const masking = opt.masking ?? true;
+        const headers = {};
+        if (opt.headers) {
+            for (const key in opt.headers) {
+                headers[key.toLowerCase()] = opt.headers[key];
+            }
+        }
+        headers['user-agent'] ??= 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36';
+        if (opt.cookie) {
+            headers['cookie'] = lNet.buildCookieQuery(opt.cookie, uri);
+        }
+        const ca = puri ?
+            puri.protocol === 'wss:' ? await lNet.getCa() : null :
+            uri.protocol === 'wss:' ? await lNet.getCa() : null;
+        if (!ca && hosts[uri.hostname]) {
+            headers['host'] = uri.hostname + (uri.port ? ':' + uri.port : '');
+        }
+        try {
+            const host = puri?.hostname ?? uri.hostname ?? '';
+            const port = (puri ? puri.port : uri.port) ?? 443;
+            const path = puri ? puri.path + (puri.path?.includes('?') ? '&' : '?') + lText.queryStringify({
+                'url': u,
+                'auth': opt.mproxy?.auth ?? ''
+            }) : uri.path;
+            const cli = ca ?
+                await liws.wssConnect({
+                    'hostname': hosts[host] ?? host,
+                    'port': port,
+                    'path': path,
+                    'servername': host,
+                    'headers': headers,
+                    'connectTimeout': timeout * 1000,
+                    'frameReceiveMode': mode,
+                    'localAddress': local,
+                    'ca': ca
+                }) :
+                await liws.wsConnect({
+                    'hostname': hosts[host] ?? host,
+                    'port': port,
+                    'path': path,
+                    'headers': headers,
+                    'connectTimeout': timeout * 1000,
+                    'frameReceiveMode': mode,
+                    'localAddress': local
+                });
+            cli.setMasking(masking);
+            this._ws = cli;
+            this._bindEvent();
+            return this;
+        }
+        catch {
+            return null;
+        }
+    }
+    _bindEvent() {
+        this._ws.on('message', (msg) => {
+            (async () => {
+                if (msg.opcode === EOpcode.CLOSE) {
+                    return;
+                }
+                let data = '';
+                if ('data' in msg) {
+                    data = Buffer.concat(msg.data);
+                    if (msg.opcode === EOpcode.TEXT) {
+                        data = data.toString();
+                    }
+                }
+                else {
+                    data = await (msg.opcode === EOpcode.TEXT ? msg.toString() : msg.toBuffer());
+                }
+                this._on.message({
+                    'opcode': msg.opcode,
+                    'data': data
+                });
+            })().catch(() => {
+            });
+        }).on('drain', () => {
+            this._on.drain();
+        }).on('error', (e) => {
+            this._on.error(e);
+        }).on('end', () => {
+            this._on.end();
+        }).on('close', () => {
+            this._on.close();
+        });
+    }
+    on(event, cb) {
+        this._on[event] = cb;
+        switch (event) {
+            case 'message': {
+                for (const item of this._waitMsg) {
+                    cb(item);
+                }
+                break;
+            }
+            case 'error': {
+                if (!this._error) {
+                    break;
+                }
+                cb(this._error);
+                break;
+            }
+            case 'end': {
+                cb();
+                break;
+            }
+            default: {
+                if (!this._close) {
+                    break;
+                }
+                cb();
+            }
+        }
+        return this;
+    }
+    end() {
+        this._ws.end();
+    }
+    destroy() {
+        this._ws.destroy();
+    }
+    writeText(data) {
+        if (!this._ws.writable) {
+            return false;
+        }
+        return this._ws.writeText(data);
+    }
+    writeResult(data) {
+        if (!this._ws.writable) {
+            return false;
+        }
+        return this._ws.writeText(lText.stringifyResult(data));
+    }
+    writeBinary(data) {
+        if (!this._ws.writable) {
+            return false;
+        }
+        return this._ws.writeBinary(data);
+    }
+    get writable() {
+        return this._ws.writable;
+    }
+    get ended() {
+        return this._ws.ended;
+    }
+    get finished() {
+        return this._ws.finished;
+    }
+    get isServer() {
+        return this._ws.isServer;
+    }
+    ping(data) {
+        try {
+            this._ws.ping(data);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    pong(data) {
+        try {
+            this._ws.pong(data);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.Socket = Socket;
+function connect(u, opt = {}) {
+    const s = new Socket();
+    return s.connect(u, opt);
+}
+function createServer(request, socket, options = {}) {
+    return new Socket(request, socket, options);
+}
+function bindPipe(s1, s2) {
+    return new Promise((resolve) => {
+        s1.on('message', (msg) => {
+            switch (msg.opcode) {
+                case EOpcode.TEXT:
+                case EOpcode.BINARY: {
+                    if (typeof msg.data === 'string') {
+                        s2.writeText(msg.data);
+                        break;
+                    }
+                    s2.writeBinary(msg.data);
+                    break;
+                }
+                case EOpcode.CLOSE: {
+                    s2.end();
+                    resolve();
+                    break;
+                }
+                case EOpcode.PING: {
+                    s2.ping(msg.data);
+                    break;
+                }
+                case EOpcode.PONG: {
+                    s2.pong(msg.data);
+                    break;
+                }
+                default: {
+                }
+            }
+        }).on('close', () => {
+            resolve();
+        });
+        s2.on('message', (msg) => {
+            switch (msg.opcode) {
+                case EOpcode.TEXT:
+                case EOpcode.BINARY: {
+                    if (typeof msg.data === 'string') {
+                        s1.writeText(msg.data);
+                        break;
+                    }
+                    s1.writeBinary(msg.data);
+                    break;
+                }
+                case EOpcode.CLOSE: {
+                    s1.end();
+                    resolve();
+                    break;
+                }
+                case EOpcode.PING: {
+                    s1.ping(msg.data);
+                    break;
+                }
+                case EOpcode.PONG: {
+                    s1.pong(msg.data);
+                    break;
+                }
+                default: {
+                }
+            }
+        }).on('close', () => {
+            resolve();
+        });
+    });
+}
+async function mproxy(ctr, auth, opt = {}) {
+    const req = ctr.getPrototype('_req');
+    const socket = ctr.getPrototype('_socket');
+    const get = ctr.getPrototype('_get');
+    if (get['auth'] !== auth) {
+        return 0;
+    }
+    if (!get['url']) {
+        return -1;
+    }
+    opt.headers ??= {};
+    Object.assign(opt.headers, lNet.filterProxyHeaders(req.headers));
+    const rsocket = await connect(get['url'], opt);
+    if (!rsocket) {
+        return -2;
+    }
+    await bindPipe(socket, rsocket);
+    return 1;
+}
+async function rproxy(ctr, url, opt = {}) {
+    const req = ctr.getPrototype('_req');
+    const socket = ctr.getPrototype('_socket');
+    opt.headers ??= {};
+    Object.assign(opt.headers, lNet.filterProxyHeaders(req.headers));
+    const rsocket = await connect(url, opt);
+    if (!rsocket) {
+        return false;
+    }
+    await bindPipe(socket, rsocket);
+    return true;
+}