@rn-org/react-native-thread 0.5.0 → 0.6.0

package/src/index.tsx

@@ -8,12 +8,18 @@ export type ThreadInfo = {
   readonly name: string;
 };
 
+export type ThreadError = {
+  message: string;
+  stack: string;
+};
+
 export type ThreadHandle = {
   readonly id: number;
   readonly name: string;
   run(task: ThreadTask, params?: unknown): void;
   onMessage(handler: (data: unknown) => void): () => void;
   onMessage(): Promise<unknown>;
+  onError(handler: (error: ThreadError) => void): () => void;
   destroy(): void;
 };
 
@@ -37,18 +43,60 @@ function _unregister(id: number): void {
   _registry.delete(id);
 }
 
+function _isBytecode(src: string): boolean {
+  return (
+    src.includes('[bytecode]') ||
+    /^\s*function\s*\(\)\s*\{\s*bytecode\s*\}/.test(src)
+  );
+}
+
+function _serializeValue(value: unknown): string {
+  if (value === undefined) return 'undefined';
+  if (value === null) return 'null';
+  if (typeof value === 'function') {
+    const src = value.toString();
+    if (_isBytecode(src)) {
+      if (__DEV__) {
+        console.warn(
+          '[react-native-thread] A function param returned a Hermes bytecode placeholder. ' +
+            "Add the Babel plugin: plugins: ['@rn-org/react-native-thread/babel-plugin']"
+        );
+      }
+      return 'undefined';
+    }
+    return src;
+  }
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'number' || typeof value === 'boolean')
+    return String(value);
+  if (Array.isArray(value))
+    return '[' + value.map(_serializeValue).join(',') + ']';
+  if (typeof value === 'object') {
+    const rec = value as Record<string, unknown>;
+    if (typeof rec.__rnThreadFn === 'string') {
+      return rec.__rnThreadFn;
+    }
+    const entries = Object.entries(rec)
+      .map(([k, v]) => `${JSON.stringify(k)}:${_serializeValue(v)}`)
+      .join(',');
+    return '{' + entries + '}';
+  }
+  return String(value);
+}
+
+function _wrapWithErrorHandler(code: string): string {
+  return `try { ${code} } catch(__e__) { resolveThreadMessage(JSON.stringify({ __rnThreadError: true, message: __e__.message || String(__e__), stack: __e__.stack || '' })); }`;
+}
+
 function toCode(task: ThreadTask, params?: unknown): string {
   if (typeof task === 'string') {
-    const paramsJson =
-      params !== undefined ? JSON.stringify(params) : 'undefined';
-    return `var __params__ = ${paramsJson};\n${task}`;
+    const paramsCode =
+      params !== undefined ? _serializeValue(params) : 'undefined';
+    return _wrapWithErrorHandler(`var __params__ = ${paramsCode};\n${task}`);
   }
 
   const src = task.toString();
-  if (
-    src.includes('[bytecode]') ||
-    /^\s*function\s*\(\)\s*\{\s*bytecode\s*\}/.test(src)
-  ) {
+  if (_isBytecode(src)) {
     if (__DEV__) {
       console.warn(
         '[react-native-thread] fn.toString() returned a Hermes bytecode placeholder. ' +
@@ -58,8 +106,8 @@ function toCode(task: ThreadTask, params?: unknown): string {
     return '/* bytecode: no-op */';
   }
 
-  const argsStr = params !== undefined ? JSON.stringify(params) : '';
-  return `(${src})(${argsStr})`;
+  const argsStr = params !== undefined ? _serializeValue(params) : '';
+  return _wrapWithErrorHandler(`(${src})(${argsStr})`);
 }
 
 const SHARED_THREAD_NAME = 'RNOrgThread';
@@ -170,6 +218,16 @@ export function onMessage(
   });
 }
 
+function _isThreadError(
+  data: unknown
+): data is { __rnThreadError: true; message: string; stack: string } {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    (data as any).__rnThreadError === true
+  );
+}
+
 function createThreadHandle(id: number, name: string): ThreadHandle {
   return {
     id,
@@ -180,18 +238,31 @@ function createThreadHandle(id: number, name: string): ThreadHandle {
     onMessage: function (handler?: (data: unknown) => void) {
       if (handler) {
         return onMessage((data, threadId) => {
-          if (threadId === id) handler(data);
+          if (threadId === id && !_isThreadError(data)) handler(data);
         });
       }
-      return new Promise<unknown>((resolve) => {
+      return new Promise<unknown>((resolve, reject) => {
         const unsub = onMessage((data, threadId) => {
           if (threadId === id) {
             unsub();
-            resolve(data);
+            if (_isThreadError(data)) {
+              const err = new Error(data.message);
+              err.stack = data.stack;
+              reject(err);
+            } else {
+              resolve(data);
+            }
           }
         });
       });
     } as ThreadHandle['onMessage'],
+    onError(handler: (error: ThreadError) => void) {
+      return onMessage((data, threadId) => {
+        if (threadId === id && _isThreadError(data)) {
+          handler({ message: data.message, stack: data.stack });
+        }
+      });
+    },
     destroy() {
       destroyThread(id);
     },