hamlib 0.1.9 → 0.1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/package.json +3 -2
  2. package/prebuilds/darwin-arm64/hamlib.node +0 -0
  3. package/prebuilds/linux-arm64/hamlib.node +0 -0
  4. package/prebuilds/linux-x64/hamlib.node +0 -0
  5. package/src/hamlib.cpp +392 -104
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "hamlib",
3
- "version": "0.1.9",
3
+ "version": "0.1.10",
4
4
  "description": "Node.js wrapper for hamlib radio control library",
5
5
  "main": "index.js",
6
6
  "module": "lib/index.mjs",
@@ -65,5 +65,6 @@
65
65
  "cpu": [
66
66
  "x64",
67
67
  "arm64"
68
- ]
68
+ ],
69
+ "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
69
70
  }
package/prebuilds/darwin-arm64/hamlib.node CHANGED
Binary file
package/prebuilds/linux-arm64/hamlib.node CHANGED
Binary file
package/prebuilds/linux-x64/hamlib.node CHANGED
Binary file
package/src/hamlib.cpp CHANGED
@@ -54,7 +54,11 @@ public:
54
54
 
55
55
  void OnOK() override {
56
56
  Napi::Env env = Env();
57
- deferred_.Resolve(Napi::Number::New(env, result_code_));
57
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
58
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
59
+ } else {
60
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
61
+ }
58
62
  }
59
63
 
60
64
  void OnError(const Napi::Error& e) override {
@@ -77,7 +81,11 @@ public:
77
81
 
78
82
  void OnOK() override {
79
83
  Napi::Env env = Env();
80
- deferred_.Resolve(Napi::Number::New(env, result_code_));
84
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
85
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
86
+ } else {
87
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
88
+ }
81
89
  }
82
90
 
83
91
  void OnError(const Napi::Error& e) override {
@@ -104,7 +112,11 @@ public:
104
112
 
105
113
  void OnOK() override {
106
114
  Napi::Env env = Env();
107
- deferred_.Resolve(Napi::Number::New(env, freq_));
115
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
116
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
117
+ } else {
118
+ deferred_.Resolve(Napi::Number::New(env, freq_));
119
+ }
108
120
  }
109
121
 
110
122
  void OnError(const Napi::Error& e) override {
@@ -131,7 +143,11 @@ public:
131
143
 
132
144
  void OnOK() override {
133
145
  Napi::Env env = Env();
134
- deferred_.Resolve(Napi::Number::New(env, result_code_));
146
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
147
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
148
+ } else {
149
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
150
+ }
135
151
  }
136
152
 
137
153
  void OnError(const Napi::Error& e) override {
@@ -159,12 +175,16 @@ public:
159
175
 
160
176
  void OnOK() override {
161
177
  Napi::Env env = Env();
162
- Napi::Object obj = Napi::Object::New(env);
163
- // Convert mode to string using rig_strrmode
164
- const char* mode_str = rig_strrmode(mode_);
165
- obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
166
- obj.Set(Napi::String::New(env, "bandwidth"), width_);
167
- deferred_.Resolve(obj);
178
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
179
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
180
+ } else {
181
+ Napi::Object obj = Napi::Object::New(env);
182
+ // Convert mode to string using rig_strrmode
183
+ const char* mode_str = rig_strrmode(mode_);
184
+ obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
185
+ obj.Set(Napi::String::New(env, "bandwidth"), width_);
186
+ deferred_.Resolve(obj);
187
+ }
168
188
  }
169
189
 
170
190
  void OnError(const Napi::Error& e) override {
@@ -191,7 +211,11 @@ public:
191
211
 
192
212
  void OnOK() override {
193
213
  Napi::Env env = Env();
194
- deferred_.Resolve(Napi::Number::New(env, result_code_));
214
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
215
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
216
+ } else {
217
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
218
+ }
195
219
  }
196
220
 
