hamlib 0.1.27 → 0.2.1

package/binding.gyp

@@ -2,19 +2,20 @@
   "targets": [
     {
       "target_name": "hamlib",
-      "sources": [ 
+      "sources": [
         "src/hamlib.cpp",
         "src/decoder.cpp",
         "src/addon.cpp"
       ],
       "include_dirs": [
         "include",
+        "src/shim",
         "<!@(node -p \"require('node-addon-api').include\")"
       ],
       "dependencies": [
         "<!(node -p \"require('node-addon-api').gyp\")"
       ],
-      "defines": [ 
+      "defines": [
         "NAPI_DISABLE_CPP_EXCEPTIONS"
       ],
       "cflags!": [ "-fno-exceptions" ],
@@ -28,6 +29,7 @@
             "/usr/local/include"
           ],
           "libraries": [
+            "<(module_root_dir)/shim-build/libhamlib_shim.a",
             "<!@(node -e \"if(process.env.HAMLIB_PREFIX) console.log('-L' + process.env.HAMLIB_PREFIX + '/lib')\")",
             "-L/usr/lib",
             "-L/usr/local/lib",
@@ -49,6 +51,7 @@
             "/opt/homebrew/opt/libusb/include"
           ],
           "libraries": [
+            "<(module_root_dir)/shim-build/libhamlib_shim.a",
             "<!@(node -e \"if(process.env.HAMLIB_PREFIX) console.log('-L' + process.env.HAMLIB_PREFIX + '/lib')\")",
             "-L/usr/local/lib",
             "-L/usr/local/opt/hamlib/lib",
@@ -75,89 +78,19 @@
           ],
           "conditions": [
             ["target_arch==\"x64\"", {
-              "conditions": [
-                # Check if we're in MinGW environment (HAMLIB_ROOT is set to /mingw64)
-                ["\"<!(node -e \"console.log(process.env.HAMLIB_ROOT || '')\")\"==\"/mingw64\"", {
-                  "include_dirs": [
-                    "/mingw64/include"
-                  ],
-                  "library_dirs": [
-                    "/mingw64/lib"
-                  ],
-                  "libraries": [
-                    "-lhamlib",
-                    "-lws2_32",
-                    "-lwinmm"
-                  ],
-                  "cflags": [
-                    "-I/mingw64/include"
-                  ],
-                  "ldflags": [
-                    "-L/mingw64/lib",
-                    "-static-libgcc",
-                    "-static-libstdc++"
-                  ]
-                }, {
-                  # Traditional Windows build with Visual C++
-                  "include_dirs": [
-                    # Try environment variable in different formats
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/include')\")",
-                    # Fallback paths
-                    "C:/hamlib/include",
-                    "C:/Program Files/Hamlib/include", 
-                    "C:/Program Files (x86)/Hamlib/include"
-                  ],
-                  "library_dirs": [
-                    # Try environment variable paths
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/bin')\")",
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib')\")",
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib/gcc')\")",
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib/x64')\")",
-                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib/msvc')\")",
-                    # Fallback paths
-                    "C:/hamlib/bin",
-                    "C:/hamlib/lib",
-                    "C:/hamlib/lib/gcc",
-                    "C:/hamlib/lib/x64",
-                    "C:/hamlib/lib/Release",
-                    "C:/Program Files/Hamlib/bin",
-                    "C:/Program Files/Hamlib/lib",
-                    "C:/Program Files/Hamlib/lib/gcc",
-                    "C:/Program Files (x86)/Hamlib/bin",
-                    "C:/Program Files (x86)/Hamlib/lib"
-                  ],
-                  "libraries": [
-                    # Link against the import library present in hamlib-w64 zip
-                    "libhamlib-4.lib",
-                    # Common Win32 system libs used by hamlib
-                    "Ws2_32.lib",
-                    "Winmm.lib"
-                  ],
-                  "conditions": [
-                    # Add pthread paths only if PTHREAD_ROOT is set
-                    ["\"<!(node -e \"console.log(process.env.PTHREAD_ROOT || '')\")\"!=\"\"", {
-                      "include_dirs": [
-                        # Headers are placed directly under PTHREAD_ROOT to match this include path
-                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32'))\")"
-                      ],
-                      "library_dirs": [
-                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32') + '/lib/x64')\")",
-                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32') + '/lib')\")"
-                      ],
-                      "libraries": [
-                        # Only link the MSVC import library we download from Sourceware
-                        "pthreadVC2.lib"
-                      ]
-                    }]
-                  ],
-                  "msvs_settings": {
-                    "VCCLCompilerTool": {
-                      "ExceptionHandling": 1,
-                      "AdditionalOptions": ["/std:c++14"]
-                    }
-                  }
-                }]
-              ]
+              "library_dirs": [
+                "<(module_root_dir)/shim-build"
+              ],
+              "libraries": [
+                "hamlib_shim.lib",
+                "Ws2_32.lib"
+              ],
+              "msvs_settings": {
+                "VCCLCompilerTool": {
+                  "ExceptionHandling": 1,
+                  "AdditionalOptions": ["/std:c++14"]
+                }
+              }
             }]
           ]
         }]

package/index.d.ts

@@ -66,6 +66,46 @@ type VFO = 'VFO-A' | 'VFO-B';
  */
 type RadioMode = 'USB' | 'LSB' | 'FM' | 'PKTFM' | 'AM' | 'CW' | 'RTTY' | 'DIG' | string;
 
+/**
+ * Frequency range information
+ */
+interface FrequencyRange {
+  /** Start frequency in Hz */
+  startFreq: number;
+  /** End frequency in Hz */
+  endFreq: number;
+  /** Supported modes for this range */
+  modes: RadioMode[];
+  /** Minimum power in mW */
+  lowPower: number;
+  /** Maximum power in mW */
+  highPower: number;
+  /** VFO bitmask */
+  vfo: number;
+  /** Antenna bitmask */
+  antenna: number;
+}
+
+/**
+ * Tuning step information
+ */
+interface TuningStepInfo {
+  /** Modes this step applies to */
+  modes: RadioMode[];
+  /** Step size in Hz */
+  stepHz: number;
+}
+
+/**
+ * Filter information
+ */
+interface FilterInfo {
+  /** Modes this filter applies to */
+  modes: RadioMode[];
+  /** Filter width in Hz */
+  width: number;
+}
+
 /**
  * Hamlib debug level type
  * Controls the verbosity of Hamlib library debug output
@@ -1151,6 +1191,220 @@ declare class HamLib {
    * await rig.reset();         // Default soft reset
    */
   reset(resetType?: 'NONE' | 'SOFT' | 'VFO' | 'MCALL' | 'MASTER'): Promise<number>;
+
+  // ===== Rig Info / Raw / Conf (async) =====
+
+  /**
+   * Get rig identification info (model, firmware version, etc.)
+   * @returns Rig info string from the backend
+   */
+  getInfo(): Promise<string>;
+
+  /**
+   * Send raw command bytes and receive reply
+   * @param data Raw command data to send
+   * @param replyMaxLen Maximum reply length in bytes
+   * @param terminator Optional terminator bytes
+   * @returns Reply data as Buffer
+   */
+  sendRaw(data: Buffer, replyMaxLen: number, terminator?: Buffer): Promise<Buffer>;
+
+  /**
+   * Set a backend configuration parameter
+   * @param name Configuration token name
+   * @param value Configuration value
+   * @returns Success status
+   */
+  setConf(name: string, value: string): Promise<number>;
+
+  /**
+   * Get a backend configuration parameter
+   * @param name Configuration token name
+   * @returns Configuration value
+   */
+  getConf(name: string): Promise<string>;
+
+  // ===== Passband / Resolution (sync) =====
+
+  /**
+   * Get normal passband width for a given mode
+   * @param mode Radio mode
+   * @returns Normal passband width in Hz
+   */
+  getPassbandNormal(mode: RadioMode): number;
+
+  /**
+   * Get narrow passband width for a given mode
+   * @param mode Radio mode
+   * @returns Narrow passband width in Hz
+   */
+  getPassbandNarrow(mode: RadioMode): number;
+
+  /**
+   * Get wide passband width for a given mode
+   * @param mode Radio mode
+   * @returns Wide passband width in Hz
+   */
+  getPassbandWide(mode: RadioMode): number;
+
+  /**
+   * Get frequency resolution (step) for a given mode
+   * @param mode Radio mode
+   * @returns Resolution in Hz
+   */
+  getResolution(mode: RadioMode): number;
+
+  // ===== Capability queries (sync) =====
+
+  /**
+   * Get list of supported parameter types
+   * @returns Array of supported parameter type names
+   */
+  getSupportedParms(): string[];
+
+  /**
+   * Get list of supported VFO operations
+   * @returns Array of supported VFO operation types
+   */
+  getSupportedVfoOps(): VfoOperationType[];
+
+  /**
+   * Get list of supported scan types
+   * @returns Array of supported scan types
+   */
+  getSupportedScanTypes(): ScanType[];
+
+  // ===== Capability Queries - Batch 2 (sync) =====
+
+  /**
+   * Get supported preamplifier values
+   * @returns Array of preamp dB values
+   */
+  getPreampValues(): number[];
+
+  /**
+   * Get supported attenuator values
+   * @returns Array of attenuator dB values
+   */
+  getAttenuatorValues(): number[];
+
+  /**
+   * Get maximum RIT offset supported
+   * @returns Maximum RIT offset in Hz
+   */
+  getMaxRit(): number;
+
+  /**
+   * Get maximum XIT offset supported
+   * @returns Maximum XIT offset in Hz
+   */
+  getMaxXit(): number;
+
+  /**
+   * Get maximum IF shift supported
+   * @returns Maximum IF shift in Hz
+   */
+  getMaxIfShift(): number;
+
+  /**
+   * Get list of available CTCSS tone frequencies
+   * @returns Array of CTCSS tones in Hz
+   */
+  getAvailableCtcssTones(): number[];
+
+  /**
+   * Get list of available DCS codes
+   * @returns Array of DCS codes
+   */
+  getAvailableDcsCodes(): number[];
+
+  /**
+   * Get supported frequency ranges for RX and TX
+   */
+  getFrequencyRanges(): { rx: FrequencyRange[]; tx: FrequencyRange[] };
+
+  /**
+   * Get supported tuning steps per mode
+   */
+  getTuningSteps(): TuningStepInfo[];
+
+  /**
+   * Get supported filter widths per mode
+   */
+  getFilterList(): FilterInfo[];
+
+  // ===== Static: Copyright / License =====
+
+  /**
+   * Get Hamlib copyright information
+   * @static
+   */
+  static getCopyright(): string;
+
+  /**
+   * Get Hamlib license information
+   * @static
+   */
+  static getLicense(): string;
+
+  // ===== Lock Mode (Hamlib >= 4.7.0) =====
+
+  /**
+   * Set lock mode to prevent accidental front-panel changes
+   * @param lock - 0 to unlock, 1 to lock
+   */
+  setLockMode(lock: number): Promise<number>;
+
+  /**
+   * Get current lock mode status
+   * @returns 0 if unlocked, 1 if locked
+   */
+  getLockMode(): Promise<number>;
+
+  // ===== Clock (Hamlib >= 4.7.0) =====
+
+  /**
+   * Set the rig's internal clock
+   */
+  setClock(clock: ClockInfo): Promise<number>;
+
+  /**
+   * Get the rig's internal clock
+   */
+  getClock(): Promise<ClockInfo>;
+
+  // ===== VFO Info (Hamlib >= 4.7.0) =====
+
+  /**
+   * Get comprehensive VFO information in a single call
+   * @param vfo - Optional VFO to query (defaults to current)
+   */
+  getVfoInfo(vfo?: VFO): Promise<VfoInfo>;
+}
+
+/**
+ * Clock information for rig's internal clock
+ */
+interface ClockInfo {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  min: number;
+  sec: number;
+  msec: number;
+  utcOffset: number;
+}
+
+/**
+ * VFO information returned by getVfoInfo()
+ */
+interface VfoInfo {
+  frequency: number;
+  mode: string;
+  bandwidth: number;
+  split: boolean;
+  satMode: boolean;
 }
 
 /**
@@ -1161,10 +1415,11 @@ declare const nodeHamlib: {
 };
 
 // Export types for use elsewhere
-export { ConnectionInfo, ModeInfo, SupportedRigInfo, AntennaInfo, VFO, RadioMode, MemoryChannelData, 
-         MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType, 
-         ScanType, VfoOperationType, SerialConfigParam, SerialBaudRate, SerialParity, 
-         SerialHandshake, SerialControlState, PttType, DcdType, SerialConfigOptions, HamLib };
+export { ConnectionInfo, ModeInfo, SupportedRigInfo, AntennaInfo, VFO, RadioMode, MemoryChannelData,
+         MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType,
+         ScanType, VfoOperationType, SerialConfigParam, SerialBaudRate, SerialParity,
+         SerialHandshake, SerialControlState, PttType, DcdType, SerialConfigOptions,
+         ClockInfo, VfoInfo, HamLib };
 
 // Support both CommonJS and ES module exports
 // @ts-ignore

package/lib/index.js

@@ -1126,6 +1126,240 @@ class HamLib {
   async reset(resetType = 'SOFT') {
     return this._nativeInstance.reset(resetType);
   }
+
+  // Rig Info (async)
+
+  /**
+   * Get rig identification info (model, firmware version, etc.)
+   * @returns {Promise<string>} Rig info string
+   */
+  async getInfo() {
+    return this._nativeInstance.getInfo();
+  }
+
+  /**
+   * Send raw command bytes and receive reply
+   * @param {Buffer} data - Raw command data to send
+   * @param {number} replyMaxLen - Maximum reply length
+   * @param {Buffer} [terminator] - Optional terminator bytes
+   * @returns {Promise<Buffer>} Reply data
+   */
+  async sendRaw(data, replyMaxLen, terminator) {
+    if (terminator !== undefined) {
+      return this._nativeInstance.sendRaw(data, replyMaxLen, terminator);
+    }
+    return this._nativeInstance.sendRaw(data, replyMaxLen);
+  }
+
+  /**
+   * Set a backend configuration parameter
+   * @param {string} name - Configuration token name
+   * @param {string} value - Configuration value
+   * @returns {Promise<number>} Success status
+   */
+  async setConf(name, value) {
+    return this._nativeInstance.setConf(name, value);
+  }
+
+  /**
+   * Get a backend configuration parameter
+   * @param {string} name - Configuration token name
+   * @returns {Promise<string>} Configuration value
+   */
+  async getConf(name) {
+    return this._nativeInstance.getConf(name);
+  }
+
+  // Passband / Resolution (sync)
+
+  /**
+   * Get normal passband width for a given mode
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {number} Normal passband width in Hz
+   */
+  getPassbandNormal(mode) {
+    return this._nativeInstance.getPassbandNormal(mode);
+  }
+
+  /**
+   * Get narrow passband width for a given mode
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {number} Narrow passband width in Hz
+   */
+  getPassbandNarrow(mode) {
+    return this._nativeInstance.getPassbandNarrow(mode);
+  }
+
+  /**
+   * Get wide passband width for a given mode
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {number} Wide passband width in Hz
+   */
+  getPassbandWide(mode) {
+    return this._nativeInstance.getPassbandWide(mode);
+  }
+
+  /**
+   * Get frequency resolution (step) for a given mode
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {number} Resolution in Hz
+   */
+  getResolution(mode) {
+    return this._nativeInstance.getResolution(mode);
+  }
+
+  /**
+   * Get list of supported parameter types
+   * @returns {Array<string>} Array of supported parameter types
+   */
+  getSupportedParms() {
+    return this._nativeInstance.getSupportedParms();
+  }
+
+  /**
+   * Get list of supported VFO operations
+   * @returns {Array<string>} Array of supported VFO operation types
+   */
+  getSupportedVfoOps() {
+    return this._nativeInstance.getSupportedVfoOps();
+  }
+
+  /**
+   * Get list of supported scan types
+   * @returns {Array<string>} Array of supported scan types
+   */
+  getSupportedScanTypes() {
+    return this._nativeInstance.getSupportedScanTypes();
+  }
+
+  // Capability Query - Batch 2 (sync)
+
+  /**
+   * Get supported preamplifier values
+   * @returns {number[]} Array of preamp dB values (e.g., [10, 20])
+   */
+  getPreampValues() {
+    return this._nativeInstance.getPreampValues();
+  }
+
+  /**
+   * Get supported attenuator values
+   * @returns {number[]} Array of attenuator dB values (e.g., [10, 20, 30])
+   */
+  getAttenuatorValues() {
+    return this._nativeInstance.getAttenuatorValues();
+  }
+
+  /**
+   * Get maximum RIT offset supported
+   * @returns {number} Maximum RIT offset in Hz
+   */
+  getMaxRit() {
+    return this._nativeInstance.getMaxRit();
+  }
+
+  /**
+   * Get maximum XIT offset supported
+   * @returns {number} Maximum XIT offset in Hz
+   */
+  getMaxXit() {
+    return this._nativeInstance.getMaxXit();
+  }
+
+  /**
+   * Get maximum IF shift supported
+   * @returns {number} Maximum IF shift in Hz
+   */
+  getMaxIfShift() {
+    return this._nativeInstance.getMaxIfShift();
+  }
+
+  /**
+   * Get list of available CTCSS tone frequencies
+   * @returns {number[]} Array of CTCSS tones in Hz (e.g., [67.0, 71.9, ...])
+   */
+  getAvailableCtcssTones() {
+    return this._nativeInstance.getAvailableCtcssTones();
+  }
+
+  /**
+   * Get list of available DCS codes
+   * @returns {number[]} Array of DCS codes (integer values)
+   */
+  getAvailableDcsCodes() {
+    return this._nativeInstance.getAvailableDcsCodes();
+  }
+
+  /**
+   * Get supported frequency ranges for RX and TX
+   * @returns {{ rx: FrequencyRange[], tx: FrequencyRange[] }} RX and TX frequency ranges
+   */
+  getFrequencyRanges() {
+    return this._nativeInstance.getFrequencyRanges();
+  }
+
+  /**
+   * Get supported tuning steps per mode
+   * @returns {TuningStepInfo[]} Array of tuning step info objects
+   */
+  getTuningSteps() {
+    return this._nativeInstance.getTuningSteps();
+  }
+
+  /**
+   * Get supported filter widths per mode
+   * @returns {FilterInfo[]} Array of filter info objects
+   */
+  getFilterList() {
+    return this._nativeInstance.getFilterList();
+  }
+
+  /**
+   * Get Hamlib copyright information
+   * @returns {string} Copyright string
+   * @static
+   */
+  static getCopyright() {
+    return nativeModule.HamLib.getCopyright();
+  }
+
+  /**
+   * Get Hamlib license information
+   * @returns {string} License string
+   * @static
+   */
+  static getLicense() {
+    return nativeModule.HamLib.getLicense();
+  }
+
+  // Lock Mode (Hamlib >= 4.7.0)
+
+  async setLockMode(lock) {
+    return this._nativeInstance.setLockMode(lock);
+  }
+
+  async getLockMode() {
+    return this._nativeInstance.getLockMode();
+  }
+
+  // Clock (Hamlib >= 4.7.0)
+
+  async setClock({ year, month, day, hour, min, sec, msec, utcOffset }) {
+    return this._nativeInstance.setClock({ year, month, day, hour, min, sec, msec, utcOffset });
+  }
+
+  async getClock() {
+    return this._nativeInstance.getClock();
+  }
+
+  // VFO Info (Hamlib >= 4.7.0)
+
+  async getVfoInfo(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getVfoInfo(vfo);
+    }
+    return this._nativeInstance.getVfoInfo();
+  }
 }
 
 // Set debug level to NONE by default to prevent unwanted output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.1.27",
+  "version": "0.2.1",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",