@ham2k/lib-operation-data 0.8.4 → 0.10.0

package/README.md

@@ -1,3 +1,89 @@
 # lib-operation-data
 
 Basic data related to Amateur Radio operation, such as bands, modes, etc
+
+## Building
+
+This module is written in TypeScript and must be compiled before use.
+
+### Development
+
+To build the module during development:
+
+```bash
+npm run build
+```
+
+This will compile TypeScript source files from `src/` to JavaScript in `dist/`, generating:
+- JavaScript files (`.js`)
+- TypeScript declaration files (`.d.ts`)
+- Source maps (`.js.map`, `.d.ts.map`)
+
+### Testing
+
+Run the test suite:
+
+```bash
+npm test
+```
+
+## Distribution
+
+### Publishing to npm
+
+Before publishing, ensure the module is built:
+
+```bash
+npm run build
+```
+
+The `prepublishOnly` script will automatically run the build before publishing, so you can also just:
+
+```bash
+npm publish
+```
+
+### Package Structure
+
+- **Source files**: Located in `src/`
+- **Compiled output**: Generated in `dist/` (excluded from git)
+- **Type definitions**: Automatically generated in `dist/` alongside compiled JavaScript
+
+### Module Exports
+
+The package exports are configured in `package.json`:
+- **Main entry**: `dist/index.js`
+- **Type definitions**: `dist/index.d.ts`
+- **ESM support**: Configured for ES2020 modules
+
+## Usage
+
+### Installation
+
+```bash
+npm install @ham2k/lib-operation-data
+```
+
+### Import
+
+```javascript
+import { BANDS, bandForFrequency, modeForFrequency } from '@ham2k/lib-operation-data'
+```
+
+### TypeScript
+
+Type definitions are included, so TypeScript projects will automatically get type checking and autocomplete:
+
+```typescript
+import { BANDS, Band, bandForFrequency } from '@ham2k/lib-operation-data'
+
+const band: Band = bandForFrequency(14255) // '20m'
+```
+
+## Development Setup
+
+1. Clone the repository
+2. Install dependencies: `npm install`
+3. Make changes in `src/`
+4. Build: `npm run build`
+5. Test: `npm test`

package/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  extensionsToTreatAsEsm: ['.ts'],
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      useESM: true,
+      tsconfig: {
+        module: 'ES2020',
+        moduleResolution: 'node'
+      }
+    }]
+  },
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+    '^(\\.{1,2}/.*)\\.json$': '$1'
+  },
+  testMatch: ['**/*.spec.ts', '**/*.test.ts'],
+  transformIgnorePatterns: []
+}
+

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@ham2k/lib-operation-data",
-  "version": "0.8.4",
+  "version": "0.10.0",
   "type": "module",
-  "main": "./src/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "devDependencies": {
-    "jest": "~29",
-    "standard": "^17.0.0"
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.1",
+    "jest": "~30",
+    "standard": "^17.1.2",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
   },
   "scripts": {
-    "test": "node --experimental-vm-modules ./node_modules/.bin/jest"
+    "build": "tsc",
+    "test": "node --experimental-vm-modules ./node_modules/.bin/jest",
+    "prepublishOnly": "npm run build"
   },
   "standard": {
-    "env": [ "jest" ]
+    "env": [
+      "jest"
+    ]
   }
 }

package/src/data/bandPlans.json

@@ -10,7 +10,7 @@
       "segments": [
         { "name": "CW", "mhz": [1800, 1843], "mode": "CW" },
         { "name": "Data", "mhz": [1800, 1810], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [1840, 1843], "mode": "FT8" },
+        { "name": "FT8", "mhz": [1840, 1843], "mode": "FT8", "priority": 100 },
         { "name": "Phone", "mhz": [1843, 2000], "mode": "SSB", "submode": "LSB" },
         { "name": "Australia", "mhz": [1800, 1875], "mode": null, "countries": ["au"] }
       ]
