@rn-org/react-native-thread 0.3.0 → 0.4.0

package/README.md

@@ -22,7 +22,7 @@ Run JavaScript on real background threads in React Native — no Workers, no Wor
   - [ThreadInfo](#threadinfo)
   - [ThreadTask](#threadtask)
 - [Thread globals](#thread-globals)
-  - [postMessage](#postmessage)
+  - [resolveThreadMessage](#resolvethreadmessage)
   - [console](#console)
   - [`__params__`](#__params__)
 - [Hermes & Babel plugin](#hermes--babel-plugin-deep-dive)
@@ -37,7 +37,7 @@ Run JavaScript on real background threads in React Native — no Workers, no Wor
 - **True background threads** — each thread runs its own JS engine on an OS-level thread; the main Hermes/JSC runtime is never blocked.
 - **Unlimited threads** — create as many threads as you need; each is isolated.
 - **Shared thread** (`runOnJS`) — fire-and-forget tasks on a single persistent background thread; no teardown required.
-- **Per-thread message passing** — call `postMessage(data)` from any thread, receive it on the main thread with `onMessage` (callback or `await`).
+- **Per-thread message passing** — call `resolveThreadMessage(data)` from any thread, receive it on the main thread with `onMessage` (callback or `await`).
 - **Parameter injection** — pass a JSON-serialisable value from the main thread into the background function as a typed argument `(args) => { ... }`.
 - **Named threads** — give threads friendly names; list or destroy them by name.
 - **Full `console` support** — `console.log/info/warn/error/debug` work inside threads and appear in Logcat / Xcode logs.
@@ -114,7 +114,7 @@ thread.run(
   (args) => {
     var result = 0;
     for (var i = 0; i < args.limit; i++) result += i;
-    postMessage({ sum: result });
+    resolveThreadMessage({ sum: result });
   },
   { limit: 1_000_000 }
 );
@@ -237,7 +237,7 @@ function onMessage(
 function onMessage(): Promise<{ data: unknown; threadId: number }>
 ```
 
-Global listener that fires whenever **any** thread calls `postMessage(data)`. Prefer `ThreadHandle.onMessage` if you want messages scoped to a single thread.
+Global listener that fires whenever **any** thread calls `resolveThreadMessage(data)`. Prefer `ThreadHandle.onMessage` if you want messages scoped to a single thread.
 
 ```ts
 // Callback variant
@@ -275,7 +275,7 @@ type ThreadHandle = {
 | `id` | Numeric ID assigned by the native layer. |
 | `name` | Display name provided at creation (or the default `RNThread-<id>`). |
 | `run(task, params?)` | Execute `task` on this thread. `params` is passed as the first argument to the function. Can be called multiple times. |
-| `onMessage(handler)` | Subscribe to `postMessage` output from **this thread only**. Returns an unsubscribe function. |
+| `onMessage(handler)` | Subscribe to `resolveThreadMessage` output from **this thread only**. Returns an unsubscribe function. |
 | `onMessage()` | Returns a `Promise` that resolves with the next message from **this thread only**, then auto-unsubscribes. |
 | `destroy()` | Shut down the thread and remove it from the registry. Equivalent to calling `destroyThread(handle.id)`. |
 
@@ -308,17 +308,17 @@ Either an arrow function / function expression (transformed by the Babel plugin)
 
 These globals are available inside every thread function:
 
-### `postMessage`
+### `resolveThreadMessage`
 
 ```ts
-declare function postMessage(data: unknown): void
+declare function resolveThreadMessage(data: unknown): void
 ```
 
 Sends `data` back to the main JS thread. The value is JSON-serialised in the background thread and JSON-parsed before reaching the `onMessage` handler. Must be JSON-serialisable (`object`, `array`, `string`, `number`, `boolean`, or `null`).
 
 ```ts
 thread.run((args) => {
-  postMessage({ status: 'done', value: args.multiply * 2 });
+  resolveThreadMessage({ status: 'done', value: args.multiply * 2 });
 }, { multiply: 21 });
 
 // Callback
@@ -359,7 +359,7 @@ thread.run(
     for (var i = 0; i < args.iterations; i++) {
       // ...
     }
-    postMessage('done');
+    resolveThreadMessage('done');
   },
   { iterations: 50_000 }
 );
@@ -370,14 +370,14 @@ thread.run(
     for (var i = 0; i < __params__.iterations; i++) {
       // ...
     }
-    postMessage('done');
+    resolveThreadMessage('done');
   },
   { iterations: 50_000 }
 );
 
 // Option C — raw code string (only __params__ is available)
 thread.run(
-  'for (var i = 0; i < __params__.iterations; i++) {} postMessage("done")',
+  'for (var i = 0; i < __params__.iterations; i++) {} resolveThreadMessage("done")',
   { iterations: 50_000 }
 );
 ```
@@ -403,11 +403,11 @@ The included Babel plugin runs at **compile time** — before Hermes touches the
 ```js
 // Input (your source)
 thread.run((args) => {
-  postMessage(args.greeting);
+  resolveThreadMessage(args.greeting);
 }, { greeting: 'hello' });
 
 // Output (what Hermes compiles)
-thread.run("((args) => {\n  postMessage(args.greeting);\n})(__params__)", { greeting: 'hello' });
+thread.run("((args) => {\n  resolveThreadMessage(args.greeting);\n})(__params__)", { greeting: 'hello' });
 ```
 
 The second `params` argument is left untouched; only the first (function) argument is transformed.
@@ -424,7 +424,7 @@ The second `params` argument is left untouched; only the first (function) argume
 ### Limitations
 
 - Thread functions are **self-contained**: they run in an isolated JS engine with no access to the outer closure, imported modules, or the React tree.
-- All values must be passed explicitly via the `args` parameter, `__params__`, or `postMessage`.
+- All values must be passed explicitly via the `args` parameter, `__params__`, or `resolveThreadMessage`.
 - Thread function bodies must be **ASCII-safe**: Rhino (Android) does not support non-ASCII identifier characters in source mode.
 - The `params` value must be **JSON-serialisable**: functions, `undefined`, `Map`, `Set`, etc. are not supported.
 
@@ -436,7 +436,7 @@ The second `params` argument is left untouched; only the first (function) argume
 |---|---|
 | Functions are closure-isolated | They run in a completely separate JS engine |
 | `params` must be JSON-serialisable | Serialised and passed as a function argument |
-| `postMessage` payload must be JSON-serialisable | Transported as a JSON string over the bridge |
+| `resolveThreadMessage` payload must be JSON-serialisable | Transported as a JSON string over the bridge |
 | Function body must be ASCII-safe | Rhino parser limitation |
 | New Architecture required | TurboModule / Codegen only; no bridge fallback |
 

package/android/src/main/java/com/rnorg/reactnativethread/ReactNativeThreadModule.kt

@@ -43,7 +43,7 @@ class ReactNativeThreadModule(reactContext: ReactApplicationContext) :
         cx.optimizationLevel = -1
         val scope = cx.initStandardObjects()
         injectConsole(scope, id)
-        injectPostMessage(scope, id)
+        injectResolveThreadMessage(scope, id)
         scopeFuture.complete(scope)
       } catch (e: Exception) {
         scopeFuture.completeExceptionally(e)
@@ -81,11 +81,11 @@ class ReactNativeThreadModule(reactContext: ReactApplicationContext) :
     entry.executor.shutdown()
   }
 
-  private fun injectPostMessage(scope: Scriptable, threadId: Long) {
+  private fun injectResolveThreadMessage(scope: Scriptable, threadId: Long) {
     val ctx = reactApplicationContext
     ScriptableObject.putProperty(
       scope as ScriptableObject,
-      "postMessage",
+      "resolveThreadMessage",
       object : BaseFunction() {
         override fun call(
           cx: RhinoContext,

package/ios/ReactNativeThread.mm

@@ -79,7 +79,7 @@
 
         NSUInteger capturedTid = tidForLog;
         __weak ReactNativeThread *weakSelf = self;
-        t.context[@"postMessage"] = ^(JSValue *data) {
+        t.context[@"resolveThreadMessage"] = ^(JSValue *data) {
             JSValue *jsonStr = [data.context[@"JSON"] invokeMethod:@"stringify"
                                                       withArguments:@[data]];
             NSString *serialised = [jsonStr toString];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rn-org/react-native-thread",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Run JavaScript on real background threads in React Native — no Workers, no Worklets. Uses JavaScriptCore on iOS and Mozilla Rhino on Android. Built as a New Architecture TurboModule.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -53,7 +53,7 @@
     "turbo-module",
     "new-architecture",
     "worker",
-    "postmessage"
+    "resolveThreadMessage"
   ],
   "repository": {
     "type": "git",

package/src/globals.d.ts

@@ -9,10 +9,10 @@
  * @example
  * thread.run(() => {
  *   const result = heavyWork();
- *   postMessage({ result });
+ *   resolveThreadMessage({ result });
  * });
  */
-declare function postMessage(data: unknown): void;
+declare function resolveThreadMessage(data: unknown): void;
 
 /**
  * Parameters passed by the caller via the optional second argument of