@airframes/acars-decoder 1.2.1 → 1.3.2

package/dist/plugins/Label_80.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+// Airline Defined
+// 3N01 POSRPT
+class Label_80 extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-80';
+        this.descriptions = {
+            ALT: 'Altitude',
+            DWND: 'Wind Direction',
+            ETA: 'Estimated Time of Arrival',
+            FOB: 'Fuel on Board',
+            FL: 'Flight Level',
+            HDG: 'Heading',
+            MCH: 'Aircraft Speed',
+            NWYP: 'Next Waypoint',
+            POS: 'Aircraft Position',
+            SAT: 'Static Air Temperature',
+            SWND: 'Window Speed',
+            TAS: 'True Airspeed',
+            WYP: 'Waypoint',
+        };
+    }
+    qualifiers() {
+        return {
+            labels: ['80'],
+            preambles: ['3N01 POSRPT'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.formatted.description = 'Airline Defined Position Report';
+        const parts = message.text.split('\n');
+        let posRptRegex = /^3N01 POSRPT \d\d\d\d\/\d\d (?<orig>\w+)\/(?<dest>\w+) \.(?<tail>[\w-]+)(\/(?<agate>.+) (?<sta>\w+:\w+))*/; // eslint-disable-line max-len
+        let results = parts[0].match(posRptRegex);
+        if (results && results.length > 0) {
+            decodeResult.raw.origin = results.groups.orig;
+            decodeResult.formatted.items.push({
+                type: 'origin',
+                code: 'ORG',
+                label: 'Origin',
+                value: `${results.groups.orig}`,
+            });
+            decodeResult.raw.destination = results.groups.dest;
+            decodeResult.formatted.items.push({
+                type: 'destination',
+                code: 'DST',
+                label: 'Destination',
+                value: `${results.groups.dest}`,
+            });
+            decodeResult.raw.tail = results.groups.tail;
+            decodeResult.formatted.items.push({
+                type: 'tail',
+                label: 'Tail',
+                value: `${results.groups.tail}`,
+            });
+            if (results.groups.agate) {
+                decodeResult.raw.arrival_gate = results.groups.agate;
+                decodeResult.formatted.items.push({
+                    type: 'arrival_gate',
+                    code: 'ARG',
+                    label: 'Arrival Gate',
+                    value: `${results.groups.agate}`,
+                });
+                decodeResult.raw.scheduled_time_of_arrival = results.groups.sta;
+                decodeResult.formatted.items.push({
+                    type: 'scheduled_time_of_arrival',
+                    code: 'STA',
+                    label: 'Scheduled Time of Arrival',
+                    value: `${results.groups.sta}`,
+                });
+            }
+            posRptRegex = /\/(?<field>\w+)\s(?<value>[\w\+\-:\.]+)\s*/gi; // eslint-disable-line no-useless-escape
+            // console.log('Regex:', posRptRegex);
+            const remainingParts = parts.slice(1);
+            // console.log("Remaining Parts:", remainingParts);
+            for (const part of remainingParts) { // eslint-disable-line no-restricted-syntax
+                // console.log('Part:', part);
+                const matches = part.matchAll(posRptRegex);
+                // console.log('Matches:', matches);
+                for (const match of matches) { // eslint-disable-line no-restricted-syntax
+                    // console.log('Match:', match);
+                    switch (match.groups.field) {
+                        case 'ALT': {
+                            decodeResult.raw.altitude = match.groups.value;
+                            decodeResult.formatted.items.push({
+                                type: 'altitude',
+                                code: 'ALT',
+                                label: this.descriptions[match.groups.field],
+                                value: `${decodeResult.raw.altitude} feet`,
+                            });
+                            break;
+                        }
+                        case 'DWND': {
+                            decodeResult.raw.wind_direction = Number(match.groups.value);
+                            decodeResult.formatted.items.push({
+                                type: 'wind_direction',
+                                code: 'DWND',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.wind_direction,
+                            });
+                            break;
+                        }
+                        case 'FL': {
+                            decodeResult.raw.flight_level = match.groups.value;
+                            decodeResult.formatted.items.push({
+                                type: 'flight_level',
+                                code: 'FL',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.flight_level,
+                            });
+                            break;
+                        }
+                        case 'FOB': {
+                            decodeResult.raw.fuel_on_board = match.groups.value;
+                            decodeResult.formatted.items.push({
+                                type: 'fuel_on_board',
+                                code: 'FOB',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.fuel_on_board,
+                            });
+                            break;
+                        }
+                        case 'HDG': {
+                            decodeResult.raw.heading = Number(match.groups.value);
+                            decodeResult.formatted.items.push({
+                                type: 'heading',
+                                code: 'HDG',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.heading,
+                            });
+                            break;
+                        }
+                        case 'MCH': {
+                            decodeResult.raw.mach = match.groups.value / 1000;
+                            decodeResult.formatted.items.push({
+                                type: 'mach',
+                                code: 'MCH',
+                                label: this.descriptions[match.groups.field],
+                                value: `${decodeResult.raw.mach} Mach`,
+                            });
+                            break;
+                        }
+                        case 'NWYP': {
+                            decodeResult.raw.next_waypoint = match.groups.value;
+                            decodeResult.formatted.items.push({
+                                type: 'next_waypoint',
+                                code: 'NWYP',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.next_waypoint,
+                            });
+                            break;
+                        }
+                        case 'POS': {
+                            const posRegex = /^(?<latd>[NS])(?<lat>.+)(?<lngd>[EW])(?<lng>.+)/;
+                            const posResult = match.groups.value.match(posRegex);
+                            const latitude = (Number(posResult.groups.lat) / 100) * (posResult.groups.lngd === 'S' ? -1 : 1);
+                            const longitude = (Number(posResult.groups.lng) / 100) * (posResult.groups.lngd === 'W' ? -1 : 1);
+                            decodeResult.raw.aircraft_position = {
+                                latitude,
+                                longitude,
+                            };
+                            decodeResult.formatted.items.push({
+                                type: 'aircraft_position',
+                                code: 'POS',
+                                label: this.descriptions[match.groups.field],
+                                value: `${(Number(posResult.groups.lat) / 100).toPrecision(5)} ${posResult.groups.latd}, ${(Number(posResult.groups.lng) / 100).toPrecision(5)} ${posResult.groups.lngd}`,
+                            });
+                            break;
+                        }
+                        case 'SWND': {
+                            decodeResult.raw.wind_speed = Number(match.groups.value);
+                            decodeResult.formatted.items.push({
+                                type: 'wind_speed',
+                                code: 'SWND',
+                                label: this.descriptions[match.groups.field],
+                                value: decodeResult.raw.wind_speed,
+                            });
+                            break;
+                        }
+                        default: {
+                            if (match.groups.field != undefined) {
+                                const description = this.descriptions[match.groups.field] ? this.descriptions[match.groups.field] : 'Unknown';
+                                decodeResult.formatted.items.push({
+                                    type: match.groups.field,
+                                    code: match.groups.field,
+                                    label: description || `Unknown (${match.groups.field})`,
+                                    value: `${match.groups.value}`,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            decodeResult.decoded = true;
+            decodeResult.decodeLevel = 'partial';
+        }
+        return decodeResult;
+    }
+}
+exports.Label_80 = Label_80;
+exports.default = {};

package/dist/plugins/Label_8E.d.ts

@@ -0,0 +1,10 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_8E extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_8E.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+// ETA
+class Label_8E extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-8E';
+    }
+    qualifiers() {
+        return {
+            labels: ["8E"],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.formatted.description = 'ETA Report';
+        decodeResult.message = message;
+        // Style: EGSS,1618
+        // Match: arrival_icao,arrival_eta
+        const regex = /^(?<arrival_icao>\w{4}),(?<arrival_eta>\d{4})$/;
+        const results = message.text.match(regex);
+        if (results) {
+            if (options.debug) {
+                console.log(`Label 8E ETA: groups`);
+                console.log(results.groups);
+            }
+            decodeResult.raw.arrival_eta = new Date();
+            decodeResult.raw.arrival_eta.setUTCHours(results.groups.arrival_eta.substr(0, 2), results.groups.arrival_eta.substr(2, 2));
+            if (new Date().getUTCHours() > decodeResult.raw.arrival_eta.getUTCHours()) { // Check if ETA is in the past, which would imply it is for the next day
+                if (options.debug) {
+                    console.log("Label 8E: Moving ETA to subsequent day");
+                }
+                decodeResult.raw.arrival_eta.setDate(decodeResult.raw.arrival_eta.getDate() + 1);
+            }
+            decodeResult.formatted.items.push({
+                type: 'eta',
+                code: 'ETA',
+                label: 'Estimated Time of Arrival',
+                value: decodeResult.raw.arrival_eta.toGMTString(),
+            });
+            decodeResult.raw.arrival_icao = results.groups.arrival_icao;
+            decodeResult.formatted.items.push({
+                type: 'destination',
+                code: 'DST',
+                label: 'Destination',
+                value: decodeResult.raw.arrival_icao,
+            });
+        }
+        decodeResult.decoded = true;
+        decodeResult.decoder.decodeLevel = 'full';
+        return decodeResult;
+    }
+}
+exports.Label_8E = Label_8E;
+exports.default = {};

package/dist/plugins/Label_B6.d.ts

@@ -0,0 +1,11 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_B6_Forwardslash extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+        preambles: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_B6.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+// CPDLC
+class Label_B6_Forwardslash extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-b6-forwardslash';
+    }
+    qualifiers() {
+        return {
+            labels: ['B6'],
+            preambles: ['/'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.formatted.description = 'CPDLC Message';
+        decodeResult.message = message;
+        if (options.debug) {
+            console.log("CPDLC: " + message);
+        }
+        return decodeResult;
+    }
+}
+exports.Label_B6_Forwardslash = Label_B6_Forwardslash;
+exports.default = {};

package/dist/plugins/Label_ColonComma.d.ts

@@ -0,0 +1,10 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_ColonComma extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_ColonComma.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_ColonComma extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-colon-comma';
+    }
+    qualifiers() {
+        return {
+            labels: [':;'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.raw.frequency = Number(message.text) / 1000;
+        decodeResult.formatted.description = 'Aircraft Transceiver Frequency Change';
+        decodeResult.formatted.items.push({
+            type: 'frequency',
+            label: 'Frequency',
+            value: `${decodeResult.raw.frequency} MHz`,
+        });
+        decodeResult.decoded = true;
+        decodeResult.decoder.decodeLevel = 'full';
+        return decodeResult;
+    }
+}
+exports.Label_ColonComma = Label_ColonComma;
+exports.default = {};

package/dist/plugins/Label_H1.d.ts

@@ -0,0 +1,9 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_H1 extends DecoderPlugin {
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_H1.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_H1 extends DecoderPlugin_1.DecoderPlugin {
+    qualifiers() {
+        return {
+            labels: ['H1'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        // console.log('DECODER: H1 detected');
+        return decodeResult;
+    }
+}
+exports.Label_H1 = Label_H1;
+exports.default = {};

package/dist/plugins/Label_H1_M1BPOS.d.ts

@@ -0,0 +1,11 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_H1_M1BPOS extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+        preambles: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_H1_M1BPOS.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_H1_M1BPOS extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-h1-m1bpos';
+    }
+    qualifiers() {
+        return {
+            labels: ['H1'],
+            preambles: ['#M1BPOS'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        if (options.debug) {
+            console.log('DECODER: #M1BPOS detected');
+        }
+        const parts = message.text.replace('#M1BPOS', '').split('/');
+        const firstHalf = parts[0];
+        const secondHalf = parts[1];
+        const items = firstHalf.split(',');
+        const coordsRegex = /(?<lac>[NS])(?<la>.+)\s*(?<lnc>[EW])(?<ln>.+)/;
+        const results = items[0].match(coordsRegex);
+        if (results && results.length >= 4) {
+            decodeResult.raw.position = {
+                latitudeDirection: results.groups.lac,
+                latitude: (results.groups.la / 1000) * (results.groups.lac === 'S' ? -1 : 1),
+                longitudeDirection: results.groups.lnc,
+                longitude: (results.groups.ln / 1000) * (results.groups.lnc === 'W' ? -1 : 1),
+            };
+            let route = items.slice(1).filter((part) => !/^\d(.+)$/.test(part));
+            route = route.map((hop) => hop || '?');
+            decodeResult.raw.route = route;
+            decodeResult.formatted.description = 'Position Report';
+            decodeResult.formatted.items = {
+                coordinates: {
+                    label: 'Position',
+                    value: this.coordinateString(decodeResult.raw.position),
+                },
+                route: {
+                    label: 'Route',
+                    value: `${route.join(' > ')}`,
+                },
+            };
+            decodeResult.decoded = true;
+            decodeResult.decodeLevel = 'partial';
+        }
+        decodeResult.remaining.text = secondHalf;
+        return decodeResult;
+    }
+}
+exports.Label_H1_M1BPOS = Label_H1_M1BPOS;
+exports.default = {};

package/dist/plugins/Label_H1_M1BPRG.d.ts

@@ -0,0 +1,11 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_H1_M1BPRG extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+        preambles: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_H1_M1BPRG.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_H1_M1BPRG extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-h1-m1bprg';
+    }
+    qualifiers() {
+        return {
+            labels: ['H1'],
+            preambles: ['#M1BPRG'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        // console.log('DECODER: H1 #M1BPRG detected');
+        const parts = message.text.split('/');
+        for (const part of parts) { // eslint-disable-line no-restricted-syntax
+            if (part.includes('#M')) {
+                const regex = /#M(?<fms>\w+)PRG/;
+            }
+            if (part.includes('DT')) {
+                const regex = /DT(?<dest>\w+),(?<rway>.+),(?<fuel>.+),(?<eta>.+),(?<rem>.+)/;
+                const result = message.text.match(regex);
+                // console.log('DT result');
+                // console.log(result);
+            }
+            if (part.includes('FN')) {
+                const regex = /FN(?<flight>\w+)/;
+            }
+        }
+        return decodeResult;
+    }
+}
+exports.Label_H1_M1BPRG = Label_H1_M1BPRG;
+exports.default = {};

package/dist/plugins/Label_QP.d.ts

@@ -0,0 +1,10 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_QP extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_QP.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_QP extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-qp';
+    }
+    qualifiers() {
+        return {
+            labels: ['QP'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.raw.origin = message.text.substring(0, 4);
+        decodeResult.raw.destination = message.text.substring(4, 8);
+        decodeResult.raw.gate_out = message.text.substring(8, 12);
+        decodeResult.remaining.text = message.text.substring(12);
+        decodeResult.formatted.description = 'OUT Report';
+        decodeResult.formatted.items = [
+            {
+                type: 'origin',
+                code: 'ORG',
+                label: 'Origin',
+                value: decodeResult.raw.origin,
+            },
+            {
+                type: 'destination',
+                code: 'DST',
+                label: 'Destination',
+                value: decodeResult.raw.destination,
+            },
+            {
+                type: 'gate_out',
+                code: 'GOUT',
+                label: 'Gate OUT',
+                value: decodeResult.raw.gate_out,
+            }
+        ];
+        decodeResult.decoded = true;
+        if (decodeResult.remaining.text === "")
+            decodeResult.decoder.decodeLevel = 'full';
+        else
+            decodeResult.decoder.decodeLevel = 'partial';
+        return decodeResult;
+    }
+}
+exports.Label_QP = Label_QP;
+exports.default = {};

package/dist/plugins/Label_QQ.d.ts

@@ -0,0 +1,10 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_QQ extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;

package/dist/plugins/Label_QQ.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DecoderPlugin_1 = require("../DecoderPlugin");
+class Label_QQ extends DecoderPlugin_1.DecoderPlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'label-qq';
+    }
+    qualifiers() {
+        return {
+            labels: ['QQ'],
+        };
+    }
+    decode(message, options = {}) {
+        const decodeResult = this.defaultResult;
+        decodeResult.decoder.name = this.name;
+        decodeResult.raw.origin = message.text.substring(0, 4);
+        decodeResult.raw.destination = message.text.substring(4, 8);
+        decodeResult.raw.wheels_off = message.text.substring(8, 12);
+        decodeResult.remaining.text = message.text.substring(12);
+        decodeResult.formatted.description = 'OFF Report';
+        decodeResult.formatted.items = [
+            {
+                type: 'origin',
+                code: 'ORG',
+                label: 'Origin',
+                value: decodeResult.raw.origin,
+            },
+            {
+                type: 'destination',
+                code: 'DST',
+                label: 'Destination',
+                value: decodeResult.raw.destination,
+            },
+            {
+                type: 'wheels_off',
+                code: 'WOFF',
+                label: 'Wheels OFF',
+                value: decodeResult.raw.wheels_off,
+            }
+        ];
+        decodeResult.decoded = true;
+        if (decodeResult.remaining.text === "")
+            decodeResult.decoder.decodeLevel = 'full';
+        else
+            decodeResult.decoder.decodeLevel = 'partial';
+        return decodeResult;
+    }
+}
+exports.Label_QQ = Label_QQ;
+exports.default = {};

package/dist/plugins/Label_QR.d.ts

@@ -0,0 +1,10 @@
+import { DecoderPlugin } from '../DecoderPlugin';
+export declare class Label_QR extends DecoderPlugin {
+    name: string;
+    qualifiers(): {
+        labels: string[];
+    };
+    decode(message: any, options?: any): any;
+}
+declare const _default: {};
+export default _default;