@signalk/streams 5.1.3 → 6.0.0

package/dist/simple.js

@@ -0,0 +1,446 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const n2kAnalyzer_1 = __importDefault(require("./n2kAnalyzer"));
+const from_json_1 = __importDefault(require("./from_json"));
+const multiplexedlog_1 = __importDefault(require("./multiplexedlog"));
+const nmea0183_signalk_1 = __importDefault(require("./nmea0183-signalk"));
+const n2k_signalk_1 = __importDefault(require("./n2k-signalk"));
+const log_1 = __importDefault(require("./log"));
+const liner_1 = __importDefault(require("./liner"));
+const splitting_liner_1 = __importDefault(require("./splitting-liner"));
+const execute_1 = __importDefault(require("./execute"));
+const udp_1 = __importDefault(require("./udp"));
+const tcp_1 = __importDefault(require("./tcp"));
+const tcpserver_1 = __importDefault(require("./tcpserver"));
+const filestream_1 = __importDefault(require("./filestream"));
+const replacer_1 = __importDefault(require("./replacer"));
+const throttle_1 = __importDefault(require("./throttle"));
+const timestamp_throttle_1 = __importDefault(require("./timestamp-throttle"));
+const canboatjs_1 = __importDefault(require("./canboatjs"));
+const canboatjs_2 = require("@canboat/canboatjs");
+const gpsd_1 = __importDefault(require("./gpsd"));
+const pigpio_seatalk_1 = __importDefault(require("./pigpio-seatalk"));
+const gpiod_seatalk_1 = __importDefault(require("./gpiod-seatalk"));
+const W2k01Ctor = canboatjs_2.W2k01;
+const Ydwg02Ctor = canboatjs_2.Ydwg02;
+const iKonvertCtor = canboatjs_2.iKonvert;
+const discriminatorByDataType = {
+    NMEA2000JS: 'A',
+    NMEA2000IK: 'A',
+    NMEA2000YD: 'A',
+    NMEA2000: 'A',
+    NMEA0183: 'N',
+    SignalK: 'I',
+    Seatalk: 'N'
+};
+const dataTypeMapping = {
+    SignalK: (options) => options.subOptions.type !== 'wss' && options.subOptions.type !== 'ws'
+        ? [new from_json_1.default()]
+        : [],
+    Seatalk: (options) => [
+        new nmea0183_signalk_1.default({
+            ...options.subOptions,
+            validateChecksum: false
+        })
+    ],
+    NMEA0183: (options) => {
+        const result = [new nmea0183_signalk_1.default(options.subOptions)];
+        if (options.type === 'FileStream') {
+            result.unshift(new throttle_1.default({
+                rate: options.subOptions.throttleRate ?? 1000,
+                chunksize: options.subOptions.throttleRate ?? 1000
+            }));
+        }
+        return result;
+    },
+    NMEA2000: (options) => {
+        const result = [new n2kAnalyzer_1.default(options.subOptions)];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default());
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    NMEA2000JS: (options) => {
+        const result = [new canboatjs_1.default(options.subOptions)];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default());
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    NMEA2000IK: (options) => {
+        const result = [new canboatjs_1.default(options.subOptions)];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default({
+                getMilliseconds: (msg) => {
+                    return msg.timer * 1000;
+                }
+            }));
+        }
+        {
+            let subOptions;
+            if (options.subOptions.type === 'navlink2-tcp-canboatjs') {
+                subOptions = { ...options.subOptions, tcp: true };
+            }
+            else {
+                subOptions = options.subOptions;
+            }
+            result.unshift(new iKonvertCtor(subOptions));
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    NMEA2000YD: (options) => {
+        const result = [
+            new Ydwg02Ctor({ ...options.subOptions }, options.subOptions.type === 'ydwg02-usb-canboatjs' ? 'usb' : 'network')
+        ];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default());
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    NMEA2000W2K_ASCII: (options) => {
+        const result = [
+            new W2k01Ctor({
+                format: 'ascii',
+                ...options.subOptions
+            })
+        ];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default());
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    NMEA2000W2K_ACTISENSE: (options) => {
+        const result = [
+            new W2k01Ctor({
+                format: 'actisense',
+                ...options.subOptions
+            })
+        ];
+        if (options.type === 'FileStream') {
+            result.push(new timestamp_throttle_1.default());
+        }
+        return [...result, new n2k_signalk_1.default(options.subOptions)];
+    },
+    Multiplexed: (options) => [new multiplexedlog_1.default(options.subOptions)]
+};
+function nmea2000input(subOptions, logging) {
+    if (subOptions.type === 'ngt-1-canboatjs') {
+        const ActisenseSerial = require('./actisense-serial');
+        const Ctor = ActisenseSerial.default ?? ActisenseSerial;
+        return [
+            new Ctor({
+                ...subOptions,
+                plainText: logging
+            })
+        ];
+    }
+    else if (subOptions.type === 'canbus-canboatjs') {
+        const Canbus = require('./canbus');
+        const Ctor = Canbus.default ?? Canbus;
+        return [
+            new Ctor({
+                ...subOptions,
+                canDevice: subOptions.interface
+            })
+        ];
+    }
+    else if (subOptions.type === 'ikonvert-canboatjs') {
+        const Serialport = require('./serialport');
+        const Ctor = Serialport.default ?? Serialport;
+        return [
+            new Ctor({
+                ...subOptions,
+                baudrate: 230400,
+                toStdout: 'ikonvertOut'
+            })
+        ];
+    }
+    else if (subOptions.type === 'ydwg02-canboatjs') {
+        return [
+            new tcp_1.default({ ...subOptions, outEvent: 'ydwg02-out' }),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'ydwg02-udp-canboatjs') {
+        return [
+            new udp_1.default({ ...subOptions, outEvent: 'ydwg02-out' }),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'navlink2-tcp-canboatjs') {
+        return [
+            new tcp_1.default({ ...subOptions, outEvent: 'navlink2-out' }),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'w2k-1-n2k-ascii-canboatjs') {
+        return [
+            new tcp_1.default({ ...subOptions, outEvent: 'w2k-1-out' }),
+            new liner_1.default(subOptions),
+            new W2k01Ctor(subOptions, 'ascii', 'w2k-1-out')
+        ];
+    }
+    else if (subOptions.type === 'w2k-1-n2k-actisense-canboatjs') {
+        return [
+            new tcp_1.default({ ...subOptions, outEvent: 'w2k-1-out' }),
+            new W2k01Ctor(subOptions, 'actisense', 'w2k-1-out')
+        ];
+    }
+    else if (subOptions.type === 'navlink2-udp-canboatjs') {
+        return [
+            new udp_1.default(subOptions),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'ydwg02-usb-canboatjs') {
+        const Serialport = require('./serialport');
+        const Ctor = Serialport.default ?? Serialport;
+        return [
+            new Ctor({
+                ...subOptions,
+                baudrate: 38400,
+                toStdout: 'ydwg02-out'
+            })
+        ];
+    }
+    else {
+        let command;
+        let toChildProcess;
+        if (subOptions.type === 'ngt-1') {
+            command = `actisense-serial -s ${subOptions.baudrate ?? 115200} ${subOptions.device}`;
+            toChildProcess = 'nmea2000out';
+        }
+        else if (subOptions.type === 'canbus') {
+            command = `candump ${subOptions.interface} | candump2analyzer`;
+            toChildProcess = undefined;
+        }
+        else {
+            throw new Error(`unknown NMEA2000 type ${subOptions.type}`);
+        }
+        return [
+            new execute_1.default({
+                command,
+                toChildProcess,
+                app: subOptions.app,
+                providerId: subOptions.providerId
+            }),
+            new liner_1.default(subOptions)
+        ];
+    }
+}
+function nmea0183input(subOptions) {
+    let pipePart;
+    if (subOptions.type === 'tcp') {
+        pipePart = [
+            new tcp_1.default(subOptions),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'tcpserver') {
+        pipePart = [new tcpserver_1.default(subOptions), new liner_1.default(subOptions)];
+    }
+    else if (subOptions.type === 'udp') {
+        pipePart = [
+            new udp_1.default(subOptions),
+            new splitting_liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'serial') {
+        const Serialport = require('./serialport');
+        const Ctor = Serialport.default ?? Serialport;
+        pipePart = [new Ctor(subOptions)];
+    }
+    else if (subOptions.type === 'gpsd') {
+        pipePart = [new gpsd_1.default(subOptions)];
+    }
+    if (pipePart) {
+        if (subOptions.removeNulls) {
+            pipePart.push(new replacer_1.default({ regexp: '\u0000', template: '' }));
+        }
+        if (subOptions.ignoredSentences) {
+            console.log(subOptions.ignoredSentences);
+            subOptions.ignoredSentences.forEach((sentence) => {
+                if (sentence.length > 0) {
+                    pipePart.push(new replacer_1.default({ regexp: `^...${sentence}.*`, template: '' }));
+                }
+            });
+        }
+        return pipePart;
+    }
+    else {
+        throw new Error(`Unknown networking type: ${subOptions.type}`);
+    }
+}
+function executeInput(subOptions) {
+    return [
+        new execute_1.default(subOptions),
+        new liner_1.default(subOptions)
+    ];
+}
+function fileInput(subOptions) {
+    return [
+        new filestream_1.default(subOptions),
+        new liner_1.default(subOptions)
+    ];
+}
+function signalKInput(subOptions) {
+    if (subOptions.type === 'ws' || subOptions.type === 'wss') {
+        const MdnsWs = require('./mdns-ws');
+        const Ctor = MdnsWs.default ?? MdnsWs;
+        return [new Ctor(subOptions)];
+    }
+    else if (subOptions.type === 'tcp') {
+        return [
+            new tcp_1.default(subOptions),
+            new liner_1.default(subOptions)
+        ];
+    }
+    else if (subOptions.type === 'udp') {
+        return [new udp_1.default(subOptions)];
+    }
+    else if (subOptions.type === 'serial') {
+        const Serialport = require('./serialport');
+        const Ctor = Serialport.default ?? Serialport;
+        return [new Ctor(subOptions)];
+    }
+    throw new Error(`unknown SignalK type: ${subOptions.type}`);
+}
+function seatalkInput(subOptions) {
+    if (subOptions.type === 'gpiod') {
+        return [new gpiod_seatalk_1.default(subOptions)];
+    }
+    else {
+        return [new pigpio_seatalk_1.default(subOptions)];
+    }
+}
+const pipeStartByType = {
+    NMEA2000: nmea2000input,
+    NMEA0183: nmea0183input,
+    Execute: executeInput,
+    FileStream: fileInput,
+    SignalK: signalKInput,
+    Seatalk: seatalkInput
+};
+function getLoggerPipeline(app, logging, discriminator) {
+    if (!logging) {
+        return [];
+    }
+    return [
+        new log_1.default({
+            app,
+            discriminator
+        })
+    ];
+}
+class Simple extends stream_1.Transform {
+    pipeline;
+    constructor(options) {
+        super({ objectMode: true });
+        const { emitPropertyValue, onPropertyValues, createDebug } = options;
+        const opts = { ...options };
+        opts.subOptions = {
+            ...options.subOptions,
+            emitPropertyValue,
+            onPropertyValues,
+            createDebug
+        };
+        opts.subOptions.providerId = options.providerId;
+        const dataType = opts.subOptions.dataType ?? options.type;
+        if (!dataType) {
+            throw new Error(`Unknown data type for ${options.type}`);
+        }
+        if (!pipeStartByType[options.type]) {
+            throw new Error(`Invalid input type: ${options.type}`);
+        }
+        if (!dataTypeMapping[dataType]) {
+            throw new Error(`Unknown data type: ${dataType}`);
+        }
+        if (dataType !== 'Multiplexed' && !discriminatorByDataType[dataType]) {
+            throw new Error(`No discriminator for: ${dataType}`);
+        }
+        opts.subOptions.app = options.app;
+        let mappingType = dataType;
+        if (options.type === 'NMEA2000' && opts.subOptions) {
+            if (opts.subOptions.type === 'ngt-1-canboatjs' ||
+                opts.subOptions.type === 'canbus-canboatjs' ||
+                opts.subOptions.type === 'w2k-1-n2k-actisense-canboatjs' ||
+                opts.subOptions.type === 'w2k-1-n2k-ascii-canboatjs') {
+                mappingType = 'NMEA2000JS';
+            }
+            else if (opts.subOptions.type === 'ikonvert-canboatjs' ||
+                opts.subOptions.type === 'navlink2-tcp-canboatjs') {
+                mappingType = 'NMEA2000IK';
+            }
+            else if (opts.subOptions.type === 'ydwg02-canboatjs' ||
+                opts.subOptions.type === 'ydwg02-udp-canboatjs' ||
+                opts.subOptions.type === 'ydwg02-usb-canboatjs') {
+                mappingType = 'NMEA2000YD';
+            }
+            options.app.on('nmea2000out', () => {
+                setImmediate(() => options.app.emit('connectionwrite', {
+                    providerId: options.providerId
+                }));
+            });
+            options.app.on('nmea2000JsonOut', () => {
+                setImmediate(() => options.app.emit('connectionwrite', {
+                    providerId: options.providerId
+                }));
+            });
+        }
+        const pipeStart = pipeStartByType[options.type];
+        const dataMapper = dataTypeMapping[mappingType];
+        const pipeline = [
+            ...pipeStart(opts.subOptions, options.logging),
+            ...getLoggerPipeline(options.app, options.logging, discriminatorByDataType[dataType]),
+            ...dataMapper(opts)
+        ];
+        const dataReceivedEventName = `${opts.subOptions.providerId}-received`;
+        const spy = new stream_1.Transform({
+            objectMode: true,
+            transform(chunk, encoding, callback) {
+                options.app.emit(dataReceivedEventName, chunk);
+                callback(null, chunk);
+            }
+        });
+        pipeline.splice(pipeline.length - 1, 0, spy);
+        opts.subOptions.app.emitPropertyValue('pipedprovider', {
+            id: opts.subOptions.providerId,
+            type: mappingType,
+            eventNames: {
+                received: dataReceivedEventName
+            }
+        });
+        if (opts.subOptions.overrideTimestamp) {
+            pipeline.push(new stream_1.Transform({
+                objectMode: true,
+                transform(delta, encoding, callback) {
+                    if (delta.updates) {
+                        const now = new Date().toISOString();
+                        delta.updates.forEach((update) => {
+                            update.timestamp = now;
+                        });
+                    }
+                    callback(null, delta);
+                }
+            }));
+        }
+        for (let i = pipeline.length - 2; i >= 0; i--) {
+            pipeline[i].pipe(pipeline[i + 1]);
+        }
+        pipeline[pipeline.length - 1].pipe(this);
+        this.pipeline = pipeline;
+    }
+    _transform(msg, encoding, done) {
+        this.push(msg);
+        done();
+    }
+    end() {
+        this.pipeline[0].end();
+        return this;
+    }
+}
+exports.default = Simple;

package/dist/splitting-liner.d.ts

@@ -0,0 +1,12 @@
+import { Transform, TransformCallback } from 'stream';
+interface SplittingLinerOptions {
+    lineSeparator?: string;
+    [key: string]: unknown;
+}
+export default class SplittingLiner extends Transform {
+    private readonly lineSeparator;
+    constructor(options?: SplittingLinerOptions);
+    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
+}
+export {};
+//# sourceMappingURL=splitting-liner.d.ts.map

package/dist/splitting-liner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitting-liner.d.ts","sourceRoot":"","sources":["../src/splitting-liner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAErD,UAAU,qBAAqB;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,SAAS;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;gBAE1B,OAAO,GAAE,qBAA0B;IAK/C,UAAU,CACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,iBAAiB,GACtB,IAAI;CAQR"}

package/dist/splitting-liner.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+class SplittingLiner extends stream_1.Transform {
+    lineSeparator;
+    constructor(options = {}) {
+        super({ objectMode: true });
+        this.lineSeparator = options.lineSeparator ?? '\n';
+    }
+    _transform(chunk, encoding, done) {
+        const data = chunk.toString();
+        const lines = data.split(this.lineSeparator);
+        for (const line of lines) {
+            this.push(line);
+        }
+        done();
+    }
+}
+exports.default = SplittingLiner;

package/dist/tcp.d.ts

@@ -0,0 +1,32 @@
+import { Transform, TransformCallback } from 'stream';
+import type { CreateDebug } from './types';
+interface TcpOptions {
+    host: string;
+    port: number;
+    app: {
+        on(event: string, cb: (...args: any[]) => void): void;
+        emit(event: string, ...args: unknown[]): void;
+        setProviderStatus(id: string, msg: string): void;
+        setProviderError(id: string, msg: string): void;
+    };
+    providerId: string;
+    noDataReceivedTimeout?: string | number;
+    outEvent?: string;
+    toStdout?: string | string[];
+    createDebug?: CreateDebug;
+    [key: string]: unknown;
+}
+export default class TcpStream extends Transform {
+    private readonly options;
+    private readonly debug;
+    private readonly debugData;
+    private readonly noDataReceivedTimeout;
+    private tcpStream;
+    private reconnector;
+    constructor(options: TcpOptions);
+    pipe<T extends NodeJS.WritableStream>(pipeTo: T): T;
+    end(): this;
+    _transform(data: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
+}
+export {};
+//# sourceMappingURL=tcp.d.ts.map

package/dist/tcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcp.d.ts","sourceRoot":"","sources":["../src/tcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAErD,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,SAAS,CAAA;AAEvD,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE;QAEH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAA;QACrD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QAC7C,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;QAChD,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAChD,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,SAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAC9C,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,WAAW,CAAsC;gBAE7C,OAAO,EAAE,UAAU;IAW/B,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAmFnD,GAAG,IAAI,IAAI;IAOX,UAAU,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI;CAGR"}

package/dist/tcp.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = __importDefault(require("net"));
+const stream_1 = require("stream");
+const reconnect_core_1 = __importDefault(require("reconnect-core"));
+class TcpStream extends stream_1.Transform {
+    options;
+    debug;
+    debugData;
+    noDataReceivedTimeout;
+    tcpStream;
+    reconnector = null;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.noDataReceivedTimeout =
+            Number.parseInt((this.options.noDataReceivedTimeout + '').trim()) * 1000;
+        const createDebug = options.createDebug ?? require('debug');
+        this.debug = createDebug('signalk:streams:tcp');
+        this.debug(`noDataReceivedTimeout:${this.noDataReceivedTimeout}`);
+        this.debugData = createDebug('signalk:streams:tcp-data');
+    }
+    pipe(pipeTo) {
+        if (this.options.outEvent) {
+            this.options.app.on(this.options.outEvent, (d) => {
+                if (this.tcpStream) {
+                    this.debug('sending %s', d);
+                    this.tcpStream.write(d);
+                    setImmediate(() => {
+                        this.options.app.emit('connectionwrite', {
+                            providerId: this.options.providerId
+                        });
+                    });
+                }
+            });
+        }
+        const stdOutEvent = this.options.toStdout;
+        if (stdOutEvent) {
+            const events = Array.isArray(stdOutEvent) ? stdOutEvent : [stdOutEvent];
+            for (const stdEvent of events) {
+                this.options.app.on(stdEvent, (d) => {
+                    if (this.tcpStream) {
+                        this.tcpStream.write(d + '\r\n');
+                        this.debug('event %s sending %s', stdEvent, d);
+                    }
+                });
+            }
+        }
+        this.reconnector = (0, reconnect_core_1.default)((opts) => {
+            return net_1.default.connect(opts);
+        })({ maxDelay: 5 * 1000 }, (tcpStream) => {
+            if (!isNaN(this.noDataReceivedTimeout)) {
+                tcpStream.setTimeout(this.noDataReceivedTimeout);
+                this.debug(`Setting socket idle timeout ${this.options.host}:${this.options.port} ${this.noDataReceivedTimeout}`);
+                tcpStream.on('timeout', () => {
+                    this.debug(`Idle timeout, closing socket ${this.options.host}:${this.options.port}`);
+                    tcpStream.end();
+                });
+            }
+            tcpStream.on('data', (data) => {
+                if (this.debugData.enabled) {
+                    this.debugData(data.toString());
+                }
+                this.write(data);
+            });
+        })
+            .on('connect', (con) => {
+            this.tcpStream = con;
+            const msg = `Connected to ${this.options.host} ${this.options.port}`;
+            this.options.app.setProviderStatus(this.options.providerId, msg);
+            this.debug(msg);
+        })
+            .on('reconnect', (n, delay) => {
+            const msg = `Reconnect ${this.options.host} ${this.options.port} retry ${n} delay ${delay}`;
+            this.options.app.setProviderError(this.options.providerId, msg);
+            this.debug(msg);
+        })
+            .on('disconnect', () => {
+            this.tcpStream = undefined;
+            this.debug(`Disconnected ${this.options.host} ${this.options.port}`);
+        })
+            .on('error', (err) => {
+            let msg;
+            if (err.message && err.message.length > 0) {
+                msg = err.message;
+            }
+            else if (err.errors) {
+                msg = err.errors.toString();
+            }
+            else {
+                msg = err.toString();
+            }
+            this.options.app.setProviderError(this.options.providerId, msg);
+            console.error('TcpProvider:' + msg);
+        })
+            .connect(this.options);
+        super.pipe(pipeTo);
+        return pipeTo;
+    }
+    end() {
+        if (this.reconnector) {
+            this.reconnector.disconnect();
+        }
+        return this;
+    }
+    _transform(data, encoding, callback) {
+        callback(null, data);
+    }
+}
+exports.default = TcpStream;

package/dist/tcpserver.d.ts

@@ -0,0 +1,14 @@
+import { Transform, TransformCallback } from 'stream';
+interface TcpServerOptions {
+    app: {
+        on(event: string, cb: (...args: any[]) => void): void;
+    };
+}
+export default class TcpServer extends Transform {
+    private readonly options;
+    constructor(options: TcpServerOptions);
+    pipe<T extends NodeJS.WritableStream>(pipeTo: T): T;
+    _transform(data: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
+}
+export {};
+//# sourceMappingURL=tcpserver.d.ts.map

package/dist/tcpserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcpserver.d.ts","sourceRoot":"","sources":["../src/tcpserver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAErD,UAAU,gBAAgB;IACxB,GAAG,EAAE;QAEH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAA;KACtD,CAAA;CACF;AAED,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,SAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;gBAE9B,OAAO,EAAE,gBAAgB;IAKrC,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAKnD,UAAU,CACR,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI;CAGR"}

package/dist/tcpserver.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+class TcpServer extends stream_1.Transform {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    pipe(pipeTo) {
+        this.options.app.on('tcpserver0183data', (d) => this.write(d));
+        return super.pipe(pipeTo);
+    }
+    _transform(data, encoding, callback) {
+        callback(null, data);
+    }
+}
+exports.default = TcpServer;