wsjtx-lib 1.0.4 → 1.1.1

package/dist/src/index.cjs

@@ -1,554 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  WSJTXError: () => WSJTXError,
-  WSJTXLib: () => WSJTXLib,
-  WSJTXMode: () => WSJTXMode
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/types.ts
-var WSJTXMode = /* @__PURE__ */ ((WSJTXMode2) => {
-  WSJTXMode2[WSJTXMode2["FT8"] = 0] = "FT8";
-  WSJTXMode2[WSJTXMode2["FT4"] = 1] = "FT4";
-  WSJTXMode2[WSJTXMode2["JT4"] = 2] = "JT4";
-  WSJTXMode2[WSJTXMode2["JT65"] = 3] = "JT65";
-  WSJTXMode2[WSJTXMode2["JT9"] = 4] = "JT9";
-  WSJTXMode2[WSJTXMode2["FST4"] = 5] = "FST4";
-  WSJTXMode2[WSJTXMode2["Q65"] = 6] = "Q65";
-  WSJTXMode2[WSJTXMode2["FST4W"] = 7] = "FST4W";
-  WSJTXMode2[WSJTXMode2["WSPR"] = 8] = "WSPR";
-  return WSJTXMode2;
-})(WSJTXMode || {});
-var WSJTXError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "WSJTXError";
-  }
-};
-
-// src/index.ts
-var import_node_module = require("module");
-var import_node_url = require("url");
-var import_node_path = __toESM(require("path"), 1);
-var import_node_fs = __toESM(require("fs"), 1);
-var import_meta = {};
-function getModuleContext() {
-  try {
-    if (typeof import_meta !== "undefined" && import_meta.url) {
-      return {
-        require: (0, import_node_module.createRequire)(import_meta.url),
-        __filename: (0, import_node_url.fileURLToPath)(import_meta.url),
-        __dirname: import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url))
-      };
-    }
-  } catch {
-  }
-  return {
-    require: typeof require2 !== "undefined" ? require2 : (0, import_node_module.createRequire)("file://"),
-    __filename: typeof __filename !== "undefined" ? __filename : "",
-    __dirname: typeof __dirname !== "undefined" ? __dirname : ""
-  };
-}
-var moduleContext = getModuleContext();
-var { require: require2, __filename, __dirname } = moduleContext;
-function findNativeModule() {
-  const platform = process.platform;
-  const arch = process.arch;
-  const isPkgEnvironment = !!process.pkg || __dirname.includes("/snapshot/") || __dirname.includes("\\snapshot\\");
-  if (isPkgEnvironment) {
-    console.log("Detected pkg packaged environment");
-    const execDir = import_node_path.default.dirname(process.execPath);
-    const pkgPaths = [
-      // 1. 与可执行文件同目录（最常见的打包方式）
-      import_node_path.default.join(execDir, "wsjtx_lib_nodejs.node"),
-      import_node_path.default.join(execDir, `wsjtx_lib_nodejs-${platform}-${arch}.node`),
-      // 2. prebuilds 子目录（保持结构的打包方式）
-      import_node_path.default.join(execDir, "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
-      // 3. 相对于可执行文件的其他可能位置
-      import_node_path.default.join(execDir, "..", "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
-      import_node_path.default.join(execDir, "lib", "wsjtx_lib_nodejs.node"),
-      import_node_path.default.join(execDir, "native", "wsjtx_lib_nodejs.node")
-    ];
-    console.log("PKG environment - searching for native module:");
-    pkgPaths.forEach((p) => console.log(`  - ${p}`));
-    for (const modulePath of pkgPaths) {
-      if (import_node_fs.default.existsSync(modulePath)) {
-        console.log(`Found native module at: ${modulePath}`);
-        return modulePath;
-      }
-    }
-    const pathList2 = pkgPaths.map((p) => `  - ${p}`).join("\n");
-    throw new Error(
-      `Native module not found in pkg packaged environment for ${platform}-${arch}.
-Searched in:
-${pathList2}
-
-Solutions:
-1. Ensure the native module is included in your pkg configuration
-2. Copy wsjtx_lib_nodejs.node to the same directory as your executable
-3. Check if the native module was properly bundled during packaging`
-    );
-  }
-  const moduleRoot = import_node_path.default.resolve(__dirname, "..");
-  const possiblePaths = [
-    // 1. Prebuilt binaries (npm packages) - highest priority
-    import_node_path.default.join(moduleRoot, "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
-    // 2. GitHub Actions legacy format (for backward compatibility)
-    import_node_path.default.join(moduleRoot, "prebuilds", `${platform}-latest-${arch}`, "wsjtx_lib_nodejs.node"),
-    import_node_path.default.join(moduleRoot, "prebuilds", `ubuntu-latest-${arch}`, "wsjtx_lib_nodejs.node"),
-    // Linux
-    import_node_path.default.join(moduleRoot, "prebuilds", `macos-latest-${arch}`, "wsjtx_lib_nodejs.node"),
-    // macOS  
-    import_node_path.default.join(moduleRoot, "prebuilds", `windows-latest-${arch}`, "wsjtx_lib_nodejs.node"),
-    // Windows
-    // 3. Local development builds - third priority
-    import_node_path.default.join(moduleRoot, "build", "wsjtx_lib_nodejs.node"),
-    import_node_path.default.join(moduleRoot, "build", "Release", "wsjtx_lib_nodejs.node")
-  ];
-  console.log("Normal environment - searching for native module:");
-  possiblePaths.forEach((p) => console.log(`  - ${p}`));
-  for (const modulePath of possiblePaths) {
-    if (import_node_fs.default.existsSync(modulePath)) {
-      console.log(`Found native module at: ${modulePath}`);
-      return modulePath;
-    }
-  }
-  const pathList = possiblePaths.map((p) => `  - ${p}`).join("\n");
-  throw new Error(
-    `Native module not found for ${platform}-${arch}.
-Searched in:
-${pathList}
-
-Solutions:
-1. If you installed via npm, this may be a missing prebuilt binary
-2. For development, run "npm run build" to compile the native module
-3. Check if your platform/architecture is supported`
-  );
-}
-var nativeModulePath = findNativeModule();
-var { WSJTXLib: NativeWSJTXLib } = require2(nativeModulePath);
-var WSJTXLib = class _WSJTXLib {
-  native;
-  config;
-  /**
-   * Create a new WSJTX library instance
-   * 
-   * @param config Optional configuration options
-   * @throws {WSJTXError} If the native library fails to initialize
-   */
-  constructor(config = {}) {
-    this.config = {
-      maxThreads: 4,
-      debug: false,
-      ...config
-    };
-    try {
-      this.native = new NativeWSJTXLib();
-    } catch (error) {
-      throw new WSJTXError(
-        `Failed to initialize WSJTX library: ${error instanceof Error ? error.message : String(error)}`,
-        "INIT_ERROR"
-      );
-    }
-  }
-  /**
-   * Decode digital radio signals from audio data
-   * 
-   * This method processes audio samples and attempts to decode digital
-   * messages using the specified protocol mode. The operation is performed
-   * asynchronously to avoid blocking the Node.js event loop.
-   * 
-   * @param mode The digital mode to use for decoding
-   * @param audioData Audio samples (Float32Array or Int16Array)
-   * @param frequency Center frequency in Hz
-   * @param threads Number of threads to use (1-16, default: 4)
-   * @returns Promise that resolves when decoding is complete
-   * 
-   * @throws {WSJTXError} If parameters are invalid or decoding fails
-   * 
-   * @example
-   * ```typescript
-   * const audioData = new Float32Array(48000 * 13); // 13 seconds
-   * await lib.decode(WSJTXMode.FT8, audioData, 1500);
-   * const messages = lib.pullMessages();
-   * ```
-   */
-  async decode(mode, audioData, frequency, threads = this.config.maxThreads || 4) {
-    this.validateMode(mode);
-    this.validateFrequency(frequency);
-    this.validateThreads(threads);
-    this.validateAudioData(audioData);
-    if (!this.isDecodingSupported(mode)) {
-      throw new WSJTXError(`Decoding not supported for mode: ${WSJTXMode[mode]}`, "UNSUPPORTED_MODE");
-    }
-    return new Promise((resolve, reject) => {
-      const callback = (error, result) => {
-        if (error) {
-          reject(new WSJTXError(error.message, "DECODE_ERROR"));
-        } else {
-          resolve({ success: result });
-        }
-      };
-      try {
-        this.native.decode(mode, audioData, frequency, threads, callback);
-      } catch (error) {
-        reject(new WSJTXError(
-          `Decode operation failed: ${error instanceof Error ? error.message : String(error)}`,
-          "DECODE_ERROR"
-        ));
-      }
-    });
-  }
-  /**
-   * Encode a message into audio waveform for transmission
-   * 
-   * Generates the audio waveform that represents the specified message
-   * using the given digital mode. The resulting audio can be fed to
-   * a radio transmitter or audio interface.
-   * 
-   * @param mode The digital mode to use for encoding
-   * @param message The message text to encode (mode-specific format)
-   * @param frequency Center frequency in Hz
-   * @param threads Number of threads to use (1-16, default: 4)
-   * @returns Promise that resolves with encoded audio data and actual message sent
-   * 
-   * @throws {WSJTXError} If parameters are invalid or encoding fails
-   * 
-   * @example
-   * ```typescript
-   * const result = await lib.encode(WSJTXMode.FT8, 'CQ DX K1ABC FN20', 1500);
-   * console.log('Generated audio samples:', result.audioData.length);
-   * console.log('Actual message sent:', result.messageSent);
-   * ```
-   */
-  async encode(mode, message, frequency, threads = this.config.maxThreads || 4) {
-    this.validateMode(mode);
-    this.validateMessage(message);
-    this.validateFrequency(frequency);
-    this.validateThreads(threads);
-    if (!this.isEncodingSupported(mode)) {
-      throw new WSJTXError(`Encoding not supported for mode: ${WSJTXMode[mode]}`, "UNSUPPORTED_MODE");
-    }
-    return new Promise((resolve, reject) => {
-      const callback = (error, result) => {
-        if (error) {
-          reject(new WSJTXError(error.message, "ENCODE_ERROR"));
-        } else {
-          resolve(result);
-        }
-      };
-      try {
-        this.native.encode(mode, message, frequency, threads, callback);
-      } catch (error) {
-        reject(new WSJTXError(
-          `Encode operation failed: ${error instanceof Error ? error.message : String(error)}`,
-          "ENCODE_ERROR"
-        ));
-      }
-    });
-  }
-  /**
-   * Decode WSPR signals from IQ data
-   * 
-   * WSPR (Weak Signal Propagation Reporter) is a specialized protocol
-   * for studying radio propagation. This method takes IQ (complex)
-   * samples and attempts to decode WSPR transmissions.
-   * 
-   * @param iqData Interleaved I,Q samples as Float32Array
-   * @param options Decoder options (frequency, callsign, etc.)
-   * @returns Promise that resolves with array of decoded WSPR results
-   * 
-   * @throws {WSJTXError} If parameters are invalid or decoding fails
-   * 
-   * @example
-   * ```typescript
-   * const iqData = new Float32Array(2 * 12000 * 111); // 2 minutes of IQ data
-   * const options = {
-   *   dialFrequency: 14095600, // 20m WSPR frequency
-   *   callsign: 'K1ABC',
-   *   locator: 'FN20'
-   * };
-   * const results = await lib.decodeWSPR(iqData, options);
-   * ```
-   */
-  async decodeWSPR(iqData, options = {}) {
-    this.validateIQData(iqData);
-    const defaultOptions = {
-      dialFrequency: 14095600,
-      // 20m WSPR frequency
-      callsign: "",
-      locator: "",
-      quickMode: false,
-      useHashTable: true,
-      passes: 2,
-      subtraction: true,
-      ...options
-    };
-    return new Promise((resolve, reject) => {
-      const callback = (error, results) => {
-        if (error) {
-          reject(new WSJTXError(error.message, "WSPR_DECODE_ERROR"));
-        } else {
-          resolve(results);
-        }
-      };
-      try {
-        this.native.decodeWSPR(iqData, defaultOptions, callback);
-      } catch (error) {
-        reject(new WSJTXError(
-          `WSPR decode failed: ${error instanceof Error ? error.message : String(error)}`,
-          "WSPR_DECODE_ERROR"
-        ));
-      }
-    });
-  }
-  /**
-   * Retrieve decoded messages from the internal queue
-   * 
-   * Messages are added to an internal queue as they are decoded.
-   * This method retrieves and removes all pending messages from the queue.
-   * 
-   * @returns Array of decoded messages
-   * 
-   * @example
-   * ```typescript
-   * const messages = lib.pullMessages();
-   * messages.forEach(msg => {
-   *   console.log(`${msg.text} (SNR: ${msg.snr} dB, ΔT: ${msg.deltaTime}s)`);
-   * });
-   * ```
-   */
-  pullMessages() {
-    try {
-      return this.native.pullMessages();
-    } catch (error) {
-      throw new WSJTXError(
-        `Failed to pull messages: ${error instanceof Error ? error.message : String(error)}`,
-        "PULL_ERROR"
-      );
-    }
-  }
-  /**
-   * Check if encoding is supported for a specific mode
-   * 
-   * @param mode The mode to check
-   * @returns True if encoding is supported
-   */
-  isEncodingSupported(mode) {
-    return this.native.isEncodingSupported(mode);
-  }
-  /**
-   * Check if decoding is supported for a specific mode
-   * 
-   * @param mode The mode to check
-   * @returns True if decoding is supported
-   */
-  isDecodingSupported(mode) {
-    return this.native.isDecodingSupported(mode);
-  }
-  /**
-   * Get the required sample rate for a specific mode
-   * 
-   * @param mode The mode to query
-   * @returns Sample rate in Hz
-   */
-  getSampleRate(mode) {
-    return this.native.getSampleRate(mode);
-  }
-  /**
-   * Get the transmission duration for a specific mode
-   * 
-   * @param mode The mode to query
-   * @returns Duration in seconds
-   */
-  getTransmissionDuration(mode) {
-    return this.native.getTransmissionDuration(mode);
-  }
-  /**
-   * Get capabilities for all supported modes
-   * 
-   * @returns Array of mode capability information
-   */
-  getAllModeCapabilities() {
-    const modes = Object.values(WSJTXMode).filter((v) => typeof v === "number");
-    return modes.map((mode) => ({
-      mode,
-      encodingSupported: this.isEncodingSupported(mode),
-      decodingSupported: this.isDecodingSupported(mode),
-      sampleRate: this.getSampleRate(mode),
-      duration: this.getTransmissionDuration(mode)
-    }));
-  }
-  /**
-   * Convert audio format between Float32Array and Int16Array
-   * 
-   * @param audioData Input audio data
-   * @param targetFormat Target format ('float32' or 'int16')
-   * @returns Converted audio data
-   */
-  static convertAudioFormat(audioData, targetFormat) {
-    if (targetFormat !== "float32" && targetFormat !== "int16") {
-      throw new Error(`Invalid target format: ${targetFormat}. Must be 'float32' or 'int16'`);
-    }
-    if (targetFormat === "float32") {
-      if (audioData instanceof Float32Array) {
-        return audioData;
-      }
-      const result = new Float32Array(audioData.length);
-      for (let i = 0; i < audioData.length; i++) {
-        result[i] = audioData[i] / 32768;
-      }
-      return result;
-    } else {
-      if (audioData instanceof Int16Array) {
-        return audioData;
-      }
-      const result = new Int16Array(audioData.length);
-      for (let i = 0; i < audioData.length; i++) {
-        result[i] = Math.max(-32768, Math.min(32767, Math.round(audioData[i] * 32768)));
-      }
-      return result;
-    }
-  }
-  /**
-   * Static convenience helper for async audio format conversion.
-   */
-  static async convertAudioFormatAsync(audioData, targetFormat) {
-    const lib = new _WSJTXLib();
-    return lib.convertAudioFormatAsync(audioData, targetFormat);
-  }
-  /**
-   * Asynchronously convert audio data format without blocking the event loop
-   *
-   * Uses native thread pool to offload conversion.
-   */
-  async convertAudioFormatAsync(audioData, targetFormat) {
-    if (targetFormat !== "float32" && targetFormat !== "int16") {
-      throw new Error(`Invalid target format: ${targetFormat}. Must be 'float32' or 'int16'`);
-    }
-    this.validateAudioData(audioData);
-    return new Promise((resolve, reject) => {
-      const callback = (error, result) => {
-        if (error) {
-          reject(new WSJTXError(error.message ?? String(error), "CONVERT_ERROR"));
-        } else {
-          resolve(result);
-        }
-      };
-      try {
-        this.native.convertAudioAsync(audioData, targetFormat, callback);
-      } catch (error) {
-        reject(new WSJTXError(
-          `Convert operation failed: ${error instanceof Error ? error.message : String(error)}`,
-          "CONVERT_ERROR"
-        ));
-      }
-    });
-  }
-  // Validation methods
-  validateMode(mode) {
-    if (!Object.values(WSJTXMode).includes(mode)) {
-      throw new WSJTXError(`Invalid mode: ${mode}`, "INVALID_MODE");
-    }
-  }
-  validateFrequency(frequency) {
-    if (!Number.isInteger(frequency) || frequency < 0 || frequency > 3e7) {
-      throw new WSJTXError(
-        `Invalid frequency: ${frequency}. Must be between 0 and 30,000,000 Hz`,
-        "INVALID_FREQUENCY"
-      );
-    }
-  }
-  validateThreads(threads) {
-    if (!Number.isInteger(threads) || threads < 1 || threads > 16) {
-      throw new WSJTXError(
-        `Invalid thread count: ${threads}. Must be between 1 and 16`,
-        "INVALID_THREADS"
-      );
-    }
-  }
-  validateMessage(message) {
-    if (typeof message !== "string" || message.length === 0 || message.length > 22) {
-      throw new WSJTXError(
-        `Invalid message: "${message}". Must be 1-22 characters long`,
-        "INVALID_MESSAGE"
-      );
-    }
-  }
-  validateAudioData(audioData) {
-    if (!(audioData instanceof Float32Array) && !(audioData instanceof Int16Array)) {
-      throw new WSJTXError(
-        "Invalid audio data: must be Float32Array or Int16Array",
-        "INVALID_AUDIO_DATA"
-      );
-    }
-    if (audioData.length === 0) {
-      throw new WSJTXError("Audio data cannot be empty", "INVALID_AUDIO_DATA");
-    }
-  }
-  validateIQData(iqData) {
-    if (!(iqData instanceof Float32Array)) {
-      throw new WSJTXError(
-        "Invalid IQ data: must be Float32Array with interleaved I,Q samples",
-        "INVALID_IQ_DATA"
-      );
-    }
-    if (iqData.length === 0 || iqData.length % 2 !== 0) {
-      throw new WSJTXError(
-        "IQ data length must be even (interleaved I,Q samples)",
-        "INVALID_IQ_DATA"
-      );
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WSJTXError,
-  WSJTXLib,
-  WSJTXMode
-});
-/**
- * WSJTX Digital Radio Protocol Library for Node.js
- * 
- * This library provides encoding and decoding capabilities for various
- * digital amateur radio protocols including FT8, FT4, WSPR, and others.
- * 
- * The library is a Node.js C++ extension that wraps the wsjtx_lib C library,
- * providing high-performance digital signal processing capabilities with
- * multi-platform support (Windows, macOS, Linux).
- * 
- * @version 1.0.0
- * @author WSJTX Development Team
- * @license GPL-3.0
- */