react-native-tuner-engine 1.0.0

package/ios/IosAudioSource.mm

@@ -0,0 +1,174 @@
+#import "IosAudioSource.h"
+#import <AVFoundation/AVFoundation.h>
+
+@implementation IosAudioSource {
+  AVAudioEngine* _engine;
+  AVAudioInputNode* _inputNode;
+  float _sampleRate;
+  BOOL _isRunning;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _sampleRate = 48000.0f;
+    _isRunning = NO;
+    [self registerNotifications];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [self stop];
+}
+
+- (float)sampleRate {
+  return _sampleRate;
+}
+
+- (BOOL)startWithError:(NSError **)error {
+  if (_isRunning) return YES;
+
+  AVAudioSession* session = [AVAudioSession sharedInstance];
+
+  NSError* sessionError = nil;
+  [session setCategory:AVAudioSessionCategoryPlayAndRecord
+           withOptions:AVAudioSessionCategoryOptionDefaultToSpeaker |
+                       AVAudioSessionCategoryOptionAllowBluetooth
+                 error:&sessionError];
+  if (sessionError) {
+    if (error) *error = sessionError;
+    return NO;
+  }
+
+  [session setMode:AVAudioSessionModeMeasurement error:&sessionError];
+  if (sessionError) {
+    NSLog(@"[IosAudioSource] setMode error (non-fatal): %@", sessionError.localizedDescription);
+    sessionError = nil;
+  }
+
+  [session setPreferredSampleRate:48000.0 error:&sessionError];
+  if (sessionError) {
+    NSLog(@"[IosAudioSource] setPreferredSampleRate error (non-fatal): %@", sessionError.localizedDescription);
+    sessionError = nil;
+  }
+
+  [session setPreferredIOBufferDuration:0.0213 error:&sessionError];
+  if (sessionError) {
+    NSLog(@"[IosAudioSource] setPreferredIOBufferDuration error (non-fatal): %@", sessionError.localizedDescription);
+    sessionError = nil;
+  }
+  [session setActive:YES error:&sessionError];
+  if (sessionError) {
+    if (error) *error = sessionError;
+    return NO;
+  }
+
+  _sampleRate = (float)session.sampleRate;
+  _engine = [[AVAudioEngine alloc] init];
+  _inputNode = _engine.inputNode;
+
+  AVAudioFormat* recordingFormat =
+    [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                     sampleRate:_sampleRate
+                                       channels:1
+                                    interleaved:YES];
+
+  __weak __typeof__(self) weakSelf = self;
+
+  [_inputNode installTapOnBus:0
+                   bufferSize:2048
+                       format:recordingFormat
+                        block:^(AVAudioPCMBuffer* buffer, AVAudioTime* when) {
+    (void)when;
+    __strong __typeof__(weakSelf) strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_isRunning) return;
+
+    const float* data = buffer.floatChannelData[0];
+    const AVAudioFrameCount frames = buffer.frameLength;
+
+    AudioSamplesCallback cb = strongSelf.onSamples;
+    if (cb && frames > 0) {
+      cb(data, (int)frames, strongSelf->_sampleRate);
+    }
+  }];
+
+  NSError* engineError = nil;
+  [_engine prepare];
+  [_engine startAndReturnError:&engineError];
+  if (engineError) {
+    if (error) *error = engineError;
+    [_inputNode removeTapOnBus:0];
+    _engine = nil;
+    return NO;
+  }
+
+  _isRunning = YES;
+  return YES;
+}
+
+- (void)stop {
+  if (!_isRunning) return;
+  _isRunning = NO;
+
+  if (_inputNode) {
+    [_inputNode removeTapOnBus:0];
+  }
+  if (_engine && _engine.isRunning) {
+    [_engine stop];
+  }
+  _engine = nil;
+  _inputNode = nil;
+
+  [[AVAudioSession sharedInstance] setActive:NO
+    withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
+           error:nil];
+}
+
+#pragma mark - Notifications
+
+- (void)registerNotifications {
+  [[NSNotificationCenter defaultCenter]
+    addObserver:self
+       selector:@selector(handleInterruption:)
+           name:AVAudioSessionInterruptionNotification
+         object:nil];
+
+  [[NSNotificationCenter defaultCenter]
+    addObserver:self
+       selector:@selector(handleRouteChange:)
+           name:AVAudioSessionRouteChangeNotification
+         object:nil];
+}
+
+- (void)handleInterruption:(NSNotification *)notification {
+  NSDictionary* info = notification.userInfo;
+  AVAudioSessionInterruptionType type =
+    (AVAudioSessionInterruptionType)[info[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
+
+  if (type == AVAudioSessionInterruptionTypeBegan) {
+    [self stop];
+  } else if (type == AVAudioSessionInterruptionTypeEnded) {
+    AVAudioSessionInterruptionOptions options =
+      (AVAudioSessionInterruptionOptions)[info[AVAudioSessionInterruptionOptionKey] unsignedIntegerValue];
+    if (options & AVAudioSessionInterruptionOptionShouldResume) {
+      NSError* err = nil;
+      [self startWithError:&err];
+    }
+  }
+}
+
+- (void)handleRouteChange:(NSNotification *)notification {
+  NSDictionary* info = notification.userInfo;
+  AVAudioSessionRouteChangeReason reason =
+    (AVAudioSessionRouteChangeReason)[info[AVAudioSessionRouteChangeReasonKey] unsignedIntegerValue];
+
+  if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
+    [self stop];
+    NSError* err = nil;
+    [self startWithError:&err];
+  }
+}
+
+@end

package/ios/TunerBridge.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^PitchEventCallback)(NSDictionary* event);
+
+@interface TunerBridge : NSObject
+
+@property(nonatomic, copy, nullable) PitchEventCallback onPitch;
+
+- (void)configure:(NSDictionary *)opts;
+- (void)startWithCompletion:(void(^)(NSError* _Nullable error))completion;
+- (void)stop;
+- (void)setA4:(float)hz;
+- (void)setInstrument:(NSString *)name;
+- (void)setTuning:(NSString *)name;
+- (void)setTemperament:(NSString *)name;
+- (NSDictionary *)getStatus;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/TunerBridge.mm

@@ -0,0 +1,136 @@
+#import "TunerBridge.h"
+#import "IosAudioSource.h"
+#include "AudioFrameDispatcher.hpp"
+#include "PostProcessor.hpp"
+#include <memory>
+
+@implementation TunerBridge {
+  IosAudioSource* _audioSource;
+  std::unique_ptr<AudioFrameDispatcher> _dispatcher;
+  bool _isRunning;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _isRunning = false;
+  }
+  return self;
+}
+
+- (void)configure:(NSDictionary *)opts {
+  float sampleRate = opts[@"sampleRate"] ? [opts[@"sampleRate"] floatValue] : 48000.0f;
+  int frameSize    = opts[@"frameSize"]  ? [opts[@"frameSize"] intValue]   : 2048;
+  float overlapRatio = opts[@"overlapRatio"] ? [opts[@"overlapRatio"] floatValue] : 0.0f;
+
+  [self buildDispatcherWithSampleRate:sampleRate frameSize:frameSize overlapRatio:overlapRatio opts:opts];
+}
+
+- (void)buildDispatcherWithSampleRate:(float)sr frameSize:(int)fs overlapRatio:(float)overlap opts:(NSDictionary*)opts {
+  __weak __typeof__(self) weakSelf = self;
+
+  _dispatcher = std::make_unique<AudioFrameDispatcher>(fs, sr,
+    [weakSelf](const PitchResult& r) {
+      __strong __typeof__(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf || !strongSelf.onPitch) return;
+
+      NSDictionary* event = @{
+        @"hasPitch":         @(r.hasPitch),
+        @"frequency":        @(r.frequency),
+        @"confidence":       @(r.confidence),
+        @"rmsDb":            @(r.rmsDb),
+        @"noteName":         @(r.noteName.c_str()),
+        @"octave":           @(r.octave),
+        @"cents":            @(r.cents),
+        @"nearestString":    @(r.nearestString.c_str()),
+        @"stringDeviation":  @(r.stringDeviation)
+      };
+      strongSelf.onPitch(event);
+    },
+    overlap
+  );
+
+  if (opts[@"noiseGateDb"])       _dispatcher->setNoiseGateDb([opts[@"noiseGateDb"] floatValue]);
+  if (opts[@"confidenceThreshold"]) _dispatcher->setConfidenceThreshold([opts[@"confidenceThreshold"] floatValue]);
+  if (opts[@"minFrequency"] && opts[@"maxFrequency"]) {
+    _dispatcher->setFrequencyRange([opts[@"minFrequency"] floatValue], [opts[@"maxFrequency"] floatValue]);
+  }
+  if (opts[@"a4"]) _dispatcher->setA4([opts[@"a4"] floatValue]);
+  if (opts[@"hpfCutoffHz"]) _dispatcher->setHpfCutoff([opts[@"hpfCutoffHz"] floatValue]);
+  if (opts[@"emaAlpha"] || opts[@"hysteresisFrames"]) {
+    PostProcessor::Config cfg;
+    if (opts[@"emaAlpha"])          cfg.emaAlpha         = [opts[@"emaAlpha"] floatValue];
+    if (opts[@"hysteresisFrames"])  cfg.hysteresisFrames = [opts[@"hysteresisFrames"] intValue];
+    _dispatcher->setPostProcessorConfig(cfg);
+  }
+  if (opts[@"onsetDetection"]) {
+    _dispatcher->setOnsetDetectionEnabled([opts[@"onsetDetection"] boolValue]);
+  }
+}
+
+- (void)startWithCompletion:(void(^)(NSError* _Nullable error))completion {
+  if (_isRunning) {
+    completion(nil);
+    return;
+  }
+
+  _audioSource = [[IosAudioSource alloc] init];
+
+  // Spin up dispatcher if not yet configured
+  if (!_dispatcher) {
+    [self buildDispatcherWithSampleRate:48000.0f frameSize:2048 overlapRatio:0.0f opts:@{}];
+  }
+
+  __weak __typeof__(self) weakSelf = self;
+  _audioSource.onSamples = ^(const float* samples, int count, float sampleRate) {
+    __strong __typeof__(weakSelf) strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_dispatcher) return;
+    strongSelf->_dispatcher->push(samples, count);
+  };
+
+  NSError* error = nil;
+  if (![_audioSource startWithError:&error]) {
+    completion(error);
+    return;
+  }
+
+  // Sync dispatcher sample rate to what AVAudioSession actually gave us
+  const float actualSampleRate = _audioSource.sampleRate;
+  _dispatcher->setSampleRate(actualSampleRate);
+  _dispatcher->start();
+  _isRunning = true;
+
+  completion(nil);
+}
+
+- (void)stop {
+  if (!_isRunning) return;
+  _isRunning = false;
+
+  if (_dispatcher) _dispatcher->stop();
+  [_audioSource stop];
+  _audioSource = nil;
+}
+
+- (void)setA4:(float)hz {
+  if (_dispatcher) _dispatcher->setA4(hz);
+}
+
+- (void)setInstrument:(NSString *)name {
+  if (_dispatcher) _dispatcher->setInstrument(std::string([name UTF8String]));
+}
+
+- (void)setTuning:(NSString *)name {
+  if (_dispatcher) _dispatcher->setTuning(std::string([name UTF8String]));
+}
+
+- (void)setTemperament:(NSString *)name {}
+
+- (NSDictionary *)getStatus {
+  return @{
+    @"isRunning":    @(_isRunning),
+    @"engineReady":  @(_dispatcher != nullptr)
+  };
+}
+
+@end

package/ios/TunerEngine.h

@@ -0,0 +1,6 @@
+#import <React/RCTEventEmitter.h>
+#import <TunerEngineSpec/TunerEngineSpec.h>
+
+@interface TunerEngine : RCTEventEmitter <NativeTunerEngineSpec>
+
+@end

package/ios/TunerEngine.mm

@@ -0,0 +1,144 @@
+#import "TunerEngine.h"
+#import "TunerBridge.h"
+#import <AVFoundation/AVFoundation.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+
+@implementation TunerEngine {
+  TunerBridge* _tunerBridge;
+  std::shared_ptr<facebook::react::CallInvoker> _jsInvoker;
+}
+
+RCT_EXPORT_MODULE(TunerEngine)
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    [super addListener:@"onPitch"]; // keeps _listenerCount=1 for old-arch fallback
+    _tunerBridge = [[TunerBridge alloc] init];
+  }
+  return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"onPitch"];
+}
+
+- (void)addListener:(NSString *)eventName {}
+- (void)removeListeners:(double)count {}
+
+- (void)configure:(NSDictionary *)opts
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [_tunerBridge configure:opts];
+  resolve(nil);
+}
+
+- (void)start:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject {
+  [_tunerBridge startWithCompletion:^(NSError* error) {
+    if (error) {
+      reject(@"START_ERROR", error.localizedDescription, error);
+    } else {
+      resolve(nil);
+    }
+  }];
+}
+
+- (void)stop:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  [_tunerBridge stop];
+  resolve(nil);
+}
+
+- (void)setA4:(double)hz {
+  [_tunerBridge setA4:(float)hz];
+}
+
+- (void)setInstrument:(NSString *)name {
+  [_tunerBridge setInstrument:name];
+}
+
+- (void)setTuning:(NSString *)name {
+  [_tunerBridge setTuning:name];
+}
+
+- (void)setTemperament:(NSString *)name {
+  [_tunerBridge setTemperament:name];
+}
+
+- (void)requestPermission:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
+    resolve(@(granted));
+  }];
+}
+
+- (NSDictionary *)getStatus {
+  return [_tunerBridge getStatus];
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  _jsInvoker = params.jsInvoker;
+
+  __weak __typeof__(self) weakSelf = self;
+  _tunerBridge.onPitch = ^(NSDictionary* event) {
+    __strong __typeof__(weakSelf) strongSelf = weakSelf;
+    if (!strongSelf) return;
+
+    auto jsInvoker = strongSelf->_jsInvoker;
+    if (!jsInvoker) {
+      [strongSelf sendEventWithName:@"onPitch" body:event];
+      return;
+    }
+
+    // Extract primitives before crossing thread boundary
+    bool hasPitch     = [event[@"hasPitch"] boolValue];
+    double frequency  = [event[@"frequency"] doubleValue];
+    double confidence = [event[@"confidence"] doubleValue];
+    double rmsDb      = [event[@"rmsDb"] doubleValue];
+    std::string note  = std::string([event[@"noteName"] UTF8String]);
+    int octave        = [event[@"octave"] intValue];
+    double cents      = [event[@"cents"] doubleValue];
+    std::string nearestStr = event[@"nearestString"]
+        ? std::string([event[@"nearestString"] UTF8String]) : std::string();
+    double stringDev  = [event[@"stringDeviation"] doubleValue];
+
+    jsInvoker->invokeAsync([weakSelf, hasPitch, frequency, confidence, rmsDb,
+                            note, octave, cents, nearestStr, stringDev](facebook::jsi::Runtime& rt) {
+      __strong __typeof__(weakSelf) innerSelf = weakSelf;
+      if (!innerSelf) return; // Module deallocated — bail out
+
+      auto cb = rt.global().getProperty(rt, "__tunerEngineOnPitch");
+      if (!cb.isObject()) return;
+      auto fn = cb.asObject(rt);
+      if (!fn.isFunction(rt)) return;
+
+      facebook::jsi::Object obj(rt);
+      obj.setProperty(rt, "hasPitch",   facebook::jsi::Value(hasPitch));
+      obj.setProperty(rt, "frequency",  facebook::jsi::Value(frequency));
+      obj.setProperty(rt, "confidence", facebook::jsi::Value(confidence));
+      obj.setProperty(rt, "rmsDb",      facebook::jsi::Value(rmsDb));
+      obj.setProperty(rt, "noteName",
+          facebook::jsi::String::createFromUtf8(rt, note));
+      obj.setProperty(rt, "octave",     facebook::jsi::Value(octave));
+      obj.setProperty(rt, "cents",      facebook::jsi::Value(cents));
+      obj.setProperty(rt, "nearestString",
+          facebook::jsi::String::createFromUtf8(rt, nearestStr));
+      obj.setProperty(rt, "stringDeviation", facebook::jsi::Value(stringDev));
+
+      fn.asFunction(rt).call(rt, std::move(obj));
+    });
+  };
+
+  return std::make_shared<facebook::react::NativeTunerEngineSpecJSI>(params);
+}
+
+@end

package/lib/module/NativeTunerEngine.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('TunerEngine');
+//# sourceMappingURL=NativeTunerEngine.js.map

package/lib/module/NativeTunerEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeTunerEngine.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAgBpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,aAAa,CAAC","ignoreList":[]}

package/lib/module/TunerEngine.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { DeviceEventEmitter } from 'react-native';
+import NativeTunerEngine from "./NativeTunerEngine.js";
+class TunerEngine {
+  configure(opts) {
+    return NativeTunerEngine.configure(opts);
+  }
+  start() {
+    return NativeTunerEngine.start();
+  }
+  stop() {
+    return NativeTunerEngine.stop();
+  }
+  requestPermission() {
+    return NativeTunerEngine.requestPermission();
+  }
+  setA4(hz) {
+    NativeTunerEngine.setA4(hz);
+  }
+  setInstrument(name) {
+    NativeTunerEngine.setInstrument(name);
+  }
+  setTemperament(name) {
+    NativeTunerEngine.setTemperament(name);
+  }
+  setTuning(name) {
+    NativeTunerEngine.setTuning(name);
+  }
+  getStatus() {
+    return NativeTunerEngine.getStatus();
+  }
+  onPitch(callback) {
+    globalThis.__tunerEngineOnPitch = callback;
+    const sub = DeviceEventEmitter.addListener('onPitch', callback);
+    return () => {
+      globalThis.__tunerEngineOnPitch = undefined;
+      sub.remove();
+    };
+  }
+}
+export default new TunerEngine();
+//# sourceMappingURL=TunerEngine.js.map

package/lib/module/TunerEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DeviceEventEmitter","NativeTunerEngine","TunerEngine","configure","opts","start","stop","requestPermission","setA4","hz","setInstrument","name","setTemperament","setTuning","getStatus","onPitch","callback","globalThis","__tunerEngineOnPitch","sub","addListener","undefined","remove"],"sourceRoot":"../../src","sources":["TunerEngine.ts"],"mappings":";;AAAA,SAASA,kBAAkB,QAAQ,cAAc;AACjD,OAAOC,iBAAiB,MAAM,wBAAqB;AAanD,MAAMC,WAAW,CAAC;EAChBC,SAASA,CAACC,IAAiB,EAAiB;IAC1C,OAAOH,iBAAiB,CAACE,SAAS,CAACC,IAAI,CAAC;EAC1C;EAEAC,KAAKA,CAAA,EAAkB;IACrB,OAAOJ,iBAAiB,CAACI,KAAK,CAAC,CAAC;EAClC;EAEAC,IAAIA,CAAA,EAAkB;IACpB,OAAOL,iBAAiB,CAACK,IAAI,CAAC,CAAC;EACjC;EAEAC,iBAAiBA,CAAA,EAAqB;IACpC,OAAON,iBAAiB,CAACM,iBAAiB,CAAC,CAAC;EAC9C;EAEAC,KAAKA,CAACC,EAAU,EAAQ;IACtBR,iBAAiB,CAACO,KAAK,CAACC,EAAE,CAAC;EAC7B;EAEAC,aAAaA,CAACC,IAAgB,EAAQ;IACpCV,iBAAiB,CAACS,aAAa,CAACC,IAAI,CAAC;EACvC;EAEAC,cAAcA,CAACD,IAAiB,EAAQ;IACtCV,iBAAiB,CAACW,cAAc,CAACD,IAAI,CAAC;EACxC;EAEAE,SAASA,CAACF,IAAuB,EAAQ;IACvCV,iBAAiB,CAACY,SAAS,CAACF,IAAI,CAAC;EACnC;EAEAG,SAASA,CAAA,EAAiB;IACxB,OAAOb,iBAAiB,CAACa,SAAS,CAAC,CAAC;EACtC;EAEAC,OAAOA,CAACC,QAAuB,EAAe;IAC3CC,UAAU,CAASC,oBAAoB,GAAGF,QAAQ;IACnD,MAAMG,GAAG,GAAGnB,kBAAkB,CAACoB,WAAW,CAAC,SAAS,EAAEJ,QAAQ,CAAC;IAC/D,OAAO,MAAM;MACVC,UAAU,CAASC,oBAAoB,GAAGG,SAAS;MACpDF,GAAG,CAACG,MAAM,CAAC,CAAC;IACd,CAAC;EACH;AACF;AAEA,eAAe,IAAIpB,WAAW,CAAC,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { default as TunerEngine } from "./TunerEngine.js";
+export { useTuner } from "./useTuner.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["default","TunerEngine","useTuner"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,OAAO,IAAIC,WAAW,QAAQ,kBAAe;AACtD,SAASC,QAAQ,QAAQ,eAAY","ignoreList":[]}

package/lib/module/package.json

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

package/lib/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/useTuner.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import TunerEngine from "./TunerEngine.js";
+export function useTuner(opts = {}) {
+  const [latest, setLatest] = useState(null);
+  const [isRunning, setIsRunning] = useState(false);
+  const [error, setError] = useState(null);
+  const optsRef = useRef(opts);
+  optsRef.current = opts;
+  const unsubscribeRef = useRef(null);
+  const stop = useCallback(async () => {
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = null;
+    await TunerEngine.stop();
+    setIsRunning(false);
+  }, []);
+  const start = useCallback(async () => {
+    setError(null);
+    try {
+      const granted = await TunerEngine.requestPermission();
+      if (!granted) {
+        throw new Error('Microphone permission denied');
+      }
+      const {
+        instrument,
+        a4,
+        ...config
+      } = optsRef.current;
+      await TunerEngine.configure(config);
+      if (instrument) TunerEngine.setInstrument(instrument);
+      if (a4 !== undefined) TunerEngine.setA4(a4);
+      unsubscribeRef.current = TunerEngine.onPitch(setLatest);
+      await TunerEngine.start();
+      setIsRunning(true);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+      setIsRunning(false);
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      unsubscribeRef.current?.();
+      TunerEngine.stop();
+    };
+  }, []);
+  return {
+    start,
+    stop,
+    latest,
+    isRunning,
+    error
+  };
+}
+//# sourceMappingURL=useTuner.js.map

package/lib/module/useTuner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useEffect","useRef","useState","TunerEngine","useTuner","opts","latest","setLatest","isRunning","setIsRunning","error","setError","optsRef","current","unsubscribeRef","stop","start","granted","requestPermission","Error","instrument","a4","config","configure","setInstrument","undefined","setA4","onPitch","e","String"],"sourceRoot":"../../src","sources":["useTuner.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AAChE,OAAOC,WAAW,MAAM,kBAAe;AAgBvC,OAAO,SAASC,QAAQA,CAACC,IAAqB,GAAG,CAAC,CAAC,EAAkB;EACnE,MAAM,CAACC,MAAM,EAAEC,SAAS,CAAC,GAAGL,QAAQ,CAAoB,IAAI,CAAC;EAC7D,MAAM,CAACM,SAAS,EAAEC,YAAY,CAAC,GAAGP,QAAQ,CAAC,KAAK,CAAC;EACjD,MAAM,CAACQ,KAAK,EAAEC,QAAQ,CAAC,GAAGT,QAAQ,CAAe,IAAI,CAAC;EAEtD,MAAMU,OAAO,GAAGX,MAAM,CAACI,IAAI,CAAC;EAC5BO,OAAO,CAACC,OAAO,GAAGR,IAAI;EAEtB,MAAMS,cAAc,GAAGb,MAAM,CAAsB,IAAI,CAAC;EAExD,MAAMc,IAAI,GAAGhB,WAAW,CAAC,YAAY;IACnCe,cAAc,CAACD,OAAO,GAAG,CAAC;IAC1BC,cAAc,CAACD,OAAO,GAAG,IAAI;IAC7B,MAAMV,WAAW,CAACY,IAAI,CAAC,CAAC;IACxBN,YAAY,CAAC,KAAK,CAAC;EACrB,CAAC,EAAE,EAAE,CAAC;EAEN,MAAMO,KAAK,GAAGjB,WAAW,CAAC,YAAY;IACpCY,QAAQ,CAAC,IAAI,CAAC;IACd,IAAI;MACF,MAAMM,OAAO,GAAG,MAAMd,WAAW,CAACe,iBAAiB,CAAC,CAAC;MACrD,IAAI,CAACD,OAAO,EAAE;QACZ,MAAM,IAAIE,KAAK,CAAC,8BAA8B,CAAC;MACjD;MAEA,MAAM;QAAEC,UAAU;QAAEC,EAAE;QAAE,GAAGC;MAAO,CAAC,GAAGV,OAAO,CAACC,OAAO;MACrD,MAAMV,WAAW,CAACoB,SAAS,CAACD,MAAM,CAAC;MAEnC,IAAIF,UAAU,EAAEjB,WAAW,CAACqB,aAAa,CAACJ,UAAU,CAAC;MACrD,IAAIC,EAAE,KAAKI,SAAS,EAAEtB,WAAW,CAACuB,KAAK,CAACL,EAAE,CAAC;MAE3CP,cAAc,CAACD,OAAO,GAAGV,WAAW,CAACwB,OAAO,CAACpB,SAAS,CAAC;MAEvD,MAAMJ,WAAW,CAACa,KAAK,CAAC,CAAC;MACzBP,YAAY,CAAC,IAAI,CAAC;IACpB,CAAC,CAAC,OAAOmB,CAAC,EAAE;MACVjB,QAAQ,CAACiB,CAAC,YAAYT,KAAK,GAAGS,CAAC,GAAG,IAAIT,KAAK,CAACU,MAAM,CAACD,CAAC,CAAC,CAAC,CAAC;MACvDnB,YAAY,CAAC,KAAK,CAAC;IACrB;EACF,CAAC,EAAE,EAAE,CAAC;EAENT,SAAS,CAAC,MAAM;IACd,OAAO,MAAM;MACXc,cAAc,CAACD,OAAO,GAAG,CAAC;MAC1BV,WAAW,CAACY,IAAI,CAAC,CAAC;IACpB,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO;IAAEC,KAAK;IAAED,IAAI;IAAET,MAAM;IAAEE,SAAS;IAAEE;EAAM,CAAC;AAClD","ignoreList":[]}

package/lib/typescript/package.json

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

package/lib/typescript/src/NativeTunerEngine.d.ts

@@ -0,0 +1,17 @@
+import { type TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    configure(opts: Object): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    setA4(hz: number): void;
+    setInstrument(name: string): void;
+    setTemperament(name: string): void;
+    setTuning(name: string): void;
+    requestPermission(): Promise<boolean>;
+    getStatus(): Object;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeTunerEngine.d.ts.map

package/lib/typescript/src/NativeTunerEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeTunerEngine.d.ts","sourceRoot":"","sources":["../../../src/NativeTunerEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,SAAS,IAAI,MAAM,CAAC;IACpB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;;AAED,wBAAqE"}

package/lib/typescript/src/TunerEngine.d.ts

@@ -0,0 +1,18 @@
+import type { EngineStatus, Instrument, PitchEvent, Temperament, TunerConfig, TuningPreset } from './types';
+type PitchCallback = (event: PitchEvent) => void;
+type Unsubscribe = () => void;
+declare class TunerEngine {
+    configure(opts: TunerConfig): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    requestPermission(): Promise<boolean>;
+    setA4(hz: number): void;
+    setInstrument(name: Instrument): void;
+    setTemperament(name: Temperament): void;
+    setTuning(name: TuningPreset | ''): void;
+    getStatus(): EngineStatus;
+    onPitch(callback: PitchCallback): Unsubscribe;
+}
+declare const _default: TunerEngine;
+export default _default;
+//# sourceMappingURL=TunerEngine.d.ts.map

package/lib/typescript/src/TunerEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TunerEngine.d.ts","sourceRoot":"","sources":["../../../src/TunerEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,YAAY,EACb,MAAM,SAAS,CAAC;AAEjB,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AACjD,KAAK,WAAW,GAAG,MAAM,IAAI,CAAC;AAE9B,cAAM,WAAW;IACf,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIvB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAIrC,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIvC,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,EAAE,GAAG,IAAI;IAIxC,SAAS,IAAI,YAAY;IAIzB,OAAO,CAAC,QAAQ,EAAE,aAAa,GAAG,WAAW;CAQ9C;;AAED,wBAAiC"}