@@ -20,9 +20,9 @@
       "segments": [
         { "name": "CW", "mhz": [3500, 3600], "mode": "CW" },
         { "name": "Phone", "mhz": [3535, 3800], "mode": "SSB", "submode": "LSB", "regions": [ 3 ] },
-        { "name": "FT8", "mhz": [3568, 3571], "mode": "FT8", "regions": [ 3 ] },
+        { "name": "FT8", "mhz": [3568, 3571], "mode": "FT8", "regions": [ 3 ], "priority": 100 },
         { "name": "Data", "mhz": [3570, 3600], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [3573, 3576], "mode": "FT8" },
+        { "name": "FT8", "mhz": [3573, 3576], "mode": "FT8", "priority": 100 },
         { "name": "Phone", "mhz": [3600, 4000], "mode": "SSB", "submode": "LSB" },
         { "name": "Australia", "mhz": [3500, 3800], "mode": null, "countries": ["au"] }
       ]
@@ -32,7 +32,7 @@
       "segments": [
         { "name": "60m Channel 1", "mhz": [5330.5, 5333.5] },
         { "name": "60m Channel 2", "mhz": [5346.5, 5349.5] },
-        { "name": "60m Channel 3", "mhz": [5357, 5360], "mode": "FT8" },
+        { "name": "60m Channel 3", "mhz": [5357, 5360], "mode": "FT8", "priority": 100 },
         { "name": "60m Channel 4", "mhz": [5371.5, 5373.5] },
         { "name": "60m Channel 5", "mhz": [5403.5, 5406.5] }
       ]
@@ -42,9 +42,9 @@
       "segments": [
         { "name": "CW", "mhz": [7000, 7060], "mode": "CW" },
         { "name": "CW", "mhz": [7000, 7125], "mode": "CW", "countries": [ "us" ] },
-        { "name": "FT4", "mhz": [7047.5, 7050.5], "mode": "FT4" },
+        { "name": "FT4", "mhz": [7047.5, 7050.5], "mode": "FT4", "priority": 100 },
         { "name": "Phone", "mhz": [7060, 7300], "mode": "SSB", "submode": "LSB" },
-        { "name": "FT8", "mhz": [7074, 7077], "mode": "FT8" },
+        { "name": "FT8", "mhz": [7074, 7077], "mode": "FT8", "priority": 100 },
         { "name": "Data", "mhz": [7080, 7125], "mode": "RTTY", "countries": [ "us" ] },
         { "name": "Phone", "mhz": [7125, 7300], "mode": "SSB", "submode": "LSB", "countries": [ "us" ] },
         { "name": "Australia", "mhz": [7000, 7300], "mode": null, "countries": ["au"] }
@@ -55,20 +55,20 @@
       "segments": [
         { "name": "CW", "mhz": [10100, 10150], "mode": "CW" },
         { "name": "Data", "mhz": [10130, 10140], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [10136, 10139], "mode": "FT8" },
-        { "name": "FT4", "mhz": [10140, 10143], "mode": "FT4" },
+        { "name": "FT8", "mhz": [10136, 10139], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [10140, 10143], "mode": "FT4", "priority": 100 },
         { "name": "Countries with no plan on 30m", "mhz": [10100, 10150], "mode": null, "countries": ["au", "za"] }
       ]
     },
     "20m": {
       "mhz": [14000, 14350],
       "segments": [
-        { "name": "CW", "mhz": [14000, 14101], "mode": "CW", "regions": [ 2 ] },
         { "name": "CW", "mhz": [14000, 14150], "mode": "CW" },
         { "name": "CW", "mhz": [14000, 14070], "mode": "CW", "regions": [ 1 ] },
+        { "name": "CW", "mhz": [14000, 14101], "mode": "CW", "regions": [ 2 ] },
         { "name": "Data", "mhz": [14070, 14095], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [14074, 14077], "mode": "FT8" },
-        { "name": "FT4", "mhz": [14080, 14083], "mode": "FT4" },
+        { "name": "FT8", "mhz": [14074, 14077], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [14080, 14083], "mode": "FT4", "priority": 100 },
         { "name": "Phone", "mhz": [14112, 14350], "mode": "SSB", "submode": "USB", "regions": [ 1, 2 ] },
         { "name": "Phone", "mhz": [14150, 14350], "mode": "SSB", "submode": "USB", "countries": [ "us" ] },
         { "name": "Australia", "mhz": [14000, 14350], "mode": null, "countries": ["au"] }
@@ -79,8 +79,8 @@
       "segments": [
         { "name": "CW", "mhz": [18068, 18110], "mode": "CW" },
         { "name": "Data", "mhz": [18100, 18105], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [18100, 18103], "mode": "FT8" },
-        { "name": "FT4", "mhz": [18104, 18107], "mode": "FT4" },
+        { "name": "FT8", "mhz": [18100, 18103], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [18104, 18107], "mode": "FT4", "priority": 100 },
         { "name": "Phone", "mhz": [18110, 18168], "mode": "SSB", "submode": "USB" },
         { "name": "Australia", "mhz": [18068, 18168], "mode": null, "countries": ["au"] }
       ]
@@ -90,8 +90,8 @@
       "segments": [
         { "name": "CW", "mhz": [21000, 21150], "mode": "CW" },
         { "name": "Data", "mhz": [21070, 21095], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [21074, 21077], "mode": "FT8" },
-        { "name": "FT4", "mhz": [21140, 21143], "mode": "FT4" },
+        { "name": "FT8", "mhz": [21074, 21077], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [21140, 21143], "mode": "FT4", "priority": 100 },
         { "name": "Phone", "mhz": [21150, 21450], "mode": "SSB", "submode": "USB" },
         { "name": "Australia", "mhz": [21000, 21450], "mode": null, "countries": ["au"] }
       ]
@@ -100,8 +100,8 @@
       "mhz": [24890, 24990],
       "segments": [
         { "name": "CW", "mhz": [24890, 24930], "mode": "CW" },
-        { "name": "FT8", "mhz": [24915, 24918], "mode": "FT8" },
-        { "name": "FT4", "mhz": [24919, 23922], "mode": "FT4" },
+        { "name": "FT8", "mhz": [24915, 24918], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [24919, 23922], "mode": "FT4", "priority": 100 },
         { "name": "Data", "mhz": [24920, 24925], "mode": "RTTY" },
         { "name": "Phone", "mhz": [24930, 24990], "mode": "SSB", "submode": "USB" },
         { "name": "Australia", "mhz": [24890, 24990], "mode": null, "countries": ["au"] }
@@ -112,8 +112,8 @@
       "segments": [
         { "name": "CW", "mhz": [28000, 28190], "mode": "CW" },
         { "name": "Data", "mhz": [28070, 28150], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [28074, 28077], "mode": "FT8" },
-        { "name": "FT4", "mhz": [28180, 28183], "mode": "FT4" },
+        { "name": "FT8", "mhz": [28074, 28077], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [28180, 28183], "mode": "FT4", "priority": 100 },
         { "name": "Beacons", "mhz": [28190, 28300] },
         { "name": "Phone SSB", "mhz": [28300, 29000], "mode": "SSB", "submode": "USB" },
         { "name": "AM", "mhz": [29000, 29200], "mode": "AM" },
@@ -132,9 +132,9 @@
         { "name": "Phone", "mhz": [51000, 51110], "mode": "SSB", "submode": "USB" },
         { "name": "FM", "mhz": [51110, 52100], "mode": "FM" },
         { "name": "FM", "mhz": [51110, 52100], "mode": "FM" },
-        { "name": "FT8", "mhz": [50313, 50316], "mode": "FT8" },
-        { "name": "FT4", "mhz": [50318, 50321], "mode": "FT4" },
-        { "name": "FT8", "mhz": [50323, 50326], "mode": "FT8" },
+        { "name": "FT8", "mhz": [50313, 50316], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [50318, 50321], "mode": "FT4", "priority": 100 },
+        { "name": "FT8", "mhz": [50323, 50326], "mode": "FT8", "priority": 100 },
         { "name": "Australia", "mhz": [50000, 54000], "mode": null, "countries": ["au"] }
       ]
     },
@@ -143,8 +143,8 @@
       "segments": [
         { "name": "CW", "mhz": [144000, 144100], "mode": "CW" },
         { "name": "Data", "mhz": [144100, 144200], "mode": "RTTY" },
-        { "name": "FT8", "mhz": [144174, 144177], "mode": "FT8" },
-        { "name": "FT8", "mhz": [144170, 144173], "mode": "FT4" },
+        { "name": "FT8", "mhz": [144174, 144177], "mode": "FT8", "priority": 100 },
+        { "name": "FT4", "mhz": [144170, 144173], "mode": "FT4", "priority": 100 },
         { "name": "Phone", "mhz": [144200, 144275], "mode": "SSB", "submode": "USB" },
         { "name": "FM", "mhz": [144300, 148000], "mode": "FM" }
       ]

package/src/{index.js → index.ts}

@@ -1,2 +1,3 @@
 export * from './lib/bands'
 export * from './lib/modes'
+

package/src/lib/{bands.js → bands.ts}

@@ -32,22 +32,24 @@ export const BANDS = [
   '1mm',
   'submm',
   'other'
-]
+] as const
 
-export const HF_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m']
-export const VHF_BANDS = ['6m', '5m', '4m', '2m', '1.25m']
-export const UHF_BANDS = ['70cm', '33cm', '23cm', '13cm']
-export const SHF_BANDS = ['9cm', '6cm', '3cm', '1.25cm']
-export const EHF_BANDS = ['6mm', '4mm', '2mm', '2.5mm', '1mm', 'submm']
+export type Band = typeof BANDS[number]
 
-export const POPULAR_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm']
-export const CONTEST_BANDS = ['160m', '80m', '40m', '20m', '15m', '10m']
+export const HF_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m'] as const
+export const VHF_BANDS = ['6m', '5m', '4m', '2m', '1.25m'] as const
+export const UHF_BANDS = ['70cm', '33cm', '23cm', '13cm'] as const
+export const SHF_BANDS = ['9cm', '6cm', '3cm', '1.25cm'] as const
+export const EHF_BANDS = ['6mm', '4mm', '2mm', '2.5mm', '1mm', 'submm'] as const
 
-export function bandForFrequency (freq) {
+export const POPULAR_BANDS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm'] as const
+export const CONTEST_BANDS = ['160m', '80m', '40m', '20m', '15m', '10m'] as const
+
+export function bandForFrequency(freq: number): Band {
   return bandForExactFrequencyInMHz(freq) ?? bandForExactFrequencyInMHz(freq * 1000) ?? 'other'
 }
 
-function bandForExactFrequencyInMHz (freq) {
+function bandForExactFrequencyInMHz(freq: number): Band | undefined {
   if (freq >= 130 && freq <= 140) return '2190m'
   else if (freq >= 450 && freq <= 499) return '630m'
   else if (freq >= 500 && freq <= 505) return '560m'
@@ -83,7 +85,7 @@ function bandForExactFrequencyInMHz (freq) {
   else return undefined
 }
 
-export function frequencyForBand(band, mode) {
+export function frequencyForBand(band: Band, mode?: string): number | undefined {
   if (band === '2190m') return 135.7
   else if (band === '630m') return 472
   else if (band === '560m') return 501
@@ -169,3 +171,4 @@ export function frequencyForBand(band, mode) {
   else if (band === 'submm') return 300000000
   else return undefined
 }
+

package/src/lib/{modes.spec.js → modes.spec.ts}

@@ -12,6 +12,11 @@ describe('modeForFrequency', () => {
     expect(modeForFrequency(14140, { ituRegion: 2 })).toEqual('SSB')
   })
 
+  it('should handle different priorities', () => {
+    // ituRegion 2 should make CW be the match for 14074, but priority 100 for FT8 should make FT8 the match
+    expect(modeForFrequency(14074, { ituRegion: 2 })).toEqual('FT8')
+  })
+
   // The current bandplan data does not have any entity-specific segments
   // TODO: mock data for this test
   // it('should handle different bandplans for different entities', () => {
@@ -26,3 +31,4 @@ describe('modeForFrequency', () => {
   })
 
 })
+

package/src/lib/{modes.js → modes.ts}

@@ -1,10 +1,13 @@
 import BandPlans from '../data/bandPlans.json'
+import type { BandPlansData, SegmentWithMetadata, ModeForFrequencyOptions } from '../types'
 
 export const SUPER_MODES = [
   'CW',
   'PHONE',
   'DATA'
-]
+] as const
+
+export type SuperMode = typeof SUPER_MODES[number]
 
 export const MAIN_MODES = [
   'CW',
@@ -14,7 +17,9 @@ export const MAIN_MODES = [
   'FT8',
   'FT4',
   'RTTY'
-]
+] as const
+
+export type MainMode = typeof MAIN_MODES[number]
 
 export const POPULAR_MODES = [
   'CW',
@@ -42,7 +47,9 @@ export const POPULAR_MODES = [
   'PSK',
   'SSTV',
   'WSPR',
-]
+] as const
+
+export type PopularMode = typeof POPULAR_MODES[number]
 
 export const ADIF_MODES = [
   'AM',
@@ -91,9 +98,11 @@ export const ADIF_MODES = [
   'VOI',
   'WINMOR',
   'WSPR'
-]
+] as const
 
-export const ADIF_SUBMODES = {
+export type AdifMode = typeof ADIF_MODES[number]
+
+export const ADIF_SUBMODES: Record<string, readonly string[]> = {
   'CHIP': ['CHIP64', 'CHIP128'],
   'DIGITALVOICE': ['C4FM', 'DMR', 'DSTAR', 'FREEDV', 'M17'],
   'DOMINO': ['DOM-M', 'DOM4', 'DOM5', 'DOM8', 'DOM11', 'DOM16', 'DOM22', 'DOM44', 'DOM88', 'DOMINOEX', 'DOMINOF'],
@@ -116,18 +125,18 @@ export const ADIF_SUBMODES = {
   'THOR': ['THOR-M', 'THOR4', 'THOR5', 'THOR8', 'THOR11', 'THOR16', 'THOR22', 'THOR25X4', 'THOR50X1', 'THOR50X2', 'THOR100'],
   'THRB': ['THRBX', 'THRBX1', 'THRBX2', 'THRBX4', 'THROB1', 'THROB2', 'THROB4'],
   'TOR': ['AMTORFEC', 'GTOR', 'NAVTEX', 'SITORB']
-}
+} as const
 
-export const ADIF_MODE_FOR_SUBMODE = {}
+export const ADIF_MODE_FOR_SUBMODE: Record<string, string> = {}
 Object.keys(ADIF_SUBMODES).forEach(mode => {
   ADIF_SUBMODES[mode].forEach(submode => {
     ADIF_MODE_FOR_SUBMODE[submode] = mode
   })
 })
 
-export const ADIF_MODES_AND_SUBMODES = [... new Set(ADIF_MODES.concat(Object.values(ADIF_SUBMODES)).flat())].sort()
+export const ADIF_MODES_AND_SUBMODES: readonly string[] = [...new Set([...ADIF_MODES, ...Object.values(ADIF_SUBMODES).flat()])].sort()
 
-export function adifModeAndSubmodeForMode(mode) {
+export function adifModeAndSubmodeForMode(mode: string): string[] {
   if (ADIF_MODE_FOR_SUBMODE[mode]) {
     return [ADIF_MODE_FOR_SUBMODE[mode], mode]
   } else {
@@ -135,7 +144,7 @@ export function adifModeAndSubmodeForMode(mode) {
   }
 }
 
-export function superModeForMode(mode) {
+export function superModeForMode(mode: string): SuperMode {
   if (ADIF_MODE_FOR_SUBMODE[mode]) mode = ADIF_MODE_FOR_SUBMODE[mode]
 
   if (mode === 'CW') {
@@ -147,41 +156,56 @@ export function superModeForMode(mode) {
   }
 }
 
-const AllSegments = Object.keys(BandPlans.bands).reduce((segments, band) => {
+const bandPlansData = BandPlans as unknown as BandPlansData
+
+const AllSegments: SegmentWithMetadata[] = Object.keys(bandPlansData.bands).reduce((segments, band) => {
   return segments.concat(
-    BandPlans.bands[band].segments.map(segment => (
-      {
-        ...segment,
+    bandPlansData.bands[band].segments.map(segment => {
+      const mhz = Array.isArray(segment.mhz) && segment.mhz.length >= 2
+        ? [segment.mhz[0], segment.mhz[1]] as [number, number]
+        : [0, 0] as [number, number]
+      return {
+        name: segment.name,
+        mode: segment.mode,
+        submode: segment.submode,
+        priority: segment.priority,
+        mhz,
         band,
-        width: segment.mhz[1] - segment.mhz[0],
-        regions: (segment.regions || []).reduce((regions, region) => { regions[region] = true; return regions }, {}),
-        entities: (segment.entities || []).reduce((entities, entity) => { entities[entity] = true; return entities }, {}),
-        countries: (segment.countries || []).reduce((countries, country) => { countries[country] = true; return countries }, {}),
-      }
-    ))
+        width: mhz[1] - mhz[0],
+        regions: (segment.regions || []).reduce((regions: Record<string, boolean>, region) => { regions[region.toString()] = true; return regions }, {}),
+        entities: (segment.entities || []).reduce((entities: Record<string, boolean>, entity) => { entities[entity] = true; return entities }, {}),
+        countries: (segment.countries || []).reduce((countries: Record<string, boolean>, country) => { countries[country] = true; return countries }, {}),
+      } as SegmentWithMetadata
+    })
   )
-}, [])
+}, [] as SegmentWithMetadata[])
+
+export function modeForFrequency(frequency: number, options: ModeForFrequencyOptions = {}): string | null | undefined {
+  const { ituRegion, countryCode, entityPrefix } = options
 
-export function modeForFrequency(frequency, { ituRegion, countryCode, entityPrefix } = {}) {
   const segments = AllSegments.filter(segment => (
     (segment.mhz[0] <= frequency && segment.mhz[1] >= frequency) &&
     (!entityPrefix || Object.keys(segment.entities).length === 0 || segment.entities[entityPrefix]) &&
     (!countryCode || Object.keys(segment.countries).length === 0 || segment.countries[countryCode]) &&
-    (!ituRegion || Object.keys(segment.regions).length === 0 || segment.regions[ituRegion])
+    (!ituRegion || Object.keys(segment.regions).length === 0 || segment.regions[ituRegion.toString()])
   ))
 
   const sortedSegments = segments.sort((a, b) => {
+    if ((a.priority ?? 0) < (b.priority ?? 0)) return 1
+    if ((a.priority ?? 0) > (b.priority ?? 0)) return -1
+
     if (entityPrefix && !a.entities[entityPrefix] && b.entities[entityPrefix]) return 1
     if (entityPrefix && a.entities[entityPrefix] && !b.entities[entityPrefix]) return -1
 
     if (countryCode && !a.countries[countryCode] && b.countries[countryCode]) return 1
     if (countryCode && a.countries[countryCode] && !b.countries[countryCode]) return -1
 
-    if (ituRegion && !a.regions[ituRegion] && b.regions[ituRegion]) return 1
-    if (ituRegion && a.regions[ituRegion] && !b.regions[ituRegion]) return -1
+    if (ituRegion && !a.regions[ituRegion.toString()] && b.regions[ituRegion.toString()]) return 1
+    if (ituRegion && a.regions[ituRegion.toString()] && !b.regions[ituRegion.toString()]) return -1
 
     return a.width - b.width
   })
 
   return sortedSegments[0]?.mode
 }
+

package/src/types.ts

@@ -0,0 +1,40 @@
+export interface BandPlanSegment {
+  name: string
+  mhz: [number, number] | number[]
+  mode?: string | null
+  submode?: string
+  priority?: number
+  regions?: number[]
+  entities?: string[]
+  countries?: string[]
+}
+
+export interface BandPlan {
+  mhz: [number, number] | number[]
+  segments: BandPlanSegment[]
+}
+
+export interface BandPlansData {
+  sources: Array<{ url: string }>
+  bands: Record<string, BandPlan>
+}
+
+export interface SegmentWithMetadata {
+  name: string
+  mhz: [number, number]
+  mode?: string | null
+  submode?: string
+  priority?: number
+  band: string
+  width: number
+  regions: Record<string, boolean>
+  entities: Record<string, boolean>
+  countries: Record<string, boolean>
+}
+
+export interface ModeForFrequencyOptions {
+  ituRegion?: number
+  countryCode?: string
+  entityPrefix?: string
+}
+

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020"],
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+