@synonymdev/react-native-pubky 0.7.1 → 0.9.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (26) hide show
  1. package/README.md +75 -3
  2. package/android/src/main/java/com/pubky/PubkyModule.kt +369 -252
  3. package/android/src/main/java/uniffi/pubkymobile/pubkymobile.kt +557 -127
  4. package/android/src/main/jniLibs/arm64-v8a/libpubkymobile.so +0 -0
  5. package/android/src/main/jniLibs/armeabi-v7a/libpubkymobile.so +0 -0
  6. package/android/src/main/jniLibs/x86/libpubkymobile.so +0 -0
  7. package/android/src/main/jniLibs/x86_64/libpubkymobile.so +0 -0
  8. package/ios/Frameworks/PubkyMobile.xcframework/Info.plist +4 -4
  9. package/ios/Frameworks/PubkyMobile.xcframework/ios-arm64/Headers/pubkymobileFFI.h +38 -0
  10. package/ios/Frameworks/PubkyMobile.xcframework/ios-arm64/libpubkymobile.a +0 -0
  11. package/ios/Frameworks/PubkyMobile.xcframework/ios-arm64-simulator/Headers/pubkymobileFFI.h +38 -0
  12. package/ios/Frameworks/PubkyMobile.xcframework/ios-arm64-simulator/libpubkymobile.a +0 -0
  13. package/ios/Pubky-Bridging-Header.h +1 -0
  14. package/ios/Pubky.mm +26 -1
  15. package/ios/Pubky.swift +84 -1
  16. package/ios/pubkymobile.swift +310 -0
  17. package/lib/commonjs/index.js +69 -0
  18. package/lib/commonjs/index.js.map +1 -1
  19. package/lib/module/index.js +64 -1
  20. package/lib/module/index.js.map +1 -1
  21. package/lib/typescript/commonjs/src/index.d.ts +10 -0
  22. package/lib/typescript/commonjs/src/index.d.ts.map +1 -1
  23. package/lib/typescript/module/src/index.d.ts +10 -0
  24. package/lib/typescript/module/src/index.d.ts.map +1 -1
  25. package/package.json +1 -1
  26. package/src/index.tsx +84 -1
package/android/src/main/java/com/pubky/PubkyModule.kt CHANGED
@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReactApplicationContext
5
5
  import com.facebook.react.bridge.ReactContextBaseJavaModule
6
6
  import com.facebook.react.bridge.ReactMethod
7
7
  import com.facebook.react.bridge.Promise
8
+ import com.facebook.react.modules.core.DeviceEventManagerModule
8
9
  import kotlinx.coroutines.CoroutineScope
9
10
  import kotlinx.coroutines.Dispatchers
10
11
  import kotlinx.coroutines.launch
@@ -12,273 +13,389 @@ import kotlinx.coroutines.withContext
12
13
  import uniffi.pubkymobile.*
13
14
 
14
15
  class PubkyModule(reactContext: ReactApplicationContext) :
15
- ReactContextBaseJavaModule(reactContext) {
16
+ ReactContextBaseJavaModule(reactContext) {
16
17
 
17
- override fun getName(): String {
18
- return NAME
19
- }
18
+ override fun getName(): String {
19
+ return NAME
20
+ }
20
21
 
21
- @ReactMethod
22
- fun auth(url: String, secretKey: String, promise: Promise) {
23
- CoroutineScope(Dispatchers.IO).launch {
24
- try {
25
- val result = auth(url, secretKey)
26
- val array = Arguments.createArray().apply {
27
- result.forEach { pushString(it) }
28
- }
29
- withContext(Dispatchers.Main) {
30
- promise.resolve(array)
31
- }
32
- } catch (e: Exception) {
33
- withContext(Dispatchers.Main) {
34
- promise.reject("Error", e.message)
35
- }
36
- }
37
- }
38
- }
22
+ private val eventListener = object : EventListener {
23
+ override fun onEventOccurred(eventData: String) {
24
+ reactContext
25
+ .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
26
+ .emit("PubkyEvent", eventData)
27
+ }
28
+ }
39
29
 
40
- @ReactMethod
41
- fun parseAuthUrl(url: String, promise: Promise) {
42
- try {
43
- val result = parseAuthUrl(url)
44
- val array = Arguments.createArray().apply {
45
- result.forEach { pushString(it) }
46
- }
47
- promise.resolve(array)
48
- } catch (e: Exception) {
49
- promise.reject("Error", e.message)
30
+ @ReactMethod
31
+ fun setEventListener(promise: Promise) {
32
+ CoroutineScope(Dispatchers.IO).launch {
33
+ try {
34
+ setEventListener(eventListener)
35
+ withContext(Dispatchers.Main) {
36
+ promise.resolve(null)
37
+ }
38
+ } catch (e: Exception) {
39
+ withContext(Dispatchers.Main) {
40
+ promise.reject("Error", e.message)
41
+ }
42
+ }
43
+ }
50
44
  }
51
- }
52
45
 
53
- @ReactMethod
54
- fun publish(recordName: String, recordContent: String, secretKey: String, promise: Promise) {
55
- CoroutineScope(Dispatchers.IO).launch {
56
- try {
57
- val result = publish(recordName, recordContent, secretKey)
58
- val array = Arguments.createArray().apply {
59
- result.forEach { pushString(it) }
60
- }
61
- withContext(Dispatchers.Main) {
62
- promise.resolve(array)
63
- }
64
- } catch (e: Exception) {
65
- withContext(Dispatchers.Main) {
66
- promise.reject("Error", e.message)
67
- }
68
- }
69
- }
70
- }
46
+ @ReactMethod
47
+ fun removeEventListener(promise: Promise) {
48
+ CoroutineScope(Dispatchers.IO).launch {
49
+ try {
50
+ removeEventListener()
51
+ withContext(Dispatchers.Main) {
52
+ promise.resolve(null)
53
+ }
54
+ } catch (e: Exception) {
55
+ withContext(Dispatchers.Main) {
56
+ promise.reject("Error", e.message)
57
+ }
58
+ }
59
+ }
60
+ }
71
61
 
72
- @ReactMethod
73
- fun resolve(publicKey: String, promise: Promise) {
74
- CoroutineScope(Dispatchers.IO).launch {
75
- try {
76
- val result = resolve(publicKey)
77
- val array = Arguments.createArray().apply {
78
- result.forEach { pushString(it) }
79
- }
80
- withContext(Dispatchers.Main) {
81
- promise.resolve(array)
82
- }
83
- } catch (e: Exception) {
84
- withContext(Dispatchers.Main) {
85
- promise.reject("Error", e.message)
86
- }
87
- }
88
- }
89
- }
62
+ @ReactMethod
63
+ fun deleteFile(url: String, promise: Promise) {
64
+ CoroutineScope(Dispatchers.IO).launch {
65
+ try {
66
+ val result = deleteFile(url)
67
+ val array = Arguments.createArray().apply {
68
+ result.forEach { pushString(it) }
69
+ }
70
+ withContext(Dispatchers.Main) {
71
+ promise.resolve(array)
72
+ }
73
+ } catch (e: Exception) {
74
+ withContext(Dispatchers.Main) {
75
+ promise.reject("Error", e.message)
76
+ }
77
+ }
78
+ }
79
+ }
90
80
 
91
- @ReactMethod
92
- fun signUp(secretKey: String, homeserver: String, promise: Promise) {
93
- CoroutineScope(Dispatchers.IO).launch {
94
- try {
95
- val result = signUp(secretKey, homeserver)
96
- val array = Arguments.createArray().apply {
97
- result.forEach { pushString(it) }
98
- }
99
- withContext(Dispatchers.Main) {
100
- promise.resolve(array)
101
- }
102
- } catch (e: Exception) {
103
- withContext(Dispatchers.Main) {
104
- promise.reject("Error", e.message)
105
- }
106
- }
107
- }
108
- }
81
+ @ReactMethod
82
+ fun session(pubky: String, promise: Promise) {
83
+ CoroutineScope(Dispatchers.IO).launch {
84
+ try {
85
+ val result = session(pubky)
86
+ val array = Arguments.createArray().apply {
87
+ result.forEach { pushString(it) }
88
+ }
89
+ withContext(Dispatchers.Main) {
90
+ promise.resolve(array)
91
+ }
92
+ } catch (e: Exception) {
93
+ withContext(Dispatchers.Main) {
94
+ promise.reject("Error", e.message)
95
+ }
96
+ }
97
+ }
98
+ }
109
99
 
110
- @ReactMethod
111
- fun signIn(secretKey: String, promise: Promise) {
112
- CoroutineScope(Dispatchers.IO).launch {
113
- try {
114
- val result = signIn(secretKey)
115
- val array = Arguments.createArray().apply {
116
- result.forEach { pushString(it) }
117
- }
118
- withContext(Dispatchers.Main) {
119
- promise.resolve(array)
120
- }
121
- } catch (e: Exception) {
122
- withContext(Dispatchers.Main) {
123
- promise.reject("Error", e.message)
124
- }
125
- }
126
- }
127
- }
100
+ @ReactMethod
101
+ fun auth(url: String, secretKey: String, promise: Promise) {
102
+ CoroutineScope(Dispatchers.IO).launch {
103
+ try {
104
+ val result = auth(url, secretKey)
105
+ val array = Arguments.createArray().apply {
106
+ result.forEach { pushString(it) }
107
+ }
108
+ withContext(Dispatchers.Main) {
109
+ promise.resolve(array)
110
+ }
111
+ } catch (e: Exception) {
112
+ withContext(Dispatchers.Main) {
113
+ promise.reject("Error", e.message)
114
+ }
115
+ }
116
+ }
117
+ }
128
118
 
129
- @ReactMethod
130
- fun signOut(secretKey: String, promise: Promise) {
131
- CoroutineScope(Dispatchers.IO).launch {
132
- try {
133
- val result = signOut(secretKey)
134
- val array = Arguments.createArray().apply {
135
- result.forEach { pushString(it) }
136
- }
137
- withContext(Dispatchers.Main) {
138
- promise.resolve(array)
139
- }
140
- } catch (e: Exception) {
141
- withContext(Dispatchers.Main) {
142
- promise.reject("Error", e.message)
143
- }
144
- }
145
- }
146
- }
119
+ @ReactMethod
120
+ fun parseAuthUrl(url: String, promise: Promise) {
121
+ try {
122
+ val result = parseAuthUrl(url)
123
+ val array = Arguments.createArray().apply {
124
+ result.forEach { pushString(it) }
125
+ }
126
+ promise.resolve(array)
127
+ } catch (e: Exception) {
128
+ promise.reject("Error", e.message)
129
+ }
130
+ }
147
131
 
148
- @ReactMethod
149
- fun put(url: String, content: String, promise: Promise) {
150
- CoroutineScope(Dispatchers.IO).launch {
151
- try {
152
- val result = put(url, content)
153
- val array = Arguments.createArray().apply {
154
- result.forEach { pushString(it) }
155
- }
156
- withContext(Dispatchers.Main) {
157
- promise.resolve(array)
158
- }
159
- } catch (e: Exception) {
160
- withContext(Dispatchers.Main) {
161
- promise.reject("Error", e.message)
162
- }
163
- }
164
- }
165
- }
132
+ @ReactMethod
133
+ fun publish(recordName: String, recordContent: String, secretKey: String, promise: Promise) {
134
+ CoroutineScope(Dispatchers.IO).launch {
135
+ try {
136
+ val result = publish(recordName, recordContent, secretKey)
137
+ val array = Arguments.createArray().apply {
138
+ result.forEach { pushString(it) }
139
+ }
140
+ withContext(Dispatchers.Main) {
141
+ promise.resolve(array)
142
+ }
143
+ } catch (e: Exception) {
144
+ withContext(Dispatchers.Main) {
145
+ promise.reject("Error", e.message)
146
+ }
147
+ }
148
+ }
149
+ }
166
150
 
167
- @ReactMethod
168
- fun get(url: String, promise: Promise) {
169
- CoroutineScope(Dispatchers.IO).launch {
170
- try {
171
- val result = get(url)
172
- val array = Arguments.createArray().apply {
173
- result.forEach { pushString(it) }
174
- }
175
- withContext(Dispatchers.Main) {
176
- promise.resolve(array)
177
- }
178
- } catch (e: Exception) {
179
- withContext(Dispatchers.Main) {
180
- promise.reject("Error", e.message)
181
- }
182
- }
183
- }
184
- }
151
+ @ReactMethod
152
+ fun resolve(publicKey: String, promise: Promise) {
153
+ CoroutineScope(Dispatchers.IO).launch {
154
+ try {
155
+ val result = resolve(publicKey)
156
+ val array = Arguments.createArray().apply {
157
+ result.forEach { pushString(it) }
158
+ }
159
+ withContext(Dispatchers.Main) {
160
+ promise.resolve(array)
161
+ }
162
+ } catch (e: Exception) {
163
+ withContext(Dispatchers.Main) {
164
+ promise.reject("Error", e.message)
165
+ }
166
+ }
167
+ }
168
+ }
185
169
 
186
- @ReactMethod
187
- fun publishHttps(recordName: String, target: String, secretKey: String, promise: Promise) {
188
- CoroutineScope(Dispatchers.IO).launch {
189
- try {
190
- val result = publishHttps(recordName, target, secretKey)
191
- val array = Arguments.createArray().apply {
192
- result.forEach { pushString(it) }
193
- }
194
- withContext(Dispatchers.Main) {
195
- promise.resolve(array)
196
- }
197
- } catch (e: Exception) {
198
- withContext(Dispatchers.Main) {
199
- promise.reject("Error", e.message)
200
- }
201
- }
202
- }
203
- }
170
+ @ReactMethod
171
+ fun signUp(secretKey: String, homeserver: String, promise: Promise) {
172
+ CoroutineScope(Dispatchers.IO).launch {
173
+ try {
174
+ val result = signUp(secretKey, homeserver)
175
+ val array = Arguments.createArray().apply {
176
+ result.forEach { pushString(it) }
177
+ }
178
+ withContext(Dispatchers.Main) {
179
+ promise.resolve(array)
180
+ }
181
+ } catch (e: Exception) {
182
+ withContext(Dispatchers.Main) {
183
+ promise.reject("Error", e.message)
184
+ }
185
+ }
186
+ }
187
+ }
204
188
 
205
- @ReactMethod
206
- fun resolveHttps(publicKey: String, promise: Promise) {
207
- CoroutineScope(Dispatchers.IO).launch {
208
- try {
209
- val result = resolveHttps(publicKey)
210
- val array = Arguments.createArray().apply {
211
- result.forEach { pushString(it) }
212
- }
213
- withContext(Dispatchers.Main) {
214
- promise.resolve(array)
215
- }
216
- } catch (e: Exception) {
217
- withContext(Dispatchers.Main) {
218
- promise.reject("Error", e.message)
219
- }
220
- }
221
- }
222
- }
189
+ @ReactMethod
190
+ fun signIn(secretKey: String, promise: Promise) {
191
+ CoroutineScope(Dispatchers.IO).launch {
192
+ try {
193
+ val result = signIn(secretKey)
194
+ val array = Arguments.createArray().apply {
195
+ result.forEach { pushString(it) }
196
+ }
197
+ withContext(Dispatchers.Main) {
198
+ promise.resolve(array)
199
+ }
200
+ } catch (e: Exception) {
201
+ withContext(Dispatchers.Main) {
202
+ promise.reject("Error", e.message)
203
+ }
204
+ }
205
+ }
206
+ }
223
207
 
224
- @ReactMethod
225
- fun list(url: String, promise: Promise) {
226
- CoroutineScope(Dispatchers.IO).launch {
227
- try {
228
- val result = list(url)
229
- val array = Arguments.createArray().apply {
230
- result.forEach { pushString(it) }
231
- }
232
- withContext(Dispatchers.Main) {
233
- promise.resolve(array)
234
- }
235
- } catch (e: Exception) {
236
- withContext(Dispatchers.Main) {
237
- promise.reject("Error", e.message)
238
- }
239
- }
240
- }
241
- }
208
+ @ReactMethod
209
+ fun signOut(secretKey: String, promise: Promise) {
210
+ CoroutineScope(Dispatchers.IO).launch {
211
+ try {
212
+ val result = signOut(secretKey)
213
+ val array = Arguments.createArray().apply {
214
+ result.forEach { pushString(it) }
215
+ }
216
+ withContext(Dispatchers.Main) {
217
+ promise.resolve(array)
218
+ }
219
+ } catch (e: Exception) {
220
+ withContext(Dispatchers.Main) {
221
+ promise.reject("Error", e.message)
222
+ }
223
+ }
224
+ }
225
+ }
242
226
 
243
- @ReactMethod
244
- fun generateSecretKey(promise: Promise) {
245
- CoroutineScope(Dispatchers.IO).launch {
246
- try {
247
- val result = generate_secret_key()
248
- val array = Arguments.createArray().apply {
249
- result.forEach { pushString(it) }
250
- }
251
- withContext(Dispatchers.Main) {
252
- promise.resolve(array)
253
- }
254
- } catch (e: Exception) {
255
- withContext(Dispatchers.Main) {
256
- promise.reject("Error", e.message)
257
- }
258
- }
259
- }
260
- }
227
+ @ReactMethod
228
+ fun put(url: String, content: String, promise: Promise) {
229
+ CoroutineScope(Dispatchers.IO).launch {
230
+ try {
231
+ val result = put(url, content)
232
+ val array = Arguments.createArray().apply {
233
+ result.forEach { pushString(it) }
234
+ }
235
+ withContext(Dispatchers.Main) {
236
+ promise.resolve(array)
237
+ }
238
+ } catch (e: Exception) {
239
+ withContext(Dispatchers.Main) {
240
+ promise.reject("Error", e.message)
241
+ }
242
+ }
243
+ }
244
+ }
261
245
 
262
- @ReactMethod
263
- fun getPublicKeyFromSecretKey(secretKey: String, promise: Promise) {
264
- CoroutineScope(Dispatchers.IO).launch {
265
- try {
266
- val result = getPublicKeyFromSecretKey(secretKey)
267
- val array = Arguments.createArray().apply {
268
- result.forEach { pushString(it) }
269
- }
270
- withContext(Dispatchers.Main) {
271
- promise.resolve(array)
272
- }
273
- } catch (e: Exception) {
274
- withContext(Dispatchers.Main) {
275
- promise.reject("Error", e.message)
276
- }
277
- }
278
- }
279
- }
246
+ @ReactMethod
247
+ fun get(url: String, promise: Promise) {
248
+ CoroutineScope(Dispatchers.IO).launch {
249
+ try {
250
+ val result = get(url)
251
+ val array = Arguments.createArray().apply {
252
+ result.forEach { pushString(it) }
253
+ }
254
+ withContext(Dispatchers.Main) {
255
+ promise.resolve(array)
256
+ }
257
+ } catch (e: Exception) {
258
+ withContext(Dispatchers.Main) {
259
+ promise.reject("Error", e.message)
260
+ }
261
+ }
262
+ }
263
+ }
280
264
 
281
- companion object {
282
- const val NAME = "Pubky"
283
- }
265
+ @ReactMethod
266
+ fun publishHttps(recordName: String, target: String, secretKey: String, promise: Promise) {
267
+ CoroutineScope(Dispatchers.IO).launch {
268
+ try {
269
+ val result = publishHttps(recordName, target, secretKey)
270
+ val array = Arguments.createArray().apply {
271
+ result.forEach { pushString(it) }
272
+ }
273
+ withContext(Dispatchers.Main) {
274
+ promise.resolve(array)
275
+ }
276
+ } catch (e: Exception) {
277
+ withContext(Dispatchers.Main) {
278
+ promise.reject("Error", e.message)
279
+ }
280
+ }
281
+ }
282
+ }
283
+
284
+ @ReactMethod
285
+ fun resolveHttps(publicKey: String, promise: Promise) {
286
+ CoroutineScope(Dispatchers.IO).launch {
287
+ try {
288
+ val result = resolveHttps(publicKey)
289
+ val array = Arguments.createArray().apply {
290
+ result.forEach { pushString(it) }
291
+ }
292
+ withContext(Dispatchers.Main) {
293
+ promise.resolve(array)
294
+ }
295
+ } catch (e: Exception) {
296
+ withContext(Dispatchers.Main) {
297
+ promise.reject("Error", e.message)
298
+ }
299
+ }
300
+ }
301
+ }
302
+
303
+ @ReactMethod
304
+ fun list(url: String, promise: Promise) {
305
+ CoroutineScope(Dispatchers.IO).launch {
306
+ try {
307
+ val result = list(url)
308
+ val array = Arguments.createArray().apply {
309
+ result.forEach { pushString(it) }
310
+ }
311
+ withContext(Dispatchers.Main) {
312
+ promise.resolve(array)
313
+ }
314
+ } catch (e: Exception) {
315
+ withContext(Dispatchers.Main) {
316
+ promise.reject("Error", e.message)
317
+ }
318
+ }
319
+ }
320
+ }
321
+
322
+ @ReactMethod
323
+ fun generateSecretKey(promise: Promise) {
324
+ CoroutineScope(Dispatchers.IO).launch {
325
+ try {
326
+ val result = generateSecretKey()
327
+ val array = Arguments.createArray().apply {
328
+ result.forEach { pushString(it) }
329
+ }
330
+ withContext(Dispatchers.Main) {
331
+ promise.resolve(array)
332
+ }
333
+ } catch (e: Exception) {
334
+ withContext(Dispatchers.Main) {
335
+ promise.reject("Error", e.message)
336
+ }
337
+ }
338
+ }
339
+ }
340
+
341
+ @ReactMethod
342
+ fun getPublicKeyFromSecretKey(secretKey: String, promise: Promise) {
343
+ CoroutineScope(Dispatchers.IO).launch {
344
+ try {
345
+ val result = getPublicKeyFromSecretKey(secretKey)
346
+ val array = Arguments.createArray().apply {
347
+ result.forEach { pushString(it) }
348
+ }
349
+ withContext(Dispatchers.Main) {
350
+ promise.resolve(array)
351
+ }
352
+ } catch (e: Exception) {
353
+ withContext(Dispatchers.Main) {
354
+ promise.reject("Error", e.message)
355
+ }
356
+ }
357
+ }
358
+ }
359
+
360
+ @ReactMethod
361
+ fun createRecoveryFile(secretKey: String, passphrase: String, promise: Promise) {
362
+ CoroutineScope(Dispatchers.IO).launch {
363
+ try {
364
+ val result = createRecoveryFile(secretKey, passphrase)
365
+ val array = Arguments.createArray().apply {
366
+ result.forEach { pushString(it) }
367
+ }
368
+ withContext(Dispatchers.Main) {
369
+ promise.resolve(array)
370
+ }
371
+ } catch (e: Exception) {
372
+ withContext(Dispatchers.Main) {
373
+ promise.reject("Error", e.message)
374
+ }
375
+ }
376
+ }
377
+ }
378
+
379
+ @ReactMethod
380
+ fun decryptRecoveryFile(recoveryFile: String, passphrase: String, promise: Promise) {
381
+ CoroutineScope(Dispatchers.IO).launch {
382
+ try {
383
+ val result = decryptRecoveryFile(recoveryFile, passphrase)
384
+ val array = Arguments.createArray().apply {
385
+ result.forEach { pushString(it) }
386
+ }
387
+ withContext(Dispatchers.Main) {
388
+ promise.resolve(array)
389
+ }
390
+ } catch (e: Exception) {
391
+ withContext(Dispatchers.Main) {
392
+ promise.reject("Error", e.message)
393
+ }
394
+ }
395
+ }
396
+ }
397
+
398
+ companion object {
399
+ const val NAME = "Pubky"
400
+ }
284
401
  }