197
221
  void OnError(const Napi::Error& e) override {
@@ -217,7 +241,11 @@ public:
217
241
 
218
242
  void OnOK() override {
219
243
  Napi::Env env = Env();
220
- deferred_.Resolve(Napi::Number::New(env, strength_));
244
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
245
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
246
+ } else {
247
+ deferred_.Resolve(Napi::Number::New(env, strength_));
248
+ }
221
249
  }
222
250
 
223
251
  void OnError(const Napi::Error& e) override {
@@ -244,7 +272,11 @@ public:
244
272
 
245
273
  void OnOK() override {
246
274
  Napi::Env env = Env();
247
- deferred_.Resolve(Napi::Number::New(env, result_code_));
275
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
276
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
277
+ } else {
278
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
279
+ }
248
280
  }
249
281
 
250
282
  void OnError(const Napi::Error& e) override {
@@ -273,7 +305,11 @@ public:
273
305
 
274
306
  void OnOK() override {
275
307
  Napi::Env env = Env();
276
- deferred_.Resolve(Napi::Number::New(env, value_.f));
308
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
309
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
310
+ } else {
311
+ deferred_.Resolve(Napi::Number::New(env, value_.f));
312
+ }
277
313
  }
278
314
 
279
315
  void OnError(const Napi::Error& e) override {
@@ -300,7 +336,11 @@ public:
300
336
 
301
337
  void OnOK() override {
302
338
  Napi::Env env = Env();
303
- deferred_.Resolve(Napi::Number::New(env, result_code_));
339
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
340
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
341
+ } else {
342
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
343
+ }
304
344
  }
305
345
 
306
346
  void OnError(const Napi::Error& e) override {
@@ -327,7 +367,11 @@ public:
327
367
 
328
368
  void OnOK() override {
329
369
  Napi::Env env = Env();
330
- deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
370
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
371
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
372
+ } else {
373
+ deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
374
+ }
331
375
  }
332
376
 
333
377
  void OnError(const Napi::Error& e) override {
@@ -354,7 +398,11 @@ public:
354
398
 
355
399
  void OnOK() override {
356
400
  Napi::Env env = Env();
357
- deferred_.Resolve(Napi::Number::New(env, result_code_));
401
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
402
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
403
+ } else {
404
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
405
+ }
358
406
  }
359
407
 
360
408
  void OnError(const Napi::Error& e) override {
@@ -436,7 +484,11 @@ public:
436
484
 
437
485
  void OnOK() override {
438
486
  Napi::Env env = Env();
439
- deferred_.Resolve(Napi::Number::New(env, result_code_));
487
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
488
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
489
+ } else {
490
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
491
+ }
440
492
  }
441
493
 
442
494
  void OnError(const Napi::Error& e) override {
@@ -462,7 +514,11 @@ public:
462
514
 
463
515
  void OnOK() override {
464
516
  Napi::Env env = Env();
465
- deferred_.Resolve(Napi::Number::New(env, result_code_));
517
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
518
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
519
+ } else {
520
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
521
+ }
466
522
  }
467
523
 
468
524
  void OnError(const Napi::Error& e) override {
@@ -488,7 +544,11 @@ public:
488
544
 
489
545
  void OnOK() override {
490
546
  Napi::Env env = Env();
491
- deferred_.Resolve(Napi::Number::New(env, rit_offset_));
547
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
548
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
549
+ } else {
550
+ deferred_.Resolve(Napi::Number::New(env, rit_offset_));
551
+ }
492
552
  }
493
553
 
494
554
  void OnError(const Napi::Error& e) override {
@@ -514,7 +574,11 @@ public:
514
574
 
515
575
  void OnOK() override {
516
576
  Napi::Env env = Env();
517
- deferred_.Resolve(Napi::Number::New(env, result_code_));
577
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
578
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
579
+ } else {
580
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
581
+ }
518
582
  }
519
583
 
520
584
  void OnError(const Napi::Error& e) override {
@@ -540,7 +604,11 @@ public:
540
604
 
541
605
  void OnOK() override {
542
606
  Napi::Env env = Env();
543
- deferred_.Resolve(Napi::Number::New(env, xit_offset_));
607
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
608
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
609
+ } else {
610
+ deferred_.Resolve(Napi::Number::New(env, xit_offset_));
611
+ }
544
612
  }
