react-native-tiny-wavpack-decoder 0.1.0

package/android/src/main/cpp/TinyWavPackDecoderModule.cpp

@@ -0,0 +1,118 @@
+#include <jni.h>
+#include <string>
+#include <android/log.h>
+#include "TinyWavPackDecoderInterface.h"
+
+#define TAG "TinyWavPackDecoder"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
+
+// Cache for the Java VM and class references
+static JavaVM *javaVM = nullptr;
+static jclass decoderClass = nullptr;
+static jmethodID onProgressMethod = nullptr;
+
+// Callback function to report progress back to Java
+static void progressCallbackBridge(float progress, void *context)
+{
+    JNIEnv *env;
+    // Get the JNI environment
+    jint result = javaVM->GetEnv((void **)&env, JNI_VERSION_1_6);
+
+    if (result == JNI_OK)
+    {
+        // Call the onProgress method in Java
+        env->CallStaticVoidMethod(decoderClass, onProgressMethod, progress);
+    }
+    else if (result == JNI_EDETACHED)
+    {
+        // Thread is detached, attach it
+        if (javaVM->AttachCurrentThread(&env, nullptr) == JNI_OK)
+        {
+            env->CallStaticVoidMethod(decoderClass, onProgressMethod, progress);
+            javaVM->DetachCurrentThread();
+        }
+        else
+        {
+            LOGE("Failed to attach thread for progress callback");
+        }
+    }
+    else
+    {
+        LOGE("Failed to get JNI environment for progress callback");
+    }
+}
+
+// The JNI implementation of the decode method
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_tinywavpackdecoder_TinyWavPackDecoderModule_nativeDecodeWavPack(
+    JNIEnv *env,
+    jclass clazz,
+    jstring j_input_path,
+    jstring j_output_path,
+    jint j_max_samples,
+    jint j_bits_per_sample)
+{
+
+    // Convert Java strings to C strings
+    const char *inputPath = env->GetStringUTFChars(j_input_path, nullptr);
+    const char *outputPath = env->GetStringUTFChars(j_output_path, nullptr);
+
+    // Log the parameters
+    LOGI("Decoding WavPack: input=%s, output=%s, maxSamples=%d, bitsPerSample=%d",
+         inputPath, outputPath, j_max_samples, j_bits_per_sample);
+
+    // Call the decoder
+    DecoderResult result = decode_wavpack_to_wav(
+        inputPath,
+        outputPath,
+        j_max_samples,
+        j_bits_per_sample,
+        progressCallbackBridge,
+        nullptr);
+
+    // Release the C strings
+    env->ReleaseStringUTFChars(j_input_path, inputPath);
+    env->ReleaseStringUTFChars(j_output_path, outputPath);
+
+    // Return the result
+    if (result.success)
+    {
+        return env->NewStringUTF("Success");
+    }
+    else
+    {
+        return env->NewStringUTF(result.error);
+    }
+}
+
+// Called when the library is loaded
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved)
+{
+    javaVM = vm;
+    JNIEnv *env;
+
+    if (vm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK)
+    {
+        return JNI_ERR;
+    }
+
+    // Cache the Java class and method IDs
+    jclass localClass = env->FindClass("com/tinywavpackdecoder/TinyWavPackDecoderModule");
+    if (localClass == nullptr)
+    {
+        LOGE("Failed to find TinyWavPackDecoderModule class");
+        return JNI_ERR;
+    }
+
+    decoderClass = (jclass)env->NewGlobalRef(localClass);
+    onProgressMethod = env->GetStaticMethodID(decoderClass, "onProgress", "(F)V");
+
+    if (onProgressMethod == nullptr)
+    {
+        LOGE("Failed to find onProgress method");
+        return JNI_ERR;
+    }
+
+    return JNI_VERSION_1_6;
+}

package/android/src/main/java/com/tinywavpackdecoder/TinyWavPackDecoderModule.kt

@@ -0,0 +1,114 @@
+package com.tinywavpackdecoder
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+@ReactModule(name = TinyWavPackDecoderModule.NAME)
+class TinyWavPackDecoderModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "TinyWavPackDecoderModule"
+        private const val TAG = "TinyWavPackDecoder"
+        private const val EVENT_PROGRESS = "onProgressUpdate"
+
+        init {
+            System.loadLibrary("tiny-wavpack-decoder")
+        }
+
+        // Called from JNI
+        @JvmStatic
+        fun onProgress(progress: Float) {
+            sInstance?.sendProgressEvent(progress)
+        }
+
+        // Keep a static reference to the module instance
+        private var sInstance: TinyWavPackDecoderModule? = null
+
+        // Native method declarations
+        @JvmStatic
+        external fun nativeDecodeWavPack(
+            inputPath: String,
+            outputPath: String,
+            maxSamples: Int,
+            bitsPerSample: Int
+        ): String
+    }
+
+    init {
+        sInstance = this
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun decodeWavPack(
+        inputPath: String,
+        outputPath: String,
+        maxSamples: Double?,
+        bitsPerSample: Double?,
+        promise: Promise
+    ) {
+        try {
+            // Convert parameters to the correct types
+            val maxSamplesInt = maxSamples?.toInt() ?: -1
+            val bitsPerSampleInt = bitsPerSample?.toInt() ?: 16
+
+            Log.d(TAG, "Decoding WavPack: $inputPath -> $outputPath")
+
+            // Run in a background thread to avoid blocking the JS thread
+            Thread {
+                try {
+                    val result = nativeDecodeWavPack(
+                        inputPath,
+                        outputPath,
+                        maxSamplesInt,
+                        bitsPerSampleInt
+                    )
+
+                    reactApplicationContext.runOnJSQueueThread {
+                        if (result == "Success") {
+                            promise.resolve(result)
+                        } else {
+                            promise.reject("DECODE_ERROR", result)
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error decoding WavPack", e)
+                    reactApplicationContext.runOnJSQueueThread {
+                        promise.reject("DECODE_ERROR", e.message, e)
+                    }
+                }
+            }.start()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error starting decode thread", e)
+            promise.reject("DECODE_ERROR", e.message, e)
+        }
+    }
+
+    // Send progress events to JavaScript
+    private fun sendProgressEvent(progress: Float) {
+        reactApplicationContext.runOnJSQueueThread {
+            val params = Arguments.createMap().apply {
+                putDouble("progress", progress.toDouble())
+            }
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(EVENT_PROGRESS, params)
+        }
+    }
+
+    @ReactMethod
+    fun addListener(eventType: String) {
+        // Required for RN built-in Event Emitter Support
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN built-in Event Emitter Support
+    }
+}

package/android/src/main/java/com/tinywavpackdecoder/TinyWavPackDecoderPackage.kt

@@ -0,0 +1,18 @@
+package com.tinywavpackdecoder
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class TinyWavPackDecoderPackage : ReactPackage {
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<View, ReactShadowNode<*>>> = emptyList()
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> = listOf(TinyWavPackDecoderModule(reactContext))
+}

package/ios/TinyWavPackDecoder.h

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+#import <RNTinyWavPackDecoderSpec.h>
+#import <React/RCTEventEmitter.h>
+
+@interface TinyWavPackDecoder : RCTEventEmitter <NativeTinyWavPackDecoderSpec>
+@end

package/ios/TinyWavPackDecoder.mm

@@ -0,0 +1,83 @@
+#import "TinyWavPackDecoder.h"
+#import "../src/tiny-wavpack/common/TinyWavPackDecoderInterface.h"
+#import <React/RCTLog.h>
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+
+using namespace facebook::jsi;
+using namespace facebook::react;
+
+@implementation TinyWavPackDecoder
+
+RCT_EXPORT_MODULE(TinyWavPackDecoderModule);
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    RCTLogInfo(@"TinyWavPackDecoderModule initialized");
+  }
+  return self;
+}
+
+- (dispatch_queue_t)methodQueue {
+  static dispatch_queue_t queue = dispatch_queue_create("com.wavpackdecoder.decode", DISPATCH_QUEUE_CONCURRENT);
+  return queue;
+}
+
+- (std::shared_ptr<TurboModule>)getTurboModule:(const ObjCTurboModule::InitParams &)params {
+  return std::make_shared<NativeTinyWavPackDecoderSpecJSI>(params);
+}
+
+- (void)decodeWavPack:(NSString *)inputPath
+           outputPath:(NSString *)outputPath
+           maxSamples:(NSNumber *)maxSamples
+        bitsPerSample:(NSNumber *)bitsPerSample
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+  int maxSamplesInt = maxSamples != nil ? [maxSamples intValue] : -1;
+  int bitsPerSampleInt = bitsPerSample != nil ? [bitsPerSample intValue] : 0; // Default to 16-bit
+  const char *inputPathC = [inputPath UTF8String];
+  const char *outputPathC = [outputPath UTF8String];
+  
+  DecoderResult result = decode_wavpack_to_wav(
+                                               inputPathC,
+                                               outputPathC,
+                                               maxSamplesInt,
+                                               bitsPerSampleInt,
+                                               progressCallbackBridge,
+                                               (__bridge void*)self
+                                               );
+  
+  // Dispatch promise resolution/rejection to the main queue
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (result.success) {
+      resolve(@"Success");
+    } else {
+      NSString *errorMessage = [NSString stringWithUTF8String:result.error];
+      reject(@"decode_error", errorMessage, nil);
+    }
+  });
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"onProgressUpdate"];
+}
+
+static void progressCallbackBridge(float progress, void* context) {
+  TinyWavPackDecoder* decoder = (__bridge TinyWavPackDecoder*)context;
+  if (decoder.bridge) {
+    [decoder sendEventWithName:@"onProgressUpdate" body:@{@"progress": @(progress)}];
+  } else {
+    RCTLogWarn(@"Cannot emit TinyWavPackDecoder progress event: bridge is nil");
+  }
+}
+
+- (void)startObserving {
+  RCTLogInfo(@"Starting event observation for TinyWavPackDecoder");
+}
+
+- (void)stopObserving {
+  RCTLogInfo(@"Stopping event observation for TinyWavPackDecoder");
+}
+
+@end

package/ios/generated/RNTinyWavPackDecoderSpec/RNTinyWavPackDecoderSpec-generated.mm

@@ -0,0 +1,53 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "RNTinyWavPackDecoderSpec.h"
+
+
+@implementation NativeTinyWavPackDecoderSpecBase
+
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_decodeWavPack(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "decodeWavPack", @selector(decodeWavPack:outputPath:maxSamples:bitsPerSample:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_addListener(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "addListener", @selector(addListener:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_removeListeners(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "removeListeners", @selector(removeListeners:), args, count);
+    }
+
+  NativeTinyWavPackDecoderSpecJSI::NativeTinyWavPackDecoderSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["decodeWavPack"] = MethodMetadata {4, __hostFunction_NativeTinyWavPackDecoderSpecJSI_decodeWavPack};
+        
+        
+        methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderSpecJSI_addListener};
+        
+        
+        methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderSpecJSI_removeListeners};
+        
+  }
+} // namespace facebook::react

package/ios/generated/RNTinyWavPackDecoderSpec/RNTinyWavPackDecoderSpec.h

@@ -0,0 +1,69 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of RNTinyWavPackDecoderSpec symbols
+#ifndef RNTinyWavPackDecoderSpec_H
+#define RNTinyWavPackDecoderSpec_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol NativeTinyWavPackDecoderSpec <RCTBridgeModule, RCTTurboModule>
+
+- (void)decodeWavPack:(NSString *)inputPath
+           outputPath:(NSString *)outputPath
+           maxSamples:(NSNumber *)maxSamples
+        bitsPerSample:(NSNumber *)bitsPerSample
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject;
+- (void)addListener:(NSString *)eventType;
+- (void)removeListeners:(double)count;
+
+@end
+
+@interface NativeTinyWavPackDecoderSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativeTinyWavPackDecoder'
+   */
+  class JSI_EXPORT NativeTinyWavPackDecoderSpecJSI : public ObjCTurboModule {
+  public:
+    NativeTinyWavPackDecoderSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+
+NS_ASSUME_NONNULL_END
+#endif // RNTinyWavPackDecoderSpec_H

package/ios/generated/RNTinyWavPackDecoderSpecJSI-generated.cpp

@@ -0,0 +1,46 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleCpp.js
+ */
+
+#include "RNTinyWavPackDecoderSpecJSI.h"
+
+namespace facebook::react {
+
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_decodeWavPack(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->decodeWavPack(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt),
+    count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asString(rt),
+    count <= 2 || args[2].isUndefined() ? std::nullopt : std::make_optional(args[2].asNumber()),
+    count <= 3 || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asNumber())
+  );
+}
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_addListener(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->addListener(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_removeListeners(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->removeListeners(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber()
+  );
+  return jsi::Value::undefined();
+}
+
+NativeTinyWavPackDecoderCxxSpecJSI::NativeTinyWavPackDecoderCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+  : TurboModule("TinyWavPackDecoderModule", jsInvoker) {
+  methodMap_["decodeWavPack"] = MethodMetadata {4, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_decodeWavPack};
+  methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_addListener};
+  methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_removeListeners};
+}
+
+
+} // namespace facebook::react

package/ios/generated/RNTinyWavPackDecoderSpecJSI.h

@@ -0,0 +1,89 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  class JSI_EXPORT NativeTinyWavPackDecoderCxxSpecJSI : public TurboModule {
+protected:
+  NativeTinyWavPackDecoderCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual jsi::Value decodeWavPack(jsi::Runtime &rt, jsi::String inputPath, jsi::String outputPath, std::optional<double> maxSamples, std::optional<double> bitsPerSample) = 0;
+  virtual void addListener(jsi::Runtime &rt, jsi::String eventType) = 0;
+  virtual void removeListeners(jsi::Runtime &rt, double count) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeTinyWavPackDecoderCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "TinyWavPackDecoderModule";
+
+protected:
+  NativeTinyWavPackDecoderCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeTinyWavPackDecoderCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativeTinyWavPackDecoderCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeTinyWavPackDecoderCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    jsi::Value decodeWavPack(jsi::Runtime &rt, jsi::String inputPath, jsi::String outputPath, std::optional<double> maxSamples, std::optional<double> bitsPerSample) override {
+      static_assert(
+          bridging::getParameterCount(&T::decodeWavPack) == 5,
+          "Expected decodeWavPack(...) to have 5 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::decodeWavPack, jsInvoker_, instance_, std::move(inputPath), std::move(outputPath), std::move(maxSamples), std::move(bitsPerSample));
+    }
+    void addListener(jsi::Runtime &rt, jsi::String eventType) override {
+      static_assert(
+          bridging::getParameterCount(&T::addListener) == 2,
+          "Expected addListener(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::addListener, jsInvoker_, instance_, std::move(eventType));
+    }
+    void removeListeners(jsi::Runtime &rt, double count) override {
+      static_assert(
+          bridging::getParameterCount(&T::removeListeners) == 2,
+          "Expected removeListeners(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::removeListeners, jsInvoker_, instance_, std::move(count));
+    }
+
+  private:
+    friend class NativeTinyWavPackDecoderCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react

package/lib/module/NativeTinyWavPackDecoder.ts

@@ -0,0 +1,19 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  decodeWavPack(
+    inputPath: string,
+    outputPath: string,
+    maxSamples?: number,
+    bitsPerSample?: number
+  ): Promise<string>;
+
+  // Add these to satisfy NativeEventEmitter
+  addListener: (eventType: string) => void;
+  removeListeners: (count: number) => void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'TinyWavPackDecoderModule'
+);

package/lib/module/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import NativeTinyWavPackDecoder from './NativeTinyWavPackDecoder';
+import { NativeModules, NativeEventEmitter } from 'react-native';
+const {
+  TinyWavPackDecoderModule
+} = NativeModules;
+const emitter = new NativeEventEmitter(TinyWavPackDecoderModule);
+const TinyWavPackDecoder = {
+  decode: async (inputPath, outputPath, options = {}) => {
+    const {
+      maxSamples = -1,
+      bitsPerSample = 16
+    } = options;
+    if (![8, 16, 24, 32].includes(bitsPerSample)) {
+      throw new Error('bitsPerSample must be 8, 16, 24, or 32');
+    }
+    return NativeTinyWavPackDecoder.decodeWavPack(inputPath, outputPath, maxSamples, bitsPerSample);
+  },
+  /**
+   * Subscribe to native progress updates
+   */
+  addProgressListener: callback => {
+    return emitter.addListener('onProgressUpdate', event => {
+      if (typeof event?.progress === 'number') {
+        callback(event.progress);
+      }
+    });
+  },
+  /**
+   * Remove all native listeners for progress updates
+   */
+  removeAllListeners: () => {
+    emitter.removeAllListeners('onProgressUpdate');
+  }
+};
+export default TinyWavPackDecoder;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeTinyWavPackDecoder","NativeModules","NativeEventEmitter","TinyWavPackDecoderModule","emitter","TinyWavPackDecoder","decode","inputPath","outputPath","options","maxSamples","bitsPerSample","includes","Error","decodeWavPack","addProgressListener","callback","addListener","event","progress","removeAllListeners"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,wBAAwB,MAAM,4BAA4B;AACjE,SACEC,aAAa,EACbC,kBAAkB,QAEb,cAAc;AAOrB,MAAM;EAAEC;AAAyB,CAAC,GAAGF,aAAa;AAClD,MAAMG,OAAO,GAAG,IAAIF,kBAAkB,CAACC,wBAAwB,CAAC;AAEhE,MAAME,kBAAkB,GAAG;EACzBC,MAAM,EAAE,MAAAA,CACNC,SAAiB,EACjBC,UAAkB,EAClBC,OAAkC,GAAG,CAAC,CAAC,KACnB;IACpB,MAAM;MAAEC,UAAU,GAAG,CAAC,CAAC;MAAEC,aAAa,GAAG;IAAG,CAAC,GAAGF,OAAO;IAEvD,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAACG,QAAQ,CAACD,aAAa,CAAC,EAAE;MAC5C,MAAM,IAAIE,KAAK,CAAC,wCAAwC,CAAC;IAC3D;IAEA,OAAOb,wBAAwB,CAACc,aAAa,CAC3CP,SAAS,EACTC,UAAU,EACVE,UAAU,EACVC,aACF,CAAC;EACH,CAAC;EAED;AACF;AACA;EACEI,mBAAmB,EACjBC,QAAoC,IACZ;IACxB,OAAOZ,OAAO,CAACa,WAAW,CAAC,kBAAkB,EAAGC,KAAK,IAAK;MACxD,IAAI,OAAOA,KAAK,EAAEC,QAAQ,KAAK,QAAQ,EAAE;QACvCH,QAAQ,CAACE,KAAK,CAACC,QAAQ,CAAC;MAC1B;IACF,CAAC,CAAC;EACJ,CAAC;EAED;AACF;AACA;EACEC,kBAAkB,EAAEA,CAAA,KAAY;IAC9BhB,OAAO,CAACgB,kBAAkB,CAAC,kBAAkB,CAAC;EAChD;AACF,CAAC;AAED,eAAef,kBAAkB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}