nitrogen 0.2.23 → 0.29.4

package/README.md

@@ -1,118 +1,24 @@
-# Nitrogen Client
+<a href="https://margelo.com">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="../../docs/static/img/banner-nitrogen-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="../../docs/static/img/banner-nitrogen-light.png" />
+    <img alt="Nitrogen" src="../../docs/static/img/banner-nitrogen-light.png" />
+  </picture>
+</a>
 
-Nitrogen is a platform for building connected devices.  Nitrogen provides the authentication, authorization, and real time message passing framework so that you can focus on your device and application.  All with a consistent development platform that leverages the ubiquity of Javascript.
+<br />
 
-This is the client library for developing applications and devices that communicate to the Nitrogen service.
+**Nitrogen** is a code-generator that takes TypeScript interfaces and generates C++, Swift and Kotlin code and native bindings built on top of the [**react-native-nitro-modules**](../react-native-nitro-modules/) core APIs.
 
-## Device Development Model
+## Installation
 
-Nitrogen at its heart uses messaging between principals (devices and users).  Principals in the system can create and consume messages.  Messages can follow a well known schema to enable interoperability between applications or use their own private custom message types.
-
-For example, a thermometer that measures temperature once every 15 minutes could be implemented in Nitrogen like this:
-
-``` javascript
-var thermometer = new nitrogen.Device({
-    tags: ['sends:temperature'],
-    nickname: 'thermometer'
-});
-
-var service = new nitrogen.Service(config);
-service.connect(thermometer, function(err, session, thermometer) {
-
-    // take temperature every 15 minutes.
-
-    setInterval(function() {
-        var message = new Nitrogen.Message({
-            type: 'temperature',
-            body: {
-                temperature: getTemp()
-            }
-        });
-
-        message.save(session);
-    }, 15 * 60 * 1000);
-
-});
-```
-
-You can find a complete example for a device application of Nitrogen in the [camera](https://github.com/nitrogenjs/camera) project.
-
-## Listening to a device's message stream
-
-An application that displays these temperatures in real time as they are received would look like this.  In this case,
-we're using a user principal, and a filter with onMessage to only notify us of temperature updates.
-
-``` javascript
-var user = new nitrogen.User({...});
-
-var service = new nitrogen.Service(config);
-service.connect(user, function(err, session, user) {
-    session.onMessage({ type: 'temperature' }, function(message) {
-        console.log("The temperature is now: " + message.body.temperature);
-
-        // update the UI
-    });
-});
+Install [nitrogen](https://npmjs.org/nitrogen) as a `devDependency` in your react-native library:
+```sh
+npm i nitrogen -D
 ```
 
-## Getting Started
-
-To get started with a Nitrogen client:
-
-### Node.js application
-
-1. `npm install nitrogen`
-
-### Browser application
-
-1. Add `<script src="https://api.nitrogen.io/client/nitrogen-min.js" />` to your application.
-
-### Documentation
-
-Documentation for the Nitrogen client library can be found online at the [Nitrogen project](http://nitrogen.io).
-
-### Contributing to the project.
-
-1. Clone or fork this repo: `https://github.com/nitrogenjs/client`
-2. If you are building on Windows, make sure to fetch all of the node-gyp dependencies as explained here: https://github.com/TooTallNate/node-gyp#installation
-2. Fetch and install its node.js dependencies: `npm install`
-3. Run a [Nitrogen server](https://github.com/nitrogenjs/service) locally that the tests can run against in test mode (NODE_ENV=test).
-4. Run the tests to make sure everything is setup correctly: `npm test`
-5. Make your change as a clean commit for a pull request.
-6. Make sure there is a test to cover new functionality so nobody can break it in the future without us knowing.
-7. Submit it as a pull request to the project.
-
-## How to contribute
-
-1.  Feedback:  We'd love feedback on what problems you are using Nitrogen to solve.  Obviously, we'd also like to hear about where you ran into sharp edges and dead ends.   Drop me a message at timfpark@gmail.com or file an issue with us above.
-2.  Pull requests:  If you'd like to tackle an issue, fork the repo, create a clean commit for the fix or enhancement with tests if necessary, and send us a pull request. This is also the path to becoming a core committer for the project for folks that are interested in contributing in more depth.
-3.  Documentation:  Better technical documentation is key to broadening the use of the platform.   We'd love to have more help and this is one of the most valuable contributions you can make.
-
-## Running on Windows
-
-On Windows, you'll need to install some dependencies first:
- - [node-gyp](https://github.com/TooTallNate/node-gyp/) (`npm install -g node-gyp`)
-   - [Python 2.7](http://www.python.org/download/releases/2.7.3#download) (not 3.3)
-   - Visual Studio 2010 or higher (including Express editions)
-     - Windows XP/Vista/7:
-       - Microsoft Visual Studio C++ 2010 ([Express](http://go.microsoft.com/?linkid=9709949) version works well)
-       - Also install [Microsoft Visual Studio 2010 Service Pack 1](http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=23691)
-       - For 64-bit builds of node and native modules you will _**also**_ need the [Windows 7 64-bit SDK](http://www.microsoft.com/en-us/download/details.aspx?id=8279)
-       - If you get errors that the 64-bit compilers are not installed you may also need the [compiler update for the Windows SDK 7.1](http://www.microsoft.com/en-us/download/details.aspx?id=4422)
-     - Windows 8:
-       - Microsoft Visual Studio C++ 2012 for Windows Desktop ([Express](http://go.microsoft.com/?linkid=9816758) version works well)
- - [OpenSSL](http://slproweb.com/products/Win32OpenSSL.html) (normal, not light)
-   in the same bitness as your Node.js installation.
-   - The build script looks for OpenSSL in the default install directory  (`C:\OpenSSL-Win32` or `C:\OpenSSL-Win64`)
-   - If you get `Error: The specified module could not be found.`, copy `libeay32.dll` from the OpenSSL bin directory to this module's bin directory, or to Windows\System3.
 
-## Nitrogen Project
 
-The Nitrogen project is housed in a set of GitHub projects:
+## Usage
 
-1. [service](https://github.com/nitrogenjs/service): Core platform responsible for managing principals, security, and messaging.
-2. [client](https://github.com/nitrogenjs/client): JavaScript client library for building Nitrogen devices and applications.
-3. [admin](https://github.com/nitrogenjs/admin): Administrative tool for managing the Nitrogen service.
-4. [device](https://github.com/nitrogenjs/devices): Adaptors for common pieces of hardware.
-5. [commands](https://github.com/nitrogenjs/commands): CommandManagers and schemas for well known command types.
-6. [cli](https://github.com/nitrogenjs/cli): Command line interface for working with a Nitrogen service.
+See the [Nitrogen documentation](https://nitro.margelo.com/docs/nitrogen) for more information.

package/lib/Logger.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error';
+export declare function isValidLogLevel(level: unknown): level is LogLevel;
+export declare function setLogLevel(level: LogLevel): void;
+export declare const Logger: {
+    withIndented(callback: () => void): void;
+    debug(message: string, ...extra: unknown[]): void;
+    info(message: string, ...extra: unknown[]): void;
+    warn(message: string, ...extra: unknown[]): void;
+    error(message: string, ...extra: unknown[]): void;
+};

package/lib/Logger.js

@@ -0,0 +1,56 @@
+const levelMap = {
+    debug: 0,
+    info: 1,
+    warning: 2,
+    error: 3,
+};
+let currentLogLevel = 'info';
+export function isValidLogLevel(level) {
+    // @ts-expect-error
+    return typeof levelMap[level] === 'number';
+}
+export function setLogLevel(level) {
+    currentLogLevel = level;
+}
+function isAtLeast(level) {
+    return levelMap[level] >= levelMap[currentLogLevel];
+}
+let indentation = 0;
+function getIndentation() {
+    let string = '';
+    for (let i = 0; i < indentation; i++) {
+        string += '  ';
+    }
+    return string;
+}
+export const Logger = {
+    withIndented(callback) {
+        try {
+            indentation++;
+            callback();
+        }
+        finally {
+            indentation--;
+        }
+    },
+    debug(message, ...extra) {
+        if (isAtLeast('debug')) {
+            console.debug(getIndentation() + message, ...extra);
+        }
+    },
+    info(message, ...extra) {
+        if (isAtLeast('info')) {
+            console.info(getIndentation() + message, ...extra);
+        }
+    },
+    warn(message, ...extra) {
+        if (isAtLeast('warning')) {
+            console.warn(getIndentation() + message, ...extra);
+        }
+    },
+    error(message, ...extra) {
+        if (isAtLeast('error')) {
+            console.error(getIndentation() + message, ...extra);
+        }
+    },
+};

package/lib/autolinking/Autolinking.d.ts

@@ -0,0 +1,8 @@
+import type { Platform } from '../getPlatformSpecs.js';
+import type { SourceFile } from '../syntax/SourceFile.js';
+type AutolinkingFile = Omit<SourceFile, 'language'>;
+export interface Autolinking {
+    platform: Platform;
+    sourceFiles: AutolinkingFile[];
+}
+export {};

package/lib/autolinking/Autolinking.js

@@ -0,0 +1 @@
+export {};

package/lib/autolinking/android/createCMakeExtension.d.ts

@@ -0,0 +1,6 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface CMakeFile extends Omit<SourceFile, 'language'> {
+    language: 'cmake';
+}
+export declare function getBuildingWithGeneratedCmakeDefinition(): string;
+export declare function createCMakeExtension(files: SourceFile[]): CMakeFile;

package/lib/autolinking/android/createCMakeExtension.js

@@ -0,0 +1,106 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { indent, toLowerCamelCase, toUnixPath } from '../../utils.js';
+import { createFileMetadataString, getRelativeDirectory, getRelativeDirectoryGenerated, isCppFile, isNotDuplicate, } from '../../syntax/helpers.js';
+export function getBuildingWithGeneratedCmakeDefinition() {
+    const moduleName = NitroConfig.current.getAndroidCxxLibName();
+    const upper = toLowerCamelCase(moduleName).toUpperCase();
+    return `BUILDING_${upper}_WITH_GENERATED_CMAKE_PROJECT`;
+}
+export function createCMakeExtension(files) {
+    const name = NitroConfig.current.getAndroidCxxLibName();
+    const sharedFiles = files
+        .filter((f) => f.platform === 'shared' && isCppFile(f))
+        .map((f) => getRelativeDirectory(f))
+        .map((p) => toUnixPath(p))
+        .filter(isNotDuplicate);
+    const androidFiles = files
+        .filter((f) => f.platform === 'android' && isCppFile(f))
+        .map((f) => getRelativeDirectory(f))
+        .map((p) => toUnixPath(p))
+        .filter(isNotDuplicate);
+    const autolinkingFilePath = getRelativeDirectoryGenerated('android', `${name}OnLoad.cpp`);
+    const autolinkingFile = toUnixPath(autolinkingFilePath);
+    const buildingWithDefinition = getBuildingWithGeneratedCmakeDefinition();
+    const code = `
+${createFileMetadataString(`${name}+autolinking.cmake`, '#')}
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# \`\`\`cmake
+# include(\${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/${name}+autolinking.cmake)
+# \`\`\`
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  ${name} PRIVATE
+  # Autolinking Setup
+  ${autolinkingFile}
+  # Shared Nitrogen C++ sources
+  ${indent(sharedFiles.join('\n'), '  ')}
+  # Android-specific Nitrogen C++ sources
+  ${indent(androidFiles.join('\n'), '  ')}
+)
+
+# Define a flag to check if we are building properly
+add_definitions(-D${buildingWithDefinition})
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+ target_compile_definitions(
+  ${name} PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        ${name}
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        ${name}
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ${name}
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()
+  `.trim();
+    return {
+        content: code,
+        language: 'cmake',
+        name: `${name}+autolinking.cmake`,
+        platform: 'android',
+        subdirectory: [],
+    };
+}

package/lib/autolinking/android/createGradleExtension.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface GradleFile extends Omit<SourceFile, 'language'> {
+    language: 'gradle';
+}
+export declare function createGradleExtension(): GradleFile;

package/lib/autolinking/android/createGradleExtension.js

@@ -0,0 +1,36 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { createFileMetadataString } from '../../syntax/helpers.js';
+export function createGradleExtension() {
+    const name = NitroConfig.current.getAndroidCxxLibName();
+    const code = `
+${createFileMetadataString(`${name}+autolinking.gradle`)}
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// \`\`\`gradle
+/// apply from: '../nitrogen/generated/android/${name}+autolinking.gradle'
+/// \`\`\`
+
+logger.warn("[NitroModules] 🔥 ${name} is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "\${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}
+  `.trim();
+    return {
+        content: code,
+        language: 'gradle',
+        name: `${name}+autolinking.gradle`,
+        platform: 'android',
+        subdirectory: [],
+    };
+}

package/lib/autolinking/android/createHybridObjectInitializer.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function createHybridObjectIntializer(): SourceFile[];

package/lib/autolinking/android/createHybridObjectInitializer.js

@@ -0,0 +1,159 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { createCppHybridObjectRegistration } from '../../syntax/c++/CppHybridObjectRegistration.js';
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js';
+import { createFileMetadataString, isNotDuplicate, } from '../../syntax/helpers.js';
+import { getJNINativeRegistrations } from '../../syntax/kotlin/JNINativeRegistrations.js';
+import { createJNIHybridObjectRegistration } from '../../syntax/kotlin/KotlinHybridObjectRegistration.js';
+import { indent } from '../../utils.js';
+import { getBuildingWithGeneratedCmakeDefinition } from './createCMakeExtension.js';
+export function createHybridObjectIntializer() {
+    const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
+    const cppLibName = NitroConfig.current.getAndroidCxxLibName();
+    const javaNamespace = NitroConfig.current.getAndroidPackage('java/kotlin');
+    const autolinkingClassName = `${NitroConfig.current.getAndroidCxxLibName()}OnLoad`;
+    const jniRegistrations = getJNINativeRegistrations()
+        .map((r) => `${r.namespace}::${r.className}::registerNatives();`)
+        .filter(isNotDuplicate);
+    const autolinkedHybridObjects = NitroConfig.current.getAutolinkedHybridObjects();
+    const cppHybridObjectImports = [];
+    const cppRegistrations = [];
+    for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
+        const config = autolinkedHybridObjects[hybridObjectName];
+        if (config?.cpp != null) {
+            // Autolink a C++ HybridObject!
+            const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+                hybridObjectName: hybridObjectName,
+                cppClassName: config.cpp,
+            });
+            cppHybridObjectImports.push(...requiredImports);
+            cppRegistrations.push(cppCode);
+        }
+        if (config?.kotlin != null) {
+            // Autolink a Kotlin HybridObject through JNI/C++!
+            const { cppCode, requiredImports } = createJNIHybridObjectRegistration({
+                hybridObjectName: hybridObjectName,
+                jniClassName: config.kotlin,
+            });
+            cppHybridObjectImports.push(...requiredImports);
+            cppRegistrations.push(cppCode);
+        }
+    }
+    const buildingWithDefinition = getBuildingWithGeneratedCmakeDefinition();
+    const includes = [
+        ...getJNINativeRegistrations().map((r) => includeHeader(r.import)),
+        ...cppHybridObjectImports.map((i) => includeHeader(i)),
+    ]
+        .filter(isNotDuplicate)
+        .join('\n');
+    const hppCode = `
+${createFileMetadataString(`${autolinkingClassName}.hpp`)}
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace ${cxxNamespace} {
+
+  /**
+   * Initializes the native (C++) part of ${cppLibName}, and autolinks all Hybrid Objects.
+   * Call this in your \`JNI_OnLoad\` function (probably inside \`cpp-adapter.cpp\`).
+   * Example:
+   * \`\`\`cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return ${cxxNamespace}::initialize(vm);
+   * }
+   * \`\`\`
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace ${cxxNamespace}
+
+    `;
+    const cppCode = `
+${createFileMetadataString(`${autolinkingClassName}.cpp`)}
+
+#ifndef ${buildingWithDefinition}
+#error ${autolinkingClassName}.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "${autolinkingClassName}.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+${includes}
+
+namespace ${cxxNamespace} {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace ${cxxNamespace};
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    ${indent(jniRegistrations.join('\n'), '    ')}
+
+    // Register Nitro Hybrid Objects
+    ${indent(cppRegistrations.join('\n'), '    ')}
+  });
+}
+
+} // namespace ${cxxNamespace}
+  `.trim();
+    const kotlinCode = `
+${createFileMetadataString(`${autolinkingClassName}.kt`)}
+
+package ${javaNamespace}
+
+import android.util.Log
+
+internal class ${autolinkingClassName} {
+  companion object {
+    private const val TAG = "${autolinkingClassName}"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "${cppLibName}".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading ${cppLibName} C++ library...")
+        System.loadLibrary("${cppLibName}")
+        Log.i(TAG, "Successfully loaded ${cppLibName} C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load ${cppLibName} C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see \`CMakeLists.txt\`, at \`add_library(...)\`)", e)
+        throw e
+      }
+    }
+  }
+}
+  `.trim();
+    return [
+        {
+            content: hppCode,
+            language: 'c++',
+            name: `${autolinkingClassName}.hpp`,
+            platform: 'android',
+            subdirectory: [],
+        },
+        {
+            content: cppCode,
+            language: 'c++',
+            name: `${autolinkingClassName}.cpp`,
+            platform: 'android',
+            subdirectory: [],
+        },
+        {
+            content: kotlinCode,
+            language: 'kotlin',
+            name: `${autolinkingClassName}.kt`,
+            platform: 'android',
+            subdirectory: ['kotlin', ...javaNamespace.split('.')],
+        },
+    ];
+}

package/lib/autolinking/createAndroidAutolinking.d.ts

@@ -0,0 +1,11 @@
+import type { SourceFile, SourceImport } from '../syntax/SourceFile.js';
+import type { Autolinking } from './Autolinking.js';
+interface JNIHybridRegistration {
+    sourceImport: SourceImport;
+    registrationCode: string;
+}
+interface AndroidAutolinking extends Autolinking {
+    jniHybridRegistrations: JNIHybridRegistration[];
+}
+export declare function createAndroidAutolinking(allFiles: SourceFile[]): AndroidAutolinking;
+export {};

package/lib/autolinking/createAndroidAutolinking.js

@@ -0,0 +1,13 @@
+import { createCMakeExtension } from './android/createCMakeExtension.js';
+import { createGradleExtension } from './android/createGradleExtension.js';
+import { createHybridObjectIntializer } from './android/createHybridObjectInitializer.js';
+export function createAndroidAutolinking(allFiles) {
+    const cmakeExtension = createCMakeExtension(allFiles);
+    const gradleExtension = createGradleExtension();
+    const hybridObjectInitializer = createHybridObjectIntializer();
+    return {
+        platform: 'android',
+        jniHybridRegistrations: [],
+        sourceFiles: [cmakeExtension, gradleExtension, ...hybridObjectInitializer],
+    };
+}

package/lib/autolinking/createIOSAutolinking.d.ts

@@ -0,0 +1,5 @@
+import type { Autolinking } from './Autolinking.js';
+interface IOSAutolinking extends Autolinking {
+}
+export declare function createIOSAutolinking(): IOSAutolinking;
+export {};

package/lib/autolinking/createIOSAutolinking.js

@@ -0,0 +1,19 @@
+import { createHybridObjectIntializer } from './ios/createHybridObjectInitializer.js';
+import { createPodspecRubyExtension } from './ios/createPodspecRubyExtension.js';
+import { createSwiftCxxBridge } from './ios/createSwiftCxxBridge.js';
+import { createSwiftUmbrellaHeader } from './ios/createSwiftUmbrellaHeader.js';
+export function createIOSAutolinking() {
+    const podspecExtension = createPodspecRubyExtension();
+    const swiftCxxBridge = createSwiftCxxBridge();
+    const swiftUmbrellaHeader = createSwiftUmbrellaHeader();
+    const hybridObjectInitializer = createHybridObjectIntializer();
+    return {
+        platform: 'ios',
+        sourceFiles: [
+            podspecExtension,
+            ...swiftCxxBridge,
+            swiftUmbrellaHeader,
+            ...hybridObjectInitializer,
+        ],
+    };
+}

package/lib/autolinking/ios/createHybridObjectInitializer.d.ts

@@ -0,0 +1,9 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+type ObjcFile = Omit<SourceFile, 'language'> & {
+    language: 'objective-c++';
+};
+type SwiftFile = Omit<SourceFile, 'language'> & {
+    language: 'swift';
+};
+export declare function createHybridObjectIntializer(): [ObjcFile, SwiftFile] | [];
+export {};