test(ffi): add React Native JSI compatibility suite

Author: DjDeveloperr

NativeScript/ffi/jsi/NativeApiJsi.mm

@@ -29,6 +29,7 @@
     "build-node-api": "./scripts/build_all_react_native.sh",
     "build-rn-turbomodule": "./scripts/build_react_native_turbomodule.sh",
     "test-rn-turbomodule": "./scripts/test_react_native_turbomodule.sh",
+    "test-rn-ffi": "./scripts/test_react_native_ffi_compat.sh",
     "demo-rn-turbomodule": "./scripts/create_react_native_demo.sh",
     "pack:ios": "./scripts/build_npm_ios.sh",
     "pack:macos": "./scripts/build_npm_macos.sh",

package.json

@@ -18,6 +18,7 @@ class NativeScriptNativeApiModule
   bool isInstalled(jsi::Runtime& runtime);
   std::string defaultMetadataPath(jsi::Runtime& runtime);
   std::string getRuntimeBackend(jsi::Runtime& runtime);
+  bool __writeTestMarker(jsi::Runtime& runtime, std::string content);
 
  private:
   std::shared_ptr<CallInvoker> jsInvoker_;

packages/react-native/ios/NativeScriptNativeApiModule.h

@@ -62,6 +62,32 @@ void writeSmokeMarkerIfRequested(const char* stage) {
   [content writeToFile:path atomically:YES encoding:NSUTF8StringEncoding error:nil];
 }
 
+bool writeSmokeMarkerContentIfRequested(const std::string& content) {
+  const char* enabled = getenv("NATIVESCRIPT_RN_TURBO_SMOKE_MARKER");
+  if (enabled == nullptr || enabled[0] == '\0') {
+    return false;
+  }
+
+  NSString* path = [NSTemporaryDirectory()
+      stringByAppendingPathComponent:@"NativeScriptNativeApiSmoke.marker"];
+  NSString* nativeContent =
+      [[NSString alloc] initWithBytes:content.data()
+                               length:content.size()
+                             encoding:NSUTF8StringEncoding];
+  if (nativeContent == nil) {
+    nativeContent = @"";
+  }
+
+  BOOL ok = [nativeContent writeToFile:path
+                            atomically:YES
+                              encoding:NSUTF8StringEncoding
+                                 error:nil];
+#if !__has_feature(objc_arc)
+  [nativeContent release];
+#endif
+  return ok == YES;
+}
+
 }  // namespace
 
 namespace facebook::react {
@@ -96,4 +122,9 @@ void writeSmokeMarkerIfRequested(const char* stage) {
   return "hermes-jsi";
 }
 
+bool NativeScriptNativeApiModule::__writeTestMarker(jsi::Runtime&,
+                                                    std::string content) {
+  return writeSmokeMarkerContentIfRequested(content);
+}
+
 }  // namespace facebook::react

packages/react-native/ios/NativeScriptNativeApiModule.mm

@@ -6,6 +6,7 @@ export interface Spec extends TurboModule {
   readonly isInstalled: () => boolean;
   readonly defaultMetadataPath: () => string;
   readonly getRuntimeBackend: () => string;
+  readonly __writeTestMarker: (content: string) => boolean;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('NativeScriptNativeApi');

packages/react-native/src/NativeScriptNativeApi.ts

@@ -9,11 +9,19 @@ export type NativeApiHost = {
     constants?: number;
     protocols?: number;
     enums?: number;
+    structs?: number;
+    unions?: number;
     classNames?: () => string[];
     functionNames?: () => string[];
     constantNames?: () => string[];
+    protocolNames?: () => string[];
     enumNames?: () => string[];
+    structNames?: () => string[];
+    unionNames?: () => string[];
   };
+  getProtocol?: (name: string) => unknown;
+  getStruct?: (name: string) => unknown;
+  getUnion?: (name: string) => unknown;
   runOnUI?: (callback?: () => void) => Promise<void>;
   [name: string]: unknown;
 };

packages/react-native/src/index.d.ts

@@ -5,8 +5,14 @@ type NativeApiHost = {
     classNames?: () => string[];
     functionNames?: () => string[];
     constantNames?: () => string[];
+    protocolNames?: () => string[];
     enumNames?: () => string[];
+    structNames?: () => string[];
+    unionNames?: () => string[];
   };
+  getProtocol?: (name: string) => unknown;
+  getStruct?: (name: string) => unknown;
+  getUnion?: (name: string) => unknown;
   runOnUI?: (callback?: () => void) => Promise<void>;
   [name: string]: unknown;
 };
@@ -34,24 +40,131 @@ function requireNativeApiHost(): NativeApiHost {
 function defineLazyNativeGlobal(
   name: string,
   resolve: (name: string) => unknown,
+  force = false,
 ) {
-  if (!name || name in globalThis) {
+  if (!name || (!force && Object.prototype.hasOwnProperty.call(globalThis, name))) {
     return;
   }
 
-  Object.defineProperty(globalThis, name, {
-    configurable: true,
-    enumerable: false,
-    get() {
-      const value = resolve(name);
+  try {
+    Object.defineProperty(globalThis, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        const value = resolve(name);
+        Object.defineProperty(globalThis, name, {
+          configurable: true,
+          enumerable: false,
+          writable: false,
+          value,
+        });
+        return value;
+      },
+    });
+  } catch {
+    const value = resolve(name);
+    if (value !== undefined) {
       Object.defineProperty(globalThis, name, {
         configurable: true,
         enumerable: false,
         writable: false,
         value,
       });
-      return value;
-    },
+    }
+  }
+}
+
+function wrapAggregateConstructor(nativeConstructor: unknown): unknown {
+  if (typeof nativeConstructor !== 'function') {
+    return nativeConstructor;
+  }
+
+  const aggregate = function NativeScriptAggregate(initialValue?: unknown) {
+    return nativeConstructor(initialValue);
+  };
+
+  for (const key of ['kind', 'runtimeName', 'metadataOffset', 'sizeof', 'fields']) {
+    try {
+      Object.defineProperty(aggregate, key, {
+        configurable: true,
+        enumerable: false,
+        writable: false,
+        value: (nativeConstructor as Record<string, unknown>)[key],
+      });
+    } catch {
+      // Best effort metadata copy for runtimes with stricter function objects.
+    }
+  }
+
+  return aggregate;
+}
+
+function wrapInteropFactory(
+  nativeFactory: unknown,
+  properties: Record<string, unknown>,
+): unknown {
+  if (typeof nativeFactory !== 'function') {
+    return nativeFactory;
+  }
+
+  if ((nativeFactory as Record<string, unknown>).__nativeScriptConstructable) {
+    return nativeFactory;
+  }
+
+  const constructable = function NativeScriptInteropValue(...args: unknown[]) {
+    return (nativeFactory as (...args: unknown[]) => unknown)(...args);
+  };
+
+  for (const [key, value] of Object.entries(properties)) {
+    try {
+      Object.defineProperty(constructable, key, {
+        configurable: true,
+        enumerable: false,
+        writable: false,
+        value,
+      });
+    } catch {
+      // Best effort metadata copy for runtimes with stricter function objects.
+    }
+  }
+
+  Object.defineProperty(constructable, '__nativeScriptConstructable', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: true,
+  });
+
+  return constructable;
+}
+
+function installInteropConstructors(): void {
+  const interop = (globalThis as Record<string, unknown>).interop as
+    | Record<string, unknown>
+    | undefined;
+  if (!interop || typeof interop !== 'object') {
+    return;
+  }
+
+  const sizeof = interop.sizeof;
+  const pointerType = (interop.types as Record<string, unknown> | undefined)
+    ?.pointer;
+  let pointerSize: unknown = undefined;
+  if (typeof sizeof === 'function' && pointerType !== undefined) {
+    try {
+      pointerSize = sizeof(pointerType);
+    } catch {
+      pointerSize = undefined;
+    }
+  }
+
+  interop.Pointer = wrapInteropFactory(interop.Pointer, {
+    kind: 'pointer',
+    sizeof: pointerSize,
+  });
+  interop.Reference = wrapInteropFactory(interop.Reference, {
+    kind: 'reference',
+    sizeof: pointerSize,
   });
 }
 
@@ -76,11 +189,39 @@ export function installGlobals(): boolean {
     defineLazyNativeGlobal(name, (constantName) => api[constantName]);
   }
 
+  const protocolNames = api.metadata?.protocolNames?.() ?? [];
+  for (const name of protocolNames) {
+    defineLazyNativeGlobal(
+      name,
+      (protocolName) => api.getProtocol?.(protocolName) ?? api[protocolName],
+    );
+  }
+
   const enumNames = api.metadata?.enumNames?.() ?? [];
   for (const name of enumNames) {
     defineLazyNativeGlobal(name, (enumName) => api[enumName]);
   }
 
+  const structNames = api.metadata?.structNames?.() ?? [];
+  for (const name of structNames) {
+    defineLazyNativeGlobal(
+      name,
+      (structName) =>
+        wrapAggregateConstructor(api.getStruct?.(structName) ?? api[structName]),
+      true,
+    );
+  }
+
+  const unionNames = api.metadata?.unionNames?.() ?? [];
+  for (const name of unionNames) {
+    defineLazyNativeGlobal(
+      name,
+      (unionName) =>
+        wrapAggregateConstructor(api.getUnion?.(unionName) ?? api[unionName]),
+      true,
+    );
+  }
+
   return true;
 }
 
@@ -89,6 +230,9 @@ export function init(
   options: InstallOptions = {},
 ): boolean {
   const installed = NativeScriptNativeApi.install(metadataPath);
+  if (installed) {
+    installInteropConstructors();
+  }
   if (installed && options.globals !== false) {
     installGlobals();
   }