@ham2k/lib-operation-data 0.9.0 → 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.9.0",
+  "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.1.2"
+    "@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/{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}

@@ -31,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 type AdifMode = typeof ADIF_MODES[number]
 
-export const ADIF_SUBMODES = {
+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,27 +156,38 @@ 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) => {
@@ -180,11 +200,12 @@ export function modeForFrequency(frequency, { ituRegion, countryCode, entityPref
     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"]
+}
+