Export all interfaces

.prettierrc.ts

@@ -0,0 +1,19 @@
+import { type Config } from "prettier";
+
+const config: Config = {
+  plugins: ["@trivago/prettier-plugin-sort-imports"],
+  trailingComma: "none",
+  printWidth: 120,
+  importOrder: [
+    "<BUILTIN_MODULES>",
+    "<THIRD_PARTY_MODULES>",
+    "(?:services|components|contexts|pages|libs|types)/(.*)$",
+    "^[./].*\\.(?:ts|tsx)$",
+    "\\.(?:scss|css)$",
+    "^[./]"
+  ],
+  importOrderSeparation: true,
+  importOrderSortSpecifiers: true
+};
+
+export default config;

package.json

@@ -1,6 +1,7 @@
 {
   "name": "@hamradio/aprs",
-  "version": "1.1.3",
+  "type": "module",
+  "version": "1.2.0",
   "description": "APRS (Automatic Packet Reporting System) protocol support for Typescript",
   "keywords": [
     "APRS",
@@ -40,9 +41,11 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^10.0.3",
     "globals": "^17.4.0",
+    "prettier": "^3.8.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.0",

src/frame.types.ts

@@ -57,7 +57,7 @@ export enum DataType {
   ThirdParty = "}",
 
   // Invalid/Test Data
-  InvalidOrTest = ",",
+  InvalidOrTest = ","
 }
 
 export interface ISymbol {
@@ -77,12 +77,39 @@ export interface IPosition {
   course?: number; // Course in degrees
   symbol?: ISymbol;
   comment?: string;
+  /**
+   * Optional reported radio range in miles (from RNG token in comment)
+   */
+  range?: number;
+  /**
+   * Optional power/height/gain information from PHG token
+   * PHG format: PHGpphhgg (pp=power, hh=height, gg=gain) as numeric values
+   */
+  phg?: IPowerHeightGain;
+  /** Direction-finding / DF information parsed from comment tokens */
+  dfs?: IDirectionFinding;
 
   toString(): string; // Return combined position representation (e.g., "lat,lon,alt")
   toCompressed?(): CompressedPosition; // Optional method to convert to compressed format
   distanceTo?(other: IPosition): number; // Optional method to calculate distance to another position
 }
 
+export interface IPowerHeightGain {
+  power?: number; // Transmit power in watts
+  height?: number; // Antenna height in meters
+  gain?: number; // Antenna gain in dBi
+  directivity?: number | "omni" | "unknown"; // Optional directivity pattern (numeric code or "omni")
+}
+
+export interface IDirectionFinding {
+  bearing?: number; // Direction finding bearing in degrees
+  strength?: number; // Relative signal strength (0-9)
+  height?: number; // Antenna height in meters
+  gain?: number; // Antenna gain in dBi
+  quality?: number; // Signal quality or other metric (0-9)
+  directivity?: number | "omni" | "unknown"; // Optional directivity pattern (numeric code or "omni")
+}
+
 export interface ITimestamp {
   day?: number; // Day of month (DHM format)
   month?: number; // Month (MDHM format)
@@ -197,12 +224,7 @@ export interface QueryPayload {
   target?: string; // Target callsign or area
 }
 
-export type TelemetryVariant =
-  | "data"
-  | "parameters"
-  | "unit"
-  | "coefficients"
-  | "bitsense";
+export type TelemetryVariant = "data" | "parameters" | "unit" | "coefficients" | "bitsense";
 
 // Telemetry Data Payload
 export interface TelemetryDataPayload {

src/index.ts

@@ -1,16 +1,14 @@
 export { Frame, Address, Timestamp } from "./frame";
 
-export {
-  type IAddress,
-  type IFrame,
-  DataType as DataTypeIdentifier,
-} from "./frame.types";
+export { type IAddress, type IFrame, DataType as DataTypeIdentifier } from "./frame.types";
 
 export {
   DataType,
   type ISymbol,
   type IPosition,
   type ITimestamp,
+  type IPowerHeightGain,
+  type IDirectionFinding,
   type PositionPayload,
   type CompressedPosition,
   type MicEPayload,
@@ -33,7 +31,7 @@ export {
   type DFReportPayload,
   type BasePayload,
   type Payload,
-  type DecodedFrame,
+  type DecodedFrame
 } from "./frame.types";
 
 export {
@@ -43,5 +41,5 @@ export {
   feetToMeters,
   metersToFeet,
   celsiusToFahrenheit,
-  fahrenheitToCelsius,
+  fahrenheitToCelsius
 } from "./parser";

src/parser.ts

@@ -15,9 +15,7 @@ export const base91ToNumber = (str: string): number => {
     const digit = charCode - 33; // Base91 uses chars 33-123 (! to {)
 
     if (digit < 0 || digit >= base) {
-      throw new Error(
-        `Invalid Base91 character: '${str[i]}' (code ${charCode})`,
-      );
+      throw new Error(`Invalid Base91 character: '${str[i]}' (code ${charCode})`);
     }
 
     value = value * base + digit;
@@ -62,6 +60,15 @@ export const feetToMeters = (feet: number): number => {
   return feet * FEET_TO_METERS;
 };
 
+/**
+ * Convert miles to meters.
+ * @param miles number of miles
+ * @returns meters
+ */
+export const milesToMeters = (miles: number): number => {
+  return miles * 1609.344;
+};
+
 /**
  * Convert altitude from meters to feet.
  *

src/position.ts

@@ -1,4 +1,4 @@
-import { IPosition, ISymbol } from "./frame.types";
+import { IDirectionFinding, IPosition, IPowerHeightGain, ISymbol } from "./frame.types";
 
 export class Symbol implements ISymbol {
   table: string; // Symbol table identifier
@@ -10,9 +10,7 @@ export class Symbol implements ISymbol {
         this.code = table[1];
         this.table = table[0];
       } else {
-        throw new Error(
-          `Invalid symbol format: '${table}' (expected 2 characters if code is not provided)`,
-        );
+        throw new Error(`Invalid symbol format: '${table}' (expected 2 characters if code is not provided)`);
       }
     } else {
       this.table = table;
@@ -34,6 +32,9 @@ export class Position implements IPosition {
   course?: number; // Course in degrees
   symbol?: Symbol;
   comment?: string;
+  range?: number;
+  phg?: IPowerHeightGain;
+  dfs?: IDirectionFinding;
 
   constructor(data: Partial<IPosition>) {
     this.latitude = data.latitude ?? 0;
@@ -48,6 +49,9 @@ export class Position implements IPosition {
       this.symbol = new Symbol(data.symbol.table, data.symbol.code);
     }
     this.comment = data.comment;
+    this.range = data.range;
+    this.phg = data.phg;
+    this.dfs = data.dfs;
   }
 
   public toString(): string {

test/frame.capabilities.test.ts

@@ -1,11 +1,8 @@
-import { describe, it, expect } from "vitest";
-import { Frame } from "../src/frame";
-import {
-  DataType,
-  type Payload,
-  type StationCapabilitiesPayload,
-} from "../src/frame.types";
 import { Dissected } from "@hamradio/packet";
+import { describe, expect, it } from "vitest";
+
+import { Frame } from "../src/frame";
+import { DataType, type Payload, type StationCapabilitiesPayload } from "../src/frame.types";
 
 describe("Frame.decodeCapabilities", () => {
   it("parses comma separated capabilities", () => {

test/frame.extras.test.ts

@@ -0,0 +1,97 @@
+import type { Dissected, Field, Segment } from "@hamradio/packet";
+import { describe, expect, it } from "vitest";
+
+import { Frame } from "../src/frame";
+import type { PositionPayload } from "../src/frame.types";
+
+describe("APRS extras test vectors (RNG / PHG / CSE/DDD / SPD / DFS)", () => {
+  it("parses PHG from position with messaging (spec vector 1)", () => {
+    const raw = "NOCALL>APZRAZ,qAS,PA2RDK-14:=5154.19N/00627.77E>PHG500073 de NOCALL";
+    const frame = Frame.fromString(raw);
+    const res = frame.decode(true) as { payload: PositionPayload | null; structure: Dissected };
+    const { payload } = res;
+
+    expect(payload).not.toBeNull();
+    expect(payload!.position.phg).toBeDefined();
+    // PHG500073 parsed per spec: p=5 -> 25 W, h='0' -> 10 ft, g='0' -> 0 dBi
+    expect(payload!.position.phg!.power).toBe(25);
+    expect(payload!.position.phg!.height).toBeCloseTo(3.048, 3);
+    expect(payload!.position.phg!.gain).toBe(0);
+  });
+
+  it("parses PHG token with hyphen separators (spec vector 2)", () => {
+    const raw = "NOCALL>APRS,TCPIP*,qAC,NINTH:;P-PA3RD  *061000z5156.26NP00603.29E#PHG0210DAPNET";
+    const frame = Frame.fromString(raw);
+    const res = frame.decode(true) as { payload: PositionPayload | null; structure: Dissected };
+    const { payload, structure } = res;
+
+    expect(payload).not.toBeNull();
+    // Use a spec PHG example: PHG0210 -> p=0 -> power 0 W, h=2 -> 40 ft
+    expect(payload!.position.phg).toBeDefined();
+    expect(payload!.position.phg!.power).toBe(0);
+    expect(payload!.position.phg!.height).toBeCloseTo(12.192, 3);
+
+    const commentSeg = structure.find((s) => /comment/i.test(String(s.name))) as Segment | undefined;
+    expect(commentSeg).toBeDefined();
+    const fields = (commentSeg!.fields ?? []) as Field[];
+    const hasPHG = fields.some((f) => f.name === "PHG");
+    expect(hasPHG).toBe(true);
+  });
+
+  it("parses DFS token with long numeric strength", () => {
+    const raw = "N0CALL>APRS,WIDE1-1:!4500.00N/07000.00W#DFS2360/Your Comment";
+    const frame = Frame.fromString(raw);
+    const res = frame.decode(true) as { payload: PositionPayload | null; structure: Dissected };
+    const { payload, structure } = res;
+
+    expect(payload).not.toBeNull();
+    expect(payload!.position.dfs).toBeDefined();
+    // DFSshgd: strength is single-digit s value (here '2')
+    expect(payload!.position.dfs!.strength).toBe(2);
+
+    const commentSeg = structure.find((s) => /comment/i.test(String(s.name))) as Segment | undefined;
+    expect(commentSeg).toBeDefined();
+    const fieldsDFS = (commentSeg!.fields ?? []) as Field[];
+    const hasDFS = fieldsDFS.some((f) => f.name === "DFS");
+    expect(hasDFS).toBe(true);
+  });
+
+  it("parses course/speed in DDD/SSS form and altitude /A=", () => {
+    const raw = "N0CALL>APRS,WIDE1-1:!4500.00N/07000.00W>090/045/A=001234";
+    const frame = Frame.fromString(raw);
+    const res = frame.decode(true) as { payload: PositionPayload | null; structure: Dissected };
+    const { payload, structure } = res;
+
+    expect(payload).not.toBeNull();
+    expect(payload!.position.course).toBe(90);
+    // Speed is converted from knots to km/h
+    expect(payload!.position.speed).toBeCloseTo(45 * 1.852, 3);
+    // Altitude 001234 ft -> meters
+    expect(Math.round((payload!.position.altitude || 0) / 0.3048)).toBe(1234);
+
+    const commentSeg = structure.find((s) => /comment/i.test(String(s.name))) as Segment | undefined;
+    expect(commentSeg).toBeDefined();
+    const fieldsCSE = (commentSeg!.fields ?? []) as Field[];
+    const hasCSE = fieldsCSE.some((f) => f.name === "CSE/SPD");
+    expect(hasCSE).toBe(true);
+  });
+
+  it("parses combined tokens: DDD/SSS PHG and DFS", () => {
+    const raw = "N0CALL>APRS,WIDE1-1:!4500.00N/07000.00W>090/045PHG5132/DFS2132";
+    const frame = Frame.fromString(raw);
+    const res = frame.decode(true) as { payload: PositionPayload | null; structure: Dissected };
+    const { payload, structure } = res;
+
+    expect(payload).not.toBeNull();
+    expect(payload!.position.course).toBe(90);
+    expect(payload!.position.speed).toBeCloseTo(45 * 1.852, 3);
+    expect(payload!.position.phg).toBeDefined();
+    expect(payload!.position.dfs).toBeDefined();
+    expect(payload!.position.dfs!.strength).toBe(2);
+
+    const commentSeg = structure.find((s) => /comment/i.test(String(s.name))) as Segment | undefined;
+    expect(commentSeg).toBeDefined();
+    const fieldsCombined = (commentSeg!.fields ?? []) as Field[];
+    expect(fieldsCombined.some((f) => ["CSE/SPD", "PHG", "DFS"].includes(String(f.name)))).toBe(true);
+  });
+});

test/frame.query.test.ts

@@ -1,6 +1,7 @@
+import { Dissected } from "@hamradio/packet";
 import { expect } from "vitest";
 import { describe, it } from "vitest";
-import { Dissected } from "@hamradio/packet";
+
 import { Frame } from "../src/frame";
 import { DataType, QueryPayload } from "../src/frame.types";
 

test/frame.rawgps.test.ts

@@ -1,12 +1,12 @@
-import { describe, it, expect } from "vitest";
+import { Dissected } from "@hamradio/packet";
+import { describe, expect, it } from "vitest";
+
 import { Frame } from "../src/frame";
 import { DataType, type RawGPSPayload } from "../src/frame.types";
-import { Dissected } from "@hamradio/packet";
 
 describe("Raw GPS decoding", () => {
   it("decodes simple NMEA sentence as raw-gps payload", () => {
-    const sentence =
-      "GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A";
+    const sentence = "GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A";
     const frameStr = `SRC>DEST:$${sentence}`;
 
     const f = Frame.parse(frameStr);
@@ -21,8 +21,7 @@ describe("Raw GPS decoding", () => {
   });
 
   it("returns structure when requested", () => {
-    const sentence =
-      "GPGGA,092750.000,5321.6802,N,00630.3372,W,1,08,1.0,73.0,M,0.0,M,,*6A";
+    const sentence = "GPGGA,092750.000,5321.6802,N,00630.3372,W,1,08,1.0,73.0,M,0.0,M,,*6A";
     const frameStr = `SRC>DEST:$${sentence}`;
 
     const f = Frame.parse(frameStr);
@@ -40,9 +39,7 @@ describe("Raw GPS decoding", () => {
     expect(result.structure).toBeDefined();
     const rawSection = result.structure.find((s) => s.name === "raw-gps");
     expect(rawSection).toBeDefined();
-    const posSection = result.structure.find(
-      (s) => s.name === "raw-gps-position",
-    );
+    const posSection = result.structure.find((s) => s.name === "raw-gps-position");
     expect(posSection).toBeDefined();
   });
 });

test/frame.telemetry.test.ts

@@ -1,14 +1,15 @@
 import { describe, it } from "vitest";
+import { expect } from "vitest";
+
+import { Frame } from "../src/frame";
 import {
+  DataType,
+  TelemetryBitSensePayload,
+  TelemetryCoefficientsPayload,
   TelemetryDataPayload,
   TelemetryParameterPayload,
-  TelemetryUnitPayload,
-  TelemetryCoefficientsPayload,
-  TelemetryBitSensePayload,
-  DataType,
+  TelemetryUnitPayload
 } from "../src/frame.types";
-import { Frame } from "../src/frame";
-import { expect } from "vitest";
 
 describe("Frame decode - Telemetry", () => {
   it("decodes telemetry data payload", () => {

test/frame.test.ts

@@ -1,16 +1,17 @@
+import { Dissected, FieldType } from "@hamradio/packet";
 import { describe, expect, it } from "vitest";
+
 import { Address, Frame, Timestamp } from "../src/frame";
 import {
-  type Payload,
-  type PositionPayload,
-  type ObjectPayload,
-  type StatusPayload,
+  DataType,
   type ITimestamp,
   type MessagePayload,
-  DataType,
   MicEPayload,
+  type ObjectPayload,
+  type Payload,
+  type PositionPayload,
+  type StatusPayload
 } from "../src/frame.types";
-import { Dissected, FieldType } from "@hamradio/packet";
 
 // Address parsing: split by method
 describe("Address.parse", () => {
@@ -49,8 +50,7 @@ describe("Frame.constructor", () => {
 // Frame properties / instance methods
 describe("Frame.getDataTypeIdentifier", () => {
   it("returns @ for position identifier", () => {
-    const data =
-      'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
+    const data = 'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
     const frame = Frame.fromString(data);
     expect(frame.getDataTypeIdentifier()).toBe("@");
   });
@@ -76,8 +76,7 @@ describe("Frame.getDataTypeIdentifier", () => {
 
 describe("Frame.decode (basic)", () => {
   it("should call decode and return position payload", () => {
-    const data =
-      'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
+    const data = 'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
     const frame = Frame.fromString(data);
     const decoded = frame.decode() as PositionPayload;
     expect(decoded).not.toBeNull();
@@ -99,7 +98,7 @@ describe("Frame.decode (basic)", () => {
       { data: "CALL>APRS:$GPRMC,...", type: "$" },
       { data: "CALL>APRS:<IGATE,MSG_CNT", type: "<" },
       { data: "CALL>APRS:{01", type: "{" },
-      { data: "CALL>APRS:}W1AW>APRS:test", type: "}" },
+      { data: "CALL>APRS:}W1AW>APRS:test", type: "}" }
     ];
     for (const testCase of testCases) {
       const frame = Frame.fromString(testCase.data);
@@ -112,53 +111,70 @@ describe("Frame.decode (basic)", () => {
 // Static functions
 describe("Frame.fromString", () => {
   it("parses APRS position frame (test vector 1)", () => {
-    const data =
-      'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
+    const data = 'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
     const result = Frame.fromString(data);
     expect(result.source).toEqual({
       call: "NOCALL",
       ssid: "1",
-      isRepeated: false,
+      isRepeated: false
     });
     expect(result.destination).toEqual({
       call: "APRS",
       ssid: "",
-      isRepeated: false,
+      isRepeated: false
     });
     expect(result.path).toHaveLength(1);
     expect(result.path[0]).toEqual({
       call: "WIDE1",
       ssid: "1",
-      isRepeated: false,
+      isRepeated: false
     });
     expect(result.payload).toBe('@092345z/:*E";qZ=OMRC/A=088132Hello World!');
   });
 
+  it("parses APRS position frame without messaging (test vector 3)", () => {
+    const data = "N0CALL-7>APLRT1,qAO,DG2EAZ-10:!/4CkRP&-V>76Q";
+    const result = Frame.fromString(data);
+    expect(result.source).toEqual({
+      call: "N0CALL",
+      ssid: "7",
+      isRepeated: false
+    });
+    expect(result.destination).toEqual({
+      call: "APLRT1",
+      ssid: "",
+      isRepeated: false
+    });
+    expect(result.path).toHaveLength(2);
+
+    const payload = result.decode(false);
+    expect(payload).not.toBeNull();
+  });
+
   it("parses APRS Mic-E frame with repeated digipeater (test vector 2)", () => {
     const data = "N83MZ>T2TQ5U,WA1PLE-4*:`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3";
     const result = Frame.fromString(data);
     expect(result.source).toEqual({
       call: "N83MZ",
       ssid: "",
-      isRepeated: false,
+      isRepeated: false
     });
     expect(result.destination).toEqual({
       call: "T2TQ5U",
       ssid: "",
-      isRepeated: false,
+      isRepeated: false
     });
     expect(result.path).toHaveLength(1);
     expect(result.path[0]).toEqual({
       call: "WA1PLE",
       ssid: "4",
-      isRepeated: true,
+      isRepeated: true
     });
     expect(result.payload).toBe("`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3");
   });
 
   it("parses frame with multiple path elements", () => {
-    const data =
-      "KB1ABC-5>APRS,WIDE1-1,WIDE2-2*,IGATE:!4903.50N/07201.75W-Test";
+    const data = "KB1ABC-5>APRS,WIDE1-1,WIDE2-2*,IGATE:!4903.50N/07201.75W-Test";
     const result = Frame.fromString(data);
     expect(result.source.call).toBe("KB1ABC");
     expect(result.path).toHaveLength(3);
@@ -174,16 +190,12 @@ describe("Frame.fromString", () => {
 
   it("throws for frame without route separator", () => {
     const data = "NOCALL-1>APRS";
-    expect(() => Frame.fromString(data)).toThrow(
-      "APRS: invalid frame, no route separator found",
-    );
+    expect(() => Frame.fromString(data)).toThrow("APRS: invalid frame, no route separator found");
   });
 
   it("throws for frame with invalid addresses", () => {
     const data = "NOCALL:payload";
-    expect(() => Frame.fromString(data)).toThrow(
-      "APRS: invalid addresses in route",
-    );
+    expect(() => Frame.fromString(data)).toThrow("APRS: invalid addresses in route");
   });
 });
 
@@ -257,9 +269,7 @@ describe("Frame.decodeMessage", () => {
     const textSection = res.structure.find((s) => s.name === "text");
     expect(recipientSection).toBeDefined();
     expect(textSection).toBeDefined();
-    expect(new TextDecoder().decode(recipientSection!.data).trim()).toBe(
-      "KB1ABC",
-    );
+    expect(new TextDecoder().decode(recipientSection!.data).trim()).toBe("KB1ABC");
     expect(new TextDecoder().decode(textSection!.data)).toBe("Test via spec");
   });
 });
@@ -291,8 +301,7 @@ describe("Frame.decodeObject", () => {
 
 describe("Frame.decodePosition", () => {
   it("decodes position with timestamp and compressed format", () => {
-    const data =
-      'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
+    const data = 'NOCALL-1>APRS,WIDE1-1:@092345z/:*E";qZ=OMRC/A=088132Hello World!';
     const frame = Frame.fromString(data);
     const decoded = frame.decode() as PositionPayload;
     expect(decoded).not.toBeNull();
@@ -324,8 +333,7 @@ describe("Frame.decodeStatus", () => {
       structure: Dissected;
     };
     expect(res.payload).not.toBeNull();
-    if (res.payload?.type !== DataType.Status)
-      throw new Error("expected status payload");
+    if (res.payload?.type !== DataType.Status) throw new Error("expected status payload");
     const payload = res.payload as StatusPayload & { timestamp?: ITimestamp };
     expect(payload.text).toBe("Testing status");
     expect(payload.maidenhead).toBe("FN20");
@@ -423,7 +431,7 @@ describe("Timestamp.toDate", () => {
     if (futureHours < 24) {
       const ts = new Timestamp(futureHours, 0, "HMS", {
         seconds: 0,
-        zulu: true,
+        zulu: true
       });
       const date = ts.toDate();
 
@@ -440,7 +448,7 @@ describe("Timestamp.toDate", () => {
       const ts = new Timestamp(12, 0, "MDHM", {
         month: futureMonth + 1,
         day: 1,
-        zulu: false,
+        zulu: false
       });
       const date = ts.toDate();
 
@@ -455,8 +463,7 @@ describe("Timestamp.toDate", () => {
 describe("Frame.decodeMicE", () => {
   describe("Basic Mic-E frames", () => {
     it("should decode a basic Mic-E packet (current format)", () => {
-      const data =
-        "N83MZ>T2TQ5U,WA1PLE-4*:`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3";
+      const data = "N83MZ>T2TQ5U,WA1PLE-4*:`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3";
       const frame = Frame.fromString(data);
       const decoded = frame.decode() as MicEPayload;
 
@@ -795,16 +802,13 @@ describe("Frame.decodeMicE", () => {
 
       expect(() => frame.decode()).not.toThrow();
       const decoded = frame.decode() as MicEPayload;
-      expect(decoded === null || decoded?.type === DataType.MicECurrent).toBe(
-        true,
-      );
+      expect(decoded === null || decoded?.type === DataType.MicECurrent).toBe(true);
     });
   });
 
   describe("Real-world test vectors", () => {
     it("should decode real Mic-E packet from test vector 2", () => {
-      const data =
-        "N83MZ>T2TQ5U,WA1PLE-4*:`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3";
+      const data = "N83MZ>T2TQ5U,WA1PLE-4*:`c.l+@&'/'\"G:} KJ6TMS|!:&0'p|!w#f!|3";
       const frame = Frame.fromString(data);
       const decoded = frame.decode() as MicEPayload;
 
@@ -842,15 +846,11 @@ describe("Packet dissection with sections", () => {
     expect(routingSection?.fields).toBeDefined();
     expect(routingSection?.fields?.length).toBeGreaterThan(0);
 
-    const sourceField = routingSection?.fields?.find(
-      (a) => a.name === "source address",
-    );
+    const sourceField = routingSection?.fields?.find((a) => a.name === "source address");
     expect(sourceField).toBeDefined();
     expect(sourceField?.length).toBeGreaterThan(0);
 
-    const destField = routingSection?.fields?.find(
-      (a) => a.name === "destination address",
-    );
+    const destField = routingSection?.fields?.find((a) => a.name === "destination address");
     expect(destField).toBeDefined();
     expect(destField?.length).toBeGreaterThan(0);
   });
@@ -869,9 +869,7 @@ describe("Packet dissection with sections", () => {
     expect(result.structure).toBeDefined();
     expect(result.structure?.length).toBeGreaterThan(0);
 
-    const positionSection = result.structure?.find(
-      (s) => s.name === "position",
-    );
+    const positionSection = result.structure?.find((s) => s.name === "position");
     expect(positionSection).toBeDefined();
     expect(positionSection?.data?.byteLength).toBe(19);
     expect(positionSection?.fields).toBeDefined();
@@ -897,20 +895,16 @@ describe("Packet dissection with sections", () => {
       structure: Dissected;
     };
 
-    expect(result.payload?.type).toBe(
-      DataType.PositionWithTimestampWithMessaging,
-    );
+    expect(result.payload?.type).toBe(DataType.PositionWithTimestampWithMessaging);
 
-    const timestampSection = result.structure?.find(
-      (s) => s.name === "timestamp",
-    );
+    const timestampSection = result.structure?.find((s) => s.name === "timestamp");
     expect(timestampSection).toBeDefined();
     expect(timestampSection?.data?.byteLength).toBe(7);
     expect(timestampSection?.fields?.map((a) => a.name)).toEqual([
       "day (DD)",
       "hour (HH)",
       "minute (MM)",
-      "timezone indicator",
+      "timezone indicator"
     ]);
   });
 
@@ -922,13 +916,9 @@ describe("Packet dissection with sections", () => {
       structure: Dissected;
     };
 
-    expect(result.payload?.type).toBe(
-      DataType.PositionWithTimestampWithMessaging,
-    );
+    expect(result.payload?.type).toBe(DataType.PositionWithTimestampWithMessaging);
 
-    const positionSection = result.structure?.find(
-      (s) => s.name === "position",
-    );
+    const positionSection = result.structure?.find((s) => s.name === "position");
     expect(positionSection).toBeDefined();
     expect(positionSection?.data?.byteLength).toBe(13);
 
@@ -979,9 +969,7 @@ describe("Frame.decodeMessage", () => {
     const textSection = res.structure.find((s) => s.name === "text");
     expect(recipientSection).toBeDefined();
     expect(textSection).toBeDefined();
-    expect(new TextDecoder().decode(recipientSection!.data).trim()).toBe(
-      "KB1ABC",
-    );
+    expect(new TextDecoder().decode(recipientSection!.data).trim()).toBe("KB1ABC");
     expect(new TextDecoder().decode(textSection!.data)).toBe("Test via spec");
   });
 });
@@ -998,8 +986,7 @@ describe("Frame.decoding: object and status", () => {
     expect(res).toHaveProperty("payload");
     expect(res.payload).not.toBeNull();
 
-    if (res.payload?.type !== DataType.Object)
-      throw new Error("expected object payload");
+    if (res.payload?.type !== DataType.Object) throw new Error("expected object payload");
 
     const payload = res.payload as ObjectPayload & { timestamp?: ITimestamp };
 
@@ -1029,8 +1016,7 @@ describe("Frame.decoding: object and status", () => {
     expect(res).toHaveProperty("payload");
     expect(res.payload).not.toBeNull();
 
-    if (res.payload?.type !== DataType.Status)
-      throw new Error("expected status payload");
+    if (res.payload?.type !== DataType.Status) throw new Error("expected status payload");
 
     const payload = res.payload as StatusPayload & { timestamp?: ITimestamp };
 

test/frame.userdefined.test.ts

@@ -1,5 +1,6 @@
-import { describe, it, expect } from "vitest";
 import { Dissected } from "@hamradio/packet";
+import { describe, expect, it } from "vitest";
+
 import { Frame } from "../src/frame";
 import { DataType, type UserDefinedPayload } from "../src/frame.types";
 
@@ -27,9 +28,7 @@ describe("Frame.decodeUserDefined", () => {
     expect(res.payload.data).toBe("Hello world");
 
     const raw = res.structure.find((s) => s.name === "user-defined");
-    const typeSection = res.structure.find(
-      (s) => s.name === "user-packet-type",
-    );
+    const typeSection = res.structure.find((s) => s.name === "user-packet-type");
     const dataSection = res.structure.find((s) => s.name === "user-data");
     expect(raw).toBeDefined();
     expect(typeSection).toBeDefined();

test/frame.weather.test.ts

@@ -1,7 +1,8 @@
-import { describe, it, expect } from "vitest";
+import { Dissected } from "@hamradio/packet";
+import { describe, expect, it } from "vitest";
+
 import { Frame } from "../src/frame";
 import { DataType, WeatherPayload } from "../src/frame.types";
-import { Dissected } from "@hamradio/packet";
 
 describe("Frame decode - Weather", () => {
   it("parses weather with timestamp, wind, temp, rain, humidity and pressure", () => {

test/parser.test.ts

@@ -1,12 +1,13 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
+
 import {
   base91ToNumber,
-  knotsToKmh,
-  kmhToKnots,
-  feetToMeters,
-  metersToFeet,
   celsiusToFahrenheit,
   fahrenheitToCelsius,
+  feetToMeters,
+  kmhToKnots,
+  knotsToKmh,
+  metersToFeet
 } from "../src/parser";
 
 describe("parser utilities", () => {