@signalk/streams 5.1.4 → 6.0.0

package/dist/mdns-ws.js

@@ -0,0 +1,144 @@
+"use strict";
+/*
+ * Copyright 2016 Teppo Kurki <teppo.kurki@iki.fi>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const client_1 = require("@signalk/client");
+class MdnsWs extends stream_1.Transform {
+    options;
+    selfHost;
+    selfPort;
+    remoteServers = {};
+    debug;
+    dataDebug;
+    handleContext;
+    signalkClient;
+    constructor(options) {
+        super({ objectMode: true });
+        this.options = options;
+        this.selfHost = options.app.config.getExternalHostname() + '.';
+        this.selfPort = options.app.config.getExternalPort();
+        this.remoteServers[this.selfHost + ':' + this.selfPort] = {};
+        const deltaStreamBehaviour = options.subscription ? 'none' : 'all';
+        const createDebug = options.createDebug ?? require('debug');
+        this.debug = createDebug('signalk:streams:mdns-ws');
+        this.dataDebug = createDebug('signalk:streams:mdns-ws-data');
+        this.debug(`deltaStreamBehaviour:${deltaStreamBehaviour}`);
+        this.handleContext = () => { };
+        if (options.selfHandling === 'manualSelf') {
+            if (options.remoteSelf) {
+                this.debug(`Using manual remote self ${options.remoteSelf}`);
+                this.handleContext = (delta) => {
+                    if (delta.context === options.remoteSelf) {
+                        delete delta.context;
+                    }
+                };
+            }
+            else {
+                console.error('Manual self handling speficied but no remoteSelf configured');
+            }
+        }
+        if (options.ignoreServers) {
+            options.ignoreServers.forEach((s) => {
+                this.remoteServers[s] = {};
+            });
+        }
+        if (options.host && options.port) {
+            this.signalkClient = new client_1.Client({
+                hostname: options.host,
+                port: options.port,
+                useTLS: options.type === 'wss',
+                reconnect: true,
+                notifications: false,
+                autoConnect: false,
+                deltaStreamBehaviour,
+                rejectUnauthorized: !(options.selfsignedcert === true),
+                wsKeepaliveInterval: 10
+            });
+            this.connectClient(this.signalkClient);
+        }
+        else {
+            this.options.app.setProviderError(this.options.providerId, 'This connection is deprecated and must be deleted');
+        }
+    }
+    connectClient(client) {
+        client
+            .connect()
+            .then(() => {
+            this.options.app.setProviderStatus(this.options.providerId, `ws connection connected to ${client.options.hostname}:${client.options.port}`);
+            console.log(`ws connection connected to ${client.options.hostname}:${client.options.port}`);
+            if (this.options.selfHandling === 'useRemoteSelf') {
+                client
+                    .API()
+                    .then((api) => api.get('/self'))
+                    .then((selfFromServer) => {
+                    this.debug(`Mapping context ${selfFromServer} to self (empty context)`);
+                    this.handleContext = (delta) => {
+                        if (delta.context === selfFromServer) {
+                            delete delta.context;
+                        }
+                    };
+                })
+                    .catch((err) => {
+                    console.error('Error retrieving self from remote server');
+                    console.error(err);
+                });
+            }
+            this.remoteServers[client.options.hostname + ':' + client.options.port] = client;
+            if (this.options.subscription) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(this.options.subscription);
+                }
+                catch (ex) {
+                    const error = ex;
+                    this.options.app.setProviderError(this.options.providerId, `unable to parse subscription json: ${this.options.subscription}: ${error.message}`);
+                    console.error(`unable to parse subscription json: ${this.options.subscription}: ${error.message}`);
+                    return;
+                }
+                if (!Array.isArray(parsed)) {
+                    parsed = [parsed];
+                }
+                ;
+                parsed.forEach((sub, idx) => {
+                    this.debug('sending subscription %j', sub);
+                    client.subscribe(sub, String(idx));
+                });
+            }
+        })
+            .catch((err) => {
+            this.options.app.setProviderError(this.options.providerId, err.message);
+            console.error(err.message);
+        });
+        client.on('delta', (data) => {
+            if (data && data.updates) {
+                this.handleContext(data);
+                if (this.dataDebug.enabled) {
+                    this.dataDebug(JSON.stringify(data));
+                }
+                data.updates.forEach((update) => {
+                    update['$source'] =
+                        `${this.options.providerId}.${client.options.hostname}:${client.options.port}`;
+                });
+            }
+            this.push(data);
+        });
+    }
+    _transform(chunk, encoding, done) {
+        done();
+    }
+}
+exports.default = MdnsWs;

package/dist/multiplexedlog.d.ts

@@ -0,0 +1,3 @@
+import autodetect from './autodetect';
+export default autodetect;
+//# sourceMappingURL=multiplexedlog.d.ts.map

package/dist/multiplexedlog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplexedlog.d.ts","sourceRoot":"","sources":["../src/multiplexedlog.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAA;AAErC,eAAe,UAAU,CAAA"}

package/dist/multiplexedlog.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const autodetect_1 = __importDefault(require("./autodetect"));
+exports.default = autodetect_1.default;

package/dist/n2k-signalk.d.ts

@@ -0,0 +1,39 @@
+import { Transform, TransformCallback } from 'stream';
+import type { DeltaCache } from './types';
+interface N2kFilter {
+    source?: string;
+    pgn?: string;
+}
+interface N2kToSignalKOptions {
+    app: {
+        selfContext: string;
+        isNmea2000OutAvailable: boolean;
+        deltaCache: DeltaCache;
+        on(event: string, cb: (...args: any[]) => void): void;
+        emit(event: string, ...args: unknown[]): void;
+        handleMessage(id: string, delta: object): void;
+    };
+    providerId: string;
+    filters?: N2kFilter[];
+    filtersEnabled?: boolean;
+    useCanName?: boolean;
+    [key: string]: unknown;
+}
+interface N2kMessage {
+    src: string | number;
+    pgn: string | number;
+    timestamp: string;
+}
+export default class N2kToSignalK extends Transform {
+    private readonly sourceMeta;
+    private readonly notifications;
+    private readonly options;
+    private readonly app;
+    private readonly filters?;
+    private readonly n2kMapper;
+    constructor(options: N2kToSignalKOptions);
+    private isFiltered;
+    _transform(chunk: N2kMessage, encoding: BufferEncoding, done: TransformCallback): void;
+}
+export {};
+//# sourceMappingURL=n2k-signalk.d.ts.map

package/dist/n2k-signalk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n2k-signalk.d.ts","sourceRoot":"","sources":["../src/n2k-signalk.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAErD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,UAAU,SAAS;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,UAAU,mBAAmB;IAC3B,GAAG,EAAE;QACH,WAAW,EAAE,MAAM,CAAA;QACnB,sBAAsB,EAAE,OAAO,CAAA;QAC/B,UAAU,EAAE,UAAU,CAAA;QAEtB,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,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAC/C,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAA;IACrB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AAoCD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,SAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAGxB;IACN,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,OAAO,EAAE,mBAAmB;IAwFxC,OAAO,CAAC,UAAU;IAiBlB,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,iBAAiB,GACtB,IAAI;CA0FR"}

package/dist/n2k-signalk.js

@@ -0,0 +1,180 @@
+"use strict";
+/*
+ * Copyright 2014-2015 Fabian Tollenaar <fabian@starting-point.nl>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const n2k_signalk_1 = require("@signalk/n2k-signalk");
+class N2kToSignalK extends stream_1.Transform {
+    sourceMeta = {};
+    notifications = {};
+    options;
+    app;
+    filters;
+    n2kMapper;
+    constructor(options) {
+        super({ objectMode: true });
+        this.options = options;
+        this.app = options.app;
+        if (options.filters && options.filtersEnabled) {
+            this.filters = options.filters.filter((f) => (f.source && f.source.length) || (f.pgn && f.pgn.length));
+        }
+        this.n2kMapper = new n2k_signalk_1.N2kMapper({
+            ...options,
+            sendMetaData: true
+        });
+        const n2kOutEvent = 'nmea2000JsonOut';
+        this.n2kMapper.on('n2kOut', (pgn) => this.app.emit('nmea2000JsonOut', pgn));
+        this.n2kMapper.on('n2kSourceMetadata', (n2k, meta) => {
+            const src = Number(n2k.src);
+            const existing = this.sourceMeta[src] ?? {};
+            this.sourceMeta[src] = { ...existing, ...meta };
+            const delta = {
+                context: this.app.selfContext,
+                updates: [
+                    {
+                        source: {
+                            ...this.sourceMeta[src],
+                            label: this.options.providerId,
+                            type: 'NMEA2000',
+                            pgn: Number(n2k.pgn),
+                            src: n2k.src.toString()
+                        },
+                        timestamp: n2k.timestamp.substring(0, 10) +
+                            'T' +
+                            n2k.timestamp.substring(11, n2k.timestamp.length),
+                        values: []
+                    }
+                ]
+            };
+            this.app.deltaCache.setSourceDelta(`${this.options.providerId}.${n2k.src}`, delta);
+        });
+        this.n2kMapper.on('n2kSourceMetadataTimeout', (pgn, src) => {
+            if (Number(pgn) === 60928) {
+                console.warn(`n2k-signalk: unable to detect can name for src ${src}`);
+                const srcNum = Number(src);
+                const meta = this.sourceMeta[srcNum];
+                if (meta) {
+                    meta.unknowCanName = true;
+                }
+            }
+        });
+        this.n2kMapper.on('n2kSourceChanged', (src, from, to) => {
+            console.warn(`n2k-signalk: address ${src} changed from ${from} ${to}`);
+            const srcNum = Number(src);
+            if (this.sourceMeta[srcNum]) {
+                delete this.sourceMeta[srcNum];
+            }
+        });
+        if (this.app.isNmea2000OutAvailable) {
+            this.n2kMapper.n2kOutIsAvailable(this.app, n2kOutEvent);
+        }
+        else {
+            this.app.on('nmea2000OutAvailable', () => this.n2kMapper.n2kOutIsAvailable(this.app, n2kOutEvent));
+        }
+    }
+    isFiltered(source) {
+        if (!this.filters) {
+            return undefined;
+        }
+        return this.filters.find((filter) => {
+            const sFilter = this.options.useCanName ? source.canName : source.src;
+            return ((!filter.source ||
+                filter.source.length === 0 ||
+                filter.source === sFilter) &&
+                (!filter.pgn ||
+                    filter.pgn.length === 0 ||
+                    String(filter.pgn) === String(source.pgn)));
+        });
+    }
+    _transform(chunk, encoding, done) {
+        try {
+            const delta = this.n2kMapper.toDelta(chunk);
+            const src = Number(chunk.src);
+            if (!this.sourceMeta[src]) {
+                this.sourceMeta[src] = {};
+            }
+            const firstUpdate = delta?.updates[0];
+            if (delta &&
+                firstUpdate &&
+                firstUpdate.values.length > 0 &&
+                !this.isFiltered(firstUpdate.source)) {
+                if (!this.options.useCanName) {
+                    delete firstUpdate.source.canName;
+                }
+                const canName = firstUpdate.source.canName;
+                if (this.options.useCanName &&
+                    !canName &&
+                    !this.sourceMeta[src]?.unknowCanName) {
+                    done();
+                    return;
+                }
+                delta.updates.forEach((update) => {
+                    update.values.forEach((kv) => {
+                        if (kv.path && kv.path.startsWith('notifications.')) {
+                            const pathNotifs = this.notifications[kv.path];
+                            if (kv.value.state === 'normal' &&
+                                pathNotifs &&
+                                pathNotifs[src]) {
+                                clearInterval(pathNotifs[src].interval);
+                                delete pathNotifs[src];
+                            }
+                            else if (kv.value.state !== 'normal') {
+                                if (!this.notifications[kv.path]) {
+                                    this.notifications[kv.path] = {};
+                                }
+                                const currentPathNotifs = this.notifications[kv.path];
+                                if (!currentPathNotifs[src]) {
+                                    const interval = setInterval(() => {
+                                        const entry = currentPathNotifs[src];
+                                        if (entry && Date.now() - entry.lastTime > 10000) {
+                                            const copy = JSON.parse(JSON.stringify(kv));
+                                            copy.value.state = 'normal';
+                                            const normalDelta = {
+                                                context: delta.context,
+                                                updates: [
+                                                    {
+                                                        source: update.source,
+                                                        values: [copy]
+                                                    }
+                                                ]
+                                            };
+                                            delete currentPathNotifs[src];
+                                            clearInterval(interval);
+                                            this.app.handleMessage(this.options.providerId, normalDelta);
+                                        }
+                                    }, 5000);
+                                    currentPathNotifs[src] = {
+                                        lastTime: Date.now(),
+                                        interval
+                                    };
+                                }
+                                else {
+                                    currentPathNotifs[src].lastTime = Date.now();
+                                }
+                            }
+                        }
+                    });
+                });
+                this.push(delta);
+            }
+        }
+        catch (ex) {
+            console.error(ex);
+        }
+        done();
+    }
+}
+exports.default = N2kToSignalK;

package/dist/n2kAnalyzer.d.ts

@@ -0,0 +1,19 @@
+import { Transform, TransformCallback } from 'stream';
+interface N2kAnalyzerOptions {
+    app: {
+        emit(event: string, ...args: unknown[]): void;
+    };
+    analyzerOutEvent?: string;
+    [key: string]: unknown;
+}
+export default class N2kAnalyzer extends Transform {
+    private readonly analyzerOutEvent;
+    private readonly analyzerProcess;
+    private pipeTo;
+    constructor(options: N2kAnalyzerOptions);
+    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
+    pipe<T extends NodeJS.WritableStream>(pipeTo: T): T;
+    end(): this;
+}
+export {};
+//# sourceMappingURL=n2kAnalyzer.d.ts.map

package/dist/n2kAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n2kAnalyzer.d.ts","sourceRoot":"","sources":["../src/n2kAnalyzer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAY,MAAM,QAAQ,CAAA;AAC/D,UAAU,kBAAkB;IAC1B,GAAG,EAAE;QACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;KAC9C,CAAA;IACD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAOD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,SAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAc;IAC9C,OAAO,CAAC,MAAM,CAAwB;gBAE1B,OAAO,EAAE,kBAAkB;IA0CvC,UAAU,CACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,iBAAiB,GACtB,IAAI;IAKP,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAKnD,GAAG,IAAI,IAAI;CAQZ"}

package/dist/n2kAnalyzer.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const readline_1 = require("readline");
+const stream_1 = require("stream");
+class N2kAnalyzer extends stream_1.Transform {
+    analyzerOutEvent;
+    analyzerProcess;
+    pipeTo = null;
+    constructor(options) {
+        super({ objectMode: true });
+        this.analyzerOutEvent = options.analyzerOutEvent ?? 'N2KAnalyzerOut';
+        if (process.platform === 'win32') {
+            this.analyzerProcess = (0, child_process_1.spawn)('cmd', ['/c', 'analyzer -json -si -camel']);
+        }
+        else {
+            this.analyzerProcess = (0, child_process_1.spawn)('sh', ['-c', 'analyzer -json -si -camel']);
+        }
+        this.analyzerProcess.stderr?.on('data', (data) => {
+            console.error(data.toString());
+        });
+        this.analyzerProcess.on('close', (code) => {
+            console.error('Analyzer process exited with code ' + code);
+        });
+        const linereader = (0, readline_1.createInterface)(this.analyzerProcess.stdout, this.analyzerProcess.stdin);
+        linereader.on('line', (data) => {
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed.version) {
+                    console.log('Connected to analyzer v' + parsed.version);
+                    return;
+                }
+                this.push(parsed);
+                options.app.emit(this.analyzerOutEvent, parsed);
+            }
+            catch (ex) {
+                console.error(data);
+                if (ex instanceof Error) {
+                    console.error(ex.stack);
+                }
+            }
+        });
+    }
+    _transform(chunk, encoding, done) {
+        this.analyzerProcess.stdin?.write(chunk.toString() + '\n');
+        done();
+    }
+    pipe(pipeTo) {
+        this.pipeTo = pipeTo;
+        return super.pipe(pipeTo);
+    }
+    end() {
+        console.log('end, killing child analyzer process');
+        this.analyzerProcess.kill();
+        if (this.pipeTo) {
+            this.pipeTo.end();
+        }
+        return this;
+    }
+}
+exports.default = N2kAnalyzer;

package/dist/nmea0183-signalk.d.ts

@@ -0,0 +1,33 @@
+import { Transform, TransformCallback } from 'stream';
+import type { CreateDebug } from './types';
+interface Nmea0183ToSignalKOptions {
+    app: {
+        emit(event: string, ...args: unknown[]): void;
+        signalk: {
+            emit(event: string, ...args: unknown[]): void;
+        };
+    };
+    providerId: string;
+    createDebug?: CreateDebug;
+    suppress0183event?: boolean;
+    appendChecksum?: boolean;
+    sentenceEvent?: string | string[];
+    [key: string]: unknown;
+}
+interface TimestampedChunk {
+    line: string;
+    timestamp: number | string;
+}
+export default class Nmea0183ToSignalK extends Transform {
+    private readonly debug;
+    private readonly parser;
+    private readonly n2kParser;
+    private readonly n2kState;
+    private readonly app;
+    private readonly sentenceEvents;
+    private readonly appendChecksumFlag;
+    constructor(options: Nmea0183ToSignalKOptions);
+    _transform(chunk: string | Buffer | TimestampedChunk, encoding: BufferEncoding, done: TransformCallback): void;
+}
+export {};
+//# sourceMappingURL=nmea0183-signalk.d.ts.map

package/dist/nmea0183-signalk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nmea0183-signalk.d.ts","sourceRoot":"","sources":["../src/nmea0183-signalk.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAKrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,UAAU,wBAAwB;IAChC,GAAG,EAAE;QACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QAC7C,OAAO,EAAE;YAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;SAAE,CAAA;KAC3D,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B;AAWD,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,SAAS;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiC;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,OAAO,EAAE,wBAAwB;IAuB7C,UAAU,CACR,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,EACzC,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,iBAAiB,GACtB,IAAI;CAyDR"}

package/dist/nmea0183-signalk.js

@@ -0,0 +1,105 @@
+"use strict";
+/*
+ * Copyright 2017 Signal K & Fabian Tollenaar <fabian@signalk.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 nmea0183_signalk_1 = __importDefault(require("@signalk/nmea0183-signalk"));
+const nmea0183_utilities_1 = require("@signalk/nmea0183-utilities");
+const n2k_signalk_1 = require("@signalk/n2k-signalk");
+const canboatjs_1 = require("@canboat/canboatjs");
+class Nmea0183ToSignalK extends stream_1.Transform {
+    debug;
+    parser;
+    n2kParser;
+    n2kState = {};
+    app;
+    sentenceEvents;
+    appendChecksumFlag;
+    constructor(options) {
+        super({ objectMode: true });
+        this.debug = (options.createDebug ?? require('debug'))('signalk:streams:nmea0183-signalk');
+        this.parser = new nmea0183_signalk_1.default(options);
+        this.n2kParser = new canboatjs_1.FromPgn(options);
+        this.app = options.app;
+        this.appendChecksumFlag = options.appendChecksum ?? false;
+        this.sentenceEvents = options.suppress0183event ? [] : ['nmea0183'];
+        if (options.sentenceEvent) {
+            if (Array.isArray(options.sentenceEvent)) {
+                this.sentenceEvents = this.sentenceEvents.concat(options.sentenceEvent);
+            }
+            else {
+                this.sentenceEvents.push(options.sentenceEvent);
+            }
+        }
+    }
+    _transform(chunk, encoding, done) {
+        let sentence;
+        let timestamp = null;
+        if (chunk &&
+            typeof chunk === 'object' &&
+            !Buffer.isBuffer(chunk) &&
+            typeof chunk.line === 'string') {
+            const tsChunk = chunk;
+            timestamp = new Date(Number(tsChunk.timestamp));
+            sentence = tsChunk.line.trim();
+        }
+        else if (Buffer.isBuffer(chunk)) {
+            sentence = chunk.toString().trim();
+        }
+        else if (chunk && typeof chunk === 'string') {
+            sentence = chunk.trim();
+        }
+        try {
+            if (sentence !== undefined) {
+                if (this.appendChecksumFlag) {
+                    sentence = (0, nmea0183_utilities_1.appendChecksum)(sentence);
+                }
+                this.sentenceEvents.forEach((eventName) => {
+                    this.app.emit(eventName, sentence);
+                    this.app.signalk.emit(eventName, sentence);
+                });
+                let delta = null;
+                if (this.n2kParser.isN2KOver0183(sentence)) {
+                    const pgn = this.n2kParser.parseN2KOver0183(sentence, () => { });
+                    if (pgn) {
+                        delta = (0, n2k_signalk_1.toDelta)(pgn, this.n2kState, {
+                            sendMetaData: true
+                        });
+                    }
+                }
+                else {
+                    delta = this.parser.parse(sentence);
+                }
+                if (delta !== null) {
+                    if (timestamp !== null) {
+                        delta.updates.forEach((update) => {
+                            update.timestamp = timestamp;
+                        });
+                    }
+                    this.push(delta);
+                }
+            }
+        }
+        catch (e) {
+            this.debug(e);
+        }
+        done();
+    }
+}
+exports.default = Nmea0183ToSignalK;

package/dist/nullprovider.d.ts

@@ -0,0 +1,5 @@
+import { Transform } from 'stream';
+export default class NullProvider extends Transform {
+    constructor();
+}
+//# sourceMappingURL=nullprovider.d.ts.map

package/dist/nullprovider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullprovider.d.ts","sourceRoot":"","sources":["../src/nullprovider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAElC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,SAAS;;CAIlD"}

package/dist/nullprovider.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+class NullProvider extends stream_1.Transform {
+    constructor() {
+        super({ objectMode: true });
+    }
+}
+exports.default = NullProvider;

package/dist/pigpio-seatalk.d.ts

@@ -0,0 +1,19 @@
+import Execute from './execute';
+import type { CreateDebug } from './types';
+interface PigpioSeatalkOptions {
+    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;
+    createDebug?: CreateDebug;
+    gpio?: string;
+    gpioInvert?: string;
+}
+export default class PigpioSeatalk extends Execute {
+    constructor(options: PigpioSeatalkOptions);
+}
+export {};
+//# sourceMappingURL=pigpio-seatalk.d.ts.map

package/dist/pigpio-seatalk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pigpio-seatalk.d.ts","sourceRoot":"","sources":["../src/pigpio-seatalk.ts"],"names":[],"mappings":"AAuBA,OAAO,OAAO,MAAM,WAAW,CAAA;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AA6D1C,UAAU,oBAAoB;IAC5B,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,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,OAAO;gBACpC,OAAO,EAAE,oBAAoB;CAQ1C"}