545
613
 
546
614
  void OnError(const Napi::Error& e) override {
@@ -574,7 +642,11 @@ public:
574
642
 
575
643
  void OnOK() override {
576
644
  Napi::Env env = Env();
577
- deferred_.Resolve(Napi::Number::New(env, result_code_));
645
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
646
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
647
+ } else {
648
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
649
+ }
578
650
  }
579
651
 
580
652
  void OnError(const Napi::Error& e) override {
@@ -597,7 +669,11 @@ public:
597
669
 
598
670
  void OnOK() override {
599
671
  Napi::Env env = Env();
600
- deferred_.Resolve(Napi::Number::New(env, result_code_));
672
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
673
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
674
+ } else {
675
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
676
+ }
601
677
  }
602
678
 
603
679
  void OnError(const Napi::Error& e) override {
@@ -624,7 +700,11 @@ public:
624
700
 
625
701
  void OnOK() override {
626
702
  Napi::Env env = Env();
627
- deferred_.Resolve(Napi::Number::New(env, tx_freq_));
703
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
704
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
705
+ } else {
706
+ deferred_.Resolve(Napi::Number::New(env, tx_freq_));
707
+ }
628
708
  }
629
709
 
630
710
  void OnError(const Napi::Error& e) override {
@@ -651,7 +731,11 @@ public:
651
731
 
652
732
  void OnOK() override {
653
733
  Napi::Env env = Env();
654
- deferred_.Resolve(Napi::Number::New(env, result_code_));
734
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
735
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
736
+ } else {
737
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
738
+ }
655
739
  }
656
740
 
657
741
  void OnError(const Napi::Error& e) override {
@@ -679,16 +763,20 @@ public:
679
763
 
680
764
  void OnOK() override {
681
765
  Napi::Env env = Env();
682
- Napi::Object obj = Napi::Object::New(env);
683
- obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
684
-
685
- const char* vfo_str = "VFO-B";
686
- if (tx_vfo_ == RIG_VFO_A) {
687
- vfo_str = "VFO-A";
766
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
767
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
768
+ } else {
769
+ Napi::Object obj = Napi::Object::New(env);
770
+ obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
771
+
772
+ const char* vfo_str = "VFO-B";
773
+ if (tx_vfo_ == RIG_VFO_A) {
774
+ vfo_str = "VFO-A";
775
+ }
776
+ obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
777
+
778
+ deferred_.Resolve(obj);
688
779
  }
689
- obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
690
-
691
- deferred_.Resolve(obj);
692
780
  }
693
781
 
694
782
  void OnError(const Napi::Error& e) override {
@@ -716,7 +804,11 @@ public:
716
804
 
717
805
  void OnOK() override {
718
806
  Napi::Env env = Env();
719
- deferred_.Resolve(Napi::Number::New(env, result_code_));
807
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
808
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
809
+ } else {
810
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
811
+ }
720
812
  }
721
813
 
722
814
  void OnError(const Napi::Error& e) override {
@@ -805,7 +897,11 @@ public:
805
897
 
806
898
  void OnOK() override {
807
899
  Napi::Env env = Env();
808
- deferred_.Resolve(Napi::Number::New(env, result_code_));
900
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
901
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
902
+ } else {
903
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
904
+ }
809
905
  }
810
906
 
811
907
  void OnError(const Napi::Error& e) override {
@@ -833,7 +929,11 @@ public:
833
929
 
834
930
  void OnOK() override {
835
931
  Napi::Env env = Env();
836
- deferred_.Resolve(Napi::Number::New(env, result_code_));
932
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
933
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
934
+ } else {
935
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
936
+ }
837
937
  }
838
938
 
839
939
  void OnError(const Napi::Error& e) override {
@@ -857,7 +957,11 @@ public:
857
957
 
858
958
  void OnOK() override {
859
959
  Napi::Env env = Env();
860
- deferred_.Resolve(Napi::Number::New(env, result_code_));
960
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
961
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
962
+ } else {
963
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
964
+ }
861
965
  }
862
966
 
863
967
  void OnError(const Napi::Error& e) override {
@@ -885,7 +989,11 @@ public:
885
989
 
886
990
  void OnOK() override {
887
991
  Napi::Env env = Env();
888
- deferred_.Resolve(Napi::Number::New(env, result_code_));
992
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
993
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
994
+ } else {
995
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
996
+ }
889
997
  }
890
998
 
891
999
  void OnError(const Napi::Error& e) override {
@@ -909,7 +1017,11 @@ public:
909
1017
 
910
1018
  void OnOK() override {
911
1019
  Napi::Env env = Env();
912
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1020
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1021
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1022
+ } else {
1023
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1024
+ }
913
1025
  }
914
1026
 
915
1027
  void OnError(const Napi::Error& e) override {
@@ -936,7 +1048,11 @@ public:
936
1048
 
937
1049
  void OnOK() override {
938
1050
  Napi::Env env = Env();
939
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1051
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1052
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1053
+ } else {
1054
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1055
+ }
940
1056
  }
941
1057
 
942
1058
  void OnError(const Napi::Error& e) override {
@@ -967,14 +1083,18 @@ public:
967
1083
 
968
1084
  void OnOK() override {
969
1085
  Napi::Env env = Env();
970
- Napi::Object result = Napi::Object::New(env);
971
-
972
- result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
973
- result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
974
- result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
975
- result.Set("option", Napi::Number::New(env, option_.f));
976
-
977
- deferred_.Resolve(result);
1086
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1087
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1088
+ } else {
1089
+ Napi::Object result = Napi::Object::New(env);
1090
+
1091
+ result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
1092
+ result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
1093
+ result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
1094
+ result.Set("option", Napi::Number::New(env, option_.f));
1095
+
1096
+ deferred_.Resolve(result);
1097
+ }
978
1098
  }
979
1099
 
980
1100
  void OnError(const Napi::Error& e) override {
@@ -1006,7 +1126,11 @@ public:
1006
1126
 
1007
1127
  void OnOK() override {
1008
1128
  Napi::Env env = Env();
1009
- deferred_.Resolve(Napi::Number::New(env, mwpower_));
1129
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1130
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1131
+ } else {
1132
+ deferred_.Resolve(Napi::Number::New(env, mwpower_));
1133
+ }
1010
1134
  }
1011
1135
 
1012
1136
  void OnError(const Napi::Error& e) override {
@@ -1036,7 +1160,11 @@ public:
1036
1160
 
1037
1161
  void OnOK() override {
1038
1162
  Napi::Env env = Env();
1039
- deferred_.Resolve(Napi::Number::New(env, power_));
1163
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1164
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1165
+ } else {
1166
+ deferred_.Resolve(Napi::Number::New(env, power_));
1167
+ }
1040
1168
  }
1041
1169
 
1042
1170
  void OnError(const Napi::Error& e) override {
@@ -1066,7 +1194,11 @@ public:
1066
1194
 
1067
1195
  void OnOK() override {
1068
1196
  Napi::Env env = Env();
1069
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1197
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1198
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1199
+ } else {
1200
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1201
+ }
1070
1202
  }
1071
1203
 
1072
1204
  void OnError(const Napi::Error& e) override {
@@ -1095,12 +1227,16 @@ public:
1095
1227
 
1096
1228
  void OnOK() override {
1097
1229
  Napi::Env env = Env();
1098
- Napi::Object obj = Napi::Object::New(env);
1099
- // Convert mode to string using rig_strrmode
1100
- const char* mode_str = rig_strrmode(tx_mode_);
1101
- obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
1102
- obj.Set(Napi::String::New(env, "width"), tx_width_);
1103
- deferred_.Resolve(obj);
1230
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1231
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1232
+ } else {
1233
+ Napi::Object obj = Napi::Object::New(env);
1234
+ // Convert mode to string using rig_strrmode
1235
+ const char* mode_str = rig_strrmode(tx_mode_);
1236
+ obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
1237
+ obj.Set(Napi::String::New(env, "width"), tx_width_);
1238
+ deferred_.Resolve(obj);
1239
+ }
1104
1240
  }
1105
1241
 
1106
1242
  void OnError(const Napi::Error& e) override {
@@ -1254,7 +1390,11 @@ public:
1254
1390
 
1255
1391
  void OnOK() override {
1256
1392
  Napi::Env env = Env();
1257
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1393
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1394
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1395
+ } else {
1396
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1397
+ }
1258
1398
  }
1259
1399
 
1260
1400
  void OnError(const Napi::Error& e) override {
@@ -1365,7 +1505,11 @@ public:
1365
1505
 
1366
1506
  void OnOK() override {
1367
1507
  Napi::Env env = Env();
1368
- deferred_.Resolve(Napi::String::New(env, param_value_));
1508
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1509
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1510
+ } else {
1511
+ deferred_.Resolve(Napi::String::New(env, param_value_));
1512
+ }
1369
1513
  }
1370
1514
 
1371
1515
  void OnError(const Napi::Error& e) override {
@@ -1414,7 +1558,11 @@ public:
1414
1558
 
1415
1559
  void OnOK() override {
1416
1560
  Napi::Env env = Env();
1417
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1561
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1562
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1563
+ } else {
1564
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1565
+ }
1418
1566
  }
1419
1567
 
1420
1568
  void OnError(const Napi::Error& e) override {
@@ -1469,7 +1617,11 @@ public:
1469
1617
 
1470
1618
  void OnOK() override {
1471
1619
  Napi::Env env = Env();
1472
- deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
1620
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1621
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1622
+ } else {
1623
+ deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
1624
+ }
1473
1625
  }
1474
1626
 
1475
1627
  void OnError(const Napi::Error& e) override {
@@ -1519,7 +1671,11 @@ public:
1519
1671
 
1520
1672
  void OnOK() override {
1521
1673
  Napi::Env env = Env();
1522
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1674
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1675
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1676
+ } else {
1677
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1678
+ }
1523
1679
  }
1524
1680
 
1525
1681
  void OnError(const Napi::Error& e) override {
@@ -1577,7 +1733,11 @@ public:
1577
1733
 
1578
1734
  void OnOK() override {
1579
1735
  Napi::Env env = Env();
1580
- deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
1736
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1737
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1738
+ } else {
1739
+ deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
1740
+ }
1581
1741
  }
1582
1742
 
1583
1743
  void OnError(const Napi::Error& e) override {
@@ -1604,7 +1764,11 @@ public:
1604
1764
 
1605
1765
  void OnOK() override {
1606
1766
  Napi::Env env = Env();
1607
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1767
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1768
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1769
+ } else {
1770
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1771
+ }
1608
1772
  }
1609
1773
 
1610
1774
  void OnError(const Napi::Error& e) override {
@@ -1630,7 +1794,11 @@ public:
1630
1794
 
1631
1795
  void OnOK() override {
1632
1796
  Napi::Env env = Env();
1633
- deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
1797
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1798
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1799
+ } else {
1800
+ deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
1801
+ }
1634
1802
  }
1635
1803
 
1636
1804
  void OnError(const Napi::Error& e) override {
@@ -1657,7 +1825,11 @@ public:
1657
1825
 
1658
1826
  void OnOK() override {
1659
1827
  Napi::Env env = Env();
1660
- deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
1828
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1829
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1830
+ } else {
1831
+ deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
1832
+ }
1661
1833
  }
1662
1834
 
1663
1835
  void OnError(const Napi::Error& e) override {
@@ -1685,7 +1857,11 @@ public:
1685
1857
 
1686
1858
  void OnOK() override {
1687
1859
  Napi::Env env = Env();
1688
- deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
1860
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1861
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1862
+ } else {
1863
+ deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
1864
+ }
1689
1865
  }
1690
1866
 
1691
1867
  void OnError(const Napi::Error& e) override {
@@ -1713,7 +1889,11 @@ public:
1713
1889
 
1714
1890
  void OnOK() override {
1715
1891
  Napi::Env env = Env();
1716
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1892
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1893
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1894
+ } else {
1895
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1896
+ }
1717
1897
  }
1718
1898
 
1719
1899
  void OnError(const Napi::Error& e) override {
@@ -1740,7 +1920,11 @@ public:
1740
1920
 
1741
1921
  void OnOK() override {
1742
1922
  Napi::Env env = Env();
1743
- deferred_.Resolve(Napi::Number::New(env, ts_));
1923
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1924
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1925
+ } else {
1926
+ deferred_.Resolve(Napi::Number::New(env, ts_));
1927
+ }
1744
1928
  }
1745
1929
 
1746
1930
  void OnError(const Napi::Error& e) override {
@@ -1768,7 +1952,11 @@ public:
1768
1952
 
1769
1953
  void OnOK() override {
1770
1954
  Napi::Env env = Env();
1771
- deferred_.Resolve(Napi::Number::New(env, result_code_));
1955
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
1956
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
1957
+ } else {
1958
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
1959
+ }
1772
1960
  }
1773
1961
 
1774
1962
  void OnError(const Napi::Error& e) override {
@@ -1823,7 +2011,11 @@ public:
1823
2011
 
1824
2012
  void OnOK() override {
1825
2013
  Napi::Env env = Env();
1826
- deferred_.Resolve(Napi::Number::New(env, result_code_));
2014
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
2015
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
2016
+ } else {
2017
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
2018
+ }
1827
2019
  }
1828
2020
 
1829
2021
  void OnError(const Napi::Error& e) override {
@@ -1850,7 +2042,11 @@ public:
1850
2042
 
1851
2043
  void OnOK() override {
1852
2044
  Napi::Env env = Env();
1853
- deferred_.Resolve(Napi::Number::New(env, offset_));
2045
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
2046
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
2047
+ } else {
2048
+ deferred_.Resolve(Napi::Number::New(env, offset_));
2049
+ }
1854
2050
  }
1855
2051
 
1856
2052
  void OnError(const Napi::Error& e) override {
@@ -3788,7 +3984,11 @@ public:
3788
3984
 
3789
3985
  void OnOK() override {
3790
3986
  Napi::Env env = Env();
3791
- deferred_.Resolve(Napi::Number::New(env, result_code_));
3987
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
3988
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
3989
+ } else {
3990
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
3991
+ }
3792
3992
  }
3793
3993
 
3794
3994
  void OnError(const Napi::Error& e) override {
@@ -3815,7 +4015,11 @@ public:
3815
4015
 
3816
4016
  void OnOK() override {
3817
4017
  Napi::Env env = Env();
3818
- deferred_.Resolve(Napi::Number::New(env, tone_));
4018
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4019
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4020
+ } else {
4021
+ deferred_.Resolve(Napi::Number::New(env, tone_));
4022
+ }
3819
4023
  }
3820
4024
 
3821
4025
  void OnError(const Napi::Error& e) override {
@@ -3842,7 +4046,11 @@ public:
3842
4046
 
3843
4047
  void OnOK() override {
3844
4048
  Napi::Env env = Env();
3845
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4049
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4050
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4051
+ } else {
4052
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4053
+ }
3846
4054
  }
3847
4055
 
3848
4056
  void OnError(const Napi::Error& e) override {
@@ -3869,7 +4077,11 @@ public:
3869
4077
 
3870
4078
  void OnOK() override {
3871
4079
  Napi::Env env = Env();
3872
- deferred_.Resolve(Napi::Number::New(env, code_));
4080
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4081
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4082
+ } else {
4083
+ deferred_.Resolve(Napi::Number::New(env, code_));
4084
+ }
3873
4085
  }
3874
4086
 
3875
4087
  void OnError(const Napi::Error& e) override {
@@ -3896,7 +4108,11 @@ public:
3896
4108
 
3897
4109
  void OnOK() override {
3898
4110
  Napi::Env env = Env();
3899
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4111
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4112
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4113
+ } else {
4114
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4115
+ }
3900
4116
  }
3901
4117
 
3902
4118
  void OnError(const Napi::Error& e) override {
@@ -3923,7 +4139,11 @@ public:
3923
4139
 
3924
4140
  void OnOK() override {
3925
4141
  Napi::Env env = Env();
3926
- deferred_.Resolve(Napi::Number::New(env, tone_));
4142
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4143
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4144
+ } else {
4145
+ deferred_.Resolve(Napi::Number::New(env, tone_));
4146
+ }
3927
4147
  }
3928
4148
 
3929
4149
  void OnError(const Napi::Error& e) override {
@@ -3950,7 +4170,11 @@ public:
3950
4170
 
3951
4171
  void OnOK() override {
3952
4172
  Napi::Env env = Env();
3953
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4173
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4174
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4175
+ } else {
4176
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4177
+ }
3954
4178
  }
3955
4179
 
3956
4180
  void OnError(const Napi::Error& e) override {
@@ -3977,7 +4201,11 @@ public:
3977
4201
 
3978
4202
  void OnOK() override {
3979
4203
  Napi::Env env = Env();
3980
- deferred_.Resolve(Napi::Number::New(env, code_));
4204
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4205
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4206
+ } else {
4207
+ deferred_.Resolve(Napi::Number::New(env, code_));
4208
+ }
3981
4209
  }
3982
4210
 
3983
4211
  void OnError(const Napi::Error& e) override {
@@ -4005,7 +4233,11 @@ public:
4005
4233
 
4006
4234
  void OnOK() override {
4007
4235
  Napi::Env env = Env();
4008
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4236
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4237
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4238
+ } else {
4239
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4240
+ }
4009
4241
  }
4010
4242
 
4011
4243
  void OnError(const Napi::Error& e) override {
@@ -4034,7 +4266,11 @@ public:
4034
4266
 
4035
4267
  void OnOK() override {
4036
4268
  Napi::Env env = Env();
4037
- deferred_.Resolve(Napi::Number::New(env, value_.f));
4269
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4270
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4271
+ } else {
4272
+ deferred_.Resolve(Napi::Number::New(env, value_.f));
4273
+ }
4038
4274
  }
4039
4275
 
4040
4276
  void OnError(const Napi::Error& e) override {
@@ -4062,7 +4298,11 @@ public:
4062
4298
 
4063
4299
  void OnOK() override {
4064
4300
  Napi::Env env = Env();
4065
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4301
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4302
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4303
+ } else {
4304
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4305
+ }
4066
4306
  }
4067
4307
 
4068
4308
  void OnError(const Napi::Error& e) override {
@@ -4092,10 +4332,14 @@ public:
4092
4332
 
4093
4333
  void OnOK() override {
4094
4334
  Napi::Env env = Env();
4095
- Napi::Object obj = Napi::Object::New(env);
4096
- obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
4097
- obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
4098
- deferred_.Resolve(obj);
4335
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4336
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4337
+ } else {
4338
+ Napi::Object obj = Napi::Object::New(env);
4339
+ obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
4340
+ obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
4341
+ deferred_.Resolve(obj);
4342
+ }
4099
4343
  }
4100
4344
 
4101
4345
  void OnError(const Napi::Error& e) override {
@@ -4125,7 +4369,11 @@ public:
4125
4369
 
4126
4370
  void OnOK() override {
4127
4371
  Napi::Env env = Env();
4128
- deferred_.Resolve(Napi::Number::New(env, ch_));
4372
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4373
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4374
+ } else {
4375
+ deferred_.Resolve(Napi::Number::New(env, ch_));
4376
+ }
4129
4377
  }
4130
4378
 
4131
4379
  void OnError(const Napi::Error& e) override {
@@ -4152,7 +4400,11 @@ public:
4152
4400
 
4153
4401
  void OnOK() override {
4154
4402
  Napi::Env env = Env();
4155
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4403
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4404
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4405
+ } else {
4406
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4407
+ }
4156
4408
  }
4157
4409
 
4158
4410
  void OnError(const Napi::Error& e) override {
@@ -4182,7 +4434,11 @@ public:
4182
4434
 
4183
4435
  void OnOK() override {
4184
4436
  Napi::Env env = Env();
4185
- deferred_.Resolve(Napi::Number::New(env, count_));
4437
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4438
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4439
+ } else {
4440
+ deferred_.Resolve(Napi::Number::New(env, count_));
4441
+ }
4186
4442
  }
4187
4443
 
4188
4444
  void OnError(const Napi::Error& e) override {
@@ -4209,7 +4465,11 @@ public:
4209
4465
 
4210
4466
  void OnOK() override {
4211
4467
  Napi::Env env = Env();
4212
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4468
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4469
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4470
+ } else {
4471
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4472
+ }
4213
4473
  }
4214
4474
 
4215
4475
  void OnError(const Napi::Error& e) override {
@@ -4236,7 +4496,11 @@ public:
4236
4496
 
4237
4497
  void OnOK() override {
4238
4498
  Napi::Env env = Env();
4239
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4499
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4500
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4501
+ } else {
4502
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4503
+ }
4240
4504
  }
4241
4505
 
4242
4506
  void OnError(const Napi::Error& e) override {
@@ -4262,7 +4526,11 @@ public:
4262
4526
 
4263
4527
  void OnOK() override {
4264
4528
  Napi::Env env = Env();
4265
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4529
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4530
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4531
+ } else {
4532
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4533
+ }
4266
4534
  }
4267
4535
 
4268
4536
  void OnError(const Napi::Error& e) override {
@@ -4289,7 +4557,11 @@ public:
4289
4557
 
4290
4558
  void OnOK() override {
4291
4559
  Napi::Env env = Env();
4292
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4560
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4561
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4562
+ } else {
4563
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4564
+ }
4293
4565
  }
4294
4566
 
4295
4567
  void OnError(const Napi::Error& e) override {
@@ -4323,7 +4595,11 @@ public:
4323
4595
 
4324
4596
  void OnOK() override {
4325
4597
  Napi::Env env = Env();
4326
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4598
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4599
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4600
+ } else {
4601
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4602
+ }
4327
4603
  }
4328
4604
 
4329
4605
  void OnError(const Napi::Error& e) override {
@@ -4359,7 +4635,11 @@ public:
4359
4635
 
4360
4636
  void OnOK() override {
4361
4637
  Napi::Env env = Env();
4362
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4638
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4639
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4640
+ } else {
4641
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4642
+ }
4363
4643
  }
4364
4644
 
4365
4645
  void OnError(const Napi::Error& e) override {
@@ -4395,11 +4675,15 @@ public:
4395
4675
 
4396
4676
  void OnOK() override {
4397
4677
  Napi::Env env = Env();
4398
- Napi::Object obj = Napi::Object::New(env);
4399
- obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
4400
- obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
4401
- obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
4402
- deferred_.Resolve(obj);
4678
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4679
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4680
+ } else {
4681
+ Napi::Object obj = Napi::Object::New(env);
4682
+ obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
4683
+ obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
4684
+ obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
4685
+ deferred_.Resolve(obj);
4686
+ }
4403
4687
  }
4404
4688
 
4405
4689
  void OnError(const Napi::Error& e) override {
@@ -4429,7 +4713,11 @@ public:
4429
4713
 
4430
4714
  void OnOK() override {
4431
4715
  Napi::Env env = Env();
4432
- deferred_.Resolve(Napi::Number::New(env, result_code_));
4716
+ if (result_code_ != RIG_OK && !error_message_.empty()) {
4717
+ deferred_.Reject(Napi::Error::New(env, error_message_).Value());
4718
+ } else {
4719
+ deferred_.Resolve(Napi::Number::New(env, result_code_));
4720
+ }
4433
4721
  }
4434
4722
 
4435
4723
  void OnError(const Napi::Error& e) override {