speechflow 0.9.4 → 0.9.7

package/src/speechflow-node-file.ts

@@ -1,108 +0,0 @@
-/*
-**  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-
-/*  standard dependencies  */
-import fs               from "node:fs"
-import Stream           from "node:stream"
-
-/*  internal dependencies  */
-import SpeechFlowNode   from "./speechflow-node"
-
-/*  SpeechFlow node for file access  */
-export default class SpeechFlowNodeFile extends SpeechFlowNode {
-    /*  declare official node name  */
-    public static name = "file"
-
-    /*  construct node  */
-    constructor (id: string, opts: { [ id: string ]: any }, args: any[]) {
-        super(id, opts, args)
-
-        /*  declare node configuration parameters  */
-        this.configure({
-            path: { type: "string", pos: 0 },
-            mode: { type: "string", pos: 1, val: "r",     match: /^(?:r|w|rw)$/ },
-            type: { type: "string", pos: 2, val: "audio", match: /^(?:audio|text)$/ }
-        })
-
-        /*  declare node input/output format  */
-        if (this.params.mode === "rw") {
-            this.input  = this.params.type
-            this.output = this.params.type
-        }
-        else if (this.params.mode === "r") {
-            this.input  = "none"
-            this.output = this.params.type
-        }
-        else if (this.params.mode === "w") {
-            this.input  = this.params.type
-            this.output = "none"
-        }
-    }
-
-    /*  open node  */
-    async open () {
-        const encoding = this.params.type === "text" ? this.config.textEncoding : "binary"
-        if (this.params.mode === "rw") {
-            if (this.params.path === "-") {
-                /*  standard I/O  */
-                process.stdin.setEncoding(encoding)
-                process.stdout.setEncoding(encoding)
-                this.stream = Stream.Duplex.from({
-                    readable: process.stdin,
-                    writable: process.stdout
-                })
-            }
-            else {
-                /*  file I/O  */
-                this.stream = Stream.Duplex.from({
-                    readable: fs.createReadStream(this.params.path, { encoding }),
-                    writable: fs.createWriteStream(this.params.path, { encoding })
-                })
-            }
-        }
-        else if (this.params.mode === "r") {
-            if (this.params.path === "-") {
-                /*  standard I/O  */
-                process.stdin.setEncoding(encoding)
-                this.stream = process.stdin
-            }
-            else {
-                /*  file I/O  */
-                this.stream = fs.createReadStream(this.params.path, { encoding })
-            }
-        }
-        else if (this.params.mode === "w") {
-            if (this.params.path === "-") {
-                /*  standard I/O  */
-                process.stdout.setEncoding(encoding)
-                this.stream = process.stdout
-            }
-            else {
-                /*  file I/O  */
-                this.stream = fs.createWriteStream(this.params.path, { encoding })
-            }
-        }
-        else
-            throw new Error(`invalid file mode "${this.params.mode}"`)
-    }
-
-    /*  close node  */
-    async close () {
-        /*  shutdown stream  */
-        if (this.stream !== null) {
-            await new Promise<void>((resolve) => {
-                if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex)
-                    this.stream.end(() => { resolve() })
-                else
-                    resolve()
-            })
-            if (this.params.path !== "-")
-                this.stream.destroy()
-            this.stream = null
-        }
-    }
-}
-

package/src/speechflow-node-websocket.ts

@@ -1,179 +0,0 @@
-/*
-**  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-
-/*  standard dependencies  */
-import Stream                          from "node:stream"
-
-/*  external dependencies  */
-import ws                              from "ws"
-import ReconnWebsocket, { ErrorEvent } from "@opensumi/reconnecting-websocket"
-
-/*  internal dependencies  */
-import SpeechFlowNode                  from "./speechflow-node"
-
-/*  SpeechFlow node for Websocket networking  */
-export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
-    /*  declare official node name  */
-    public static name = "websocket"
-
-    /*  internal state  */
-    private server: ws.WebSocketServer | null = null
-    private client: WebSocket          | null = null
-
-    /*  construct node  */
-    constructor (id: string, opts: { [ id: string ]: any }, args: any[]) {
-        super(id, opts, args)
-
-        /*  declare node configuration parameters  */
-        this.configure({
-            listen:  { type: "string", val: "",     match: /^(?:|ws:\/\/(.+?):(\d+))$/ },
-            connect: { type: "string", val: "",     match: /^(?:|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/ },
-            type:    { type: "string", val: "text", match: /^(?:audio|text)$/ }
-        })
-
-        /*  sanity check usage  */
-        if (this.params.listen !== "" && this.params.connect !== "")
-            throw new Error("Websocket node cannot listen and connect at the same time")
-        else if (this.params.listen === "" && this.params.connect === "")
-            throw new Error("Websocket node requires either listen or connect mode")
-
-        /*  declare node input/output format  */
-        if (this.params.listen !== "") {
-            this.input  = "none"
-            this.output = this.params.type
-        }
-        else if (this.params.connect !== "") {
-            this.input  = this.params.type
-            this.output = "none"
-        }
-    }
-
-    /*  open node  */
-    async open () {
-        if (this.params.listen !== "") {
-            /*  listen locally on a Websocket port  */
-            const url = new URL(this.params.listen)
-            let websocket: ws.WebSocket | null = null
-            const server = new ws.WebSocketServer({
-                host: url.hostname,
-                port: Number.parseInt(url.port),
-                path: url.pathname
-            })
-            server.on("listening", () => {
-                this.log("info", `listening on URL ${this.params.listen}`)
-            })
-            server.on("connection", (ws, request) => {
-                this.log("info", `connection opened on URL ${this.params.listen}`)
-                websocket = ws
-            })
-            server.on("close", () => {
-                this.log("info", `connection closed on URL ${this.params.listen}`)
-                websocket = null
-            })
-            server.on("error", (error) => {
-                this.log("error", `error on URL ${this.params.listen}: ${error.message}`)
-                websocket = null
-            })
-            const textEncoding = this.config.textEncoding
-            this.stream = new Stream.Duplex({
-                write (chunk: Buffer, encoding, callback) {
-                    const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength)
-                    if (websocket !== null) {
-                        websocket.send(data, (error) => {
-                            if (error) callback(error)
-                            else       callback()
-                        })
-                    }
-                    else
-                        callback(new Error("still no Websocket connection available"))
-                },
-                read (size: number) {
-                    if (websocket !== null) {
-                        websocket.once("message", (data, isBinary) => {
-                            this.push(data, isBinary ? "binary" : textEncoding)
-                        })
-                    }
-                    else
-                        throw new Error("still no Websocket connection available")
-                }
-            })
-        }
-        else if (this.params.connect !== "") {
-            /*  connect remotely to a Websocket port  */
-            this.client = new ReconnWebsocket(this.params.connect, [], {
-                WebSocket:                   ws,
-                WebSocketOptions:            {},
-                reconnectionDelayGrowFactor: 1.3,
-                maxReconnectionDelay:        4000,
-                minReconnectionDelay:        1000,
-                connectionTimeout:           4000,
-                minUptime:                   5000
-            })
-            this.client.addEventListener("open", (ev: Event) => {
-                this.log("info", `connection opened on URL ${this.params.connect}`)
-            })
-            this.client.addEventListener("close", (ev: Event) => {
-                this.log("info", `connection closed on URL ${this.params.connect}`)
-            })
-            this.client.addEventListener("error", (ev: ErrorEvent) => {
-                this.log("error", `error on URL ${this.params.connect}: ${ev.error.message}`)
-            })
-            const client = this.client
-            client.binaryType = "arraybuffer"
-            const textEncoding = this.config.textEncoding
-            this.stream = new Stream.Duplex({
-                write (chunk: Buffer, encoding, callback) {
-                    const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength)
-                    if (client.OPEN) {
-                        client.send(data)
-                        callback()
-                    }
-                    else
-                        callback(new Error("still no Websocket connection available"))
-                },
-                read (size: number) {
-                    if (client.OPEN) {
-                        client.addEventListener("message", (ev: MessageEvent) => {
-                            if (ev.data instanceof ArrayBuffer)
-                                this.push(ev.data, "binary")
-                            else
-                                this.push(ev.data, textEncoding)
-                        }, { once: true })
-                    }
-                    else
-                        throw new Error("still no Websocket connection available")
-                }
-            })
-        }
-    }
-
-    /*  close node  */
-    async close () {
-        /*  close Websocket server  */
-        if (this.server !== null) {
-            await new Promise<void>((resolve, reject) => {
-                this.server!.close((error) => {
-                    if (error) reject(error)
-                    else       resolve()
-                })
-            })
-            this.server = null
-        }
-
-        /*  close Websocket client  */
-        if (this.client !== null) {
-            this.client!.close()
-            this.client = null
-        }
-
-        /*  close stream  */
-        if (this.stream !== null) {
-            this.stream.destroy()
-            this.stream = null
-        }
-    }
-}
-