nitrogen 0.2.23 → 0.29.4

package/lib/views/swift/SwiftHybridViewManager.js

@@ -0,0 +1,131 @@
+import { createViewComponentShadowNodeFiles, getViewComponentNames, } from '../CppHybridViewComponent.js';
+import { createFileMetadataString, escapeCppName, } from '../../syntax/helpers.js';
+import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrellaHeader.js';
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js';
+import { getHybridObjectConstructorCall } from '../../syntax/swift/SwiftHybridObjectRegistration.js';
+import { indent } from '../../utils.js';
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js';
+export function createSwiftHybridViewManager(spec) {
+    const cppFiles = createViewComponentShadowNodeFiles(spec);
+    const namespace = spec.config.getCxxNamespace('c++');
+    const swiftNamespace = spec.config.getIosModuleName();
+    const { HybridTSpec, HybridTSpecSwift, HybridTSpecCxx } = getHybridObjectName(spec.name);
+    const { component, descriptorClassName, propsClassName } = getViewComponentNames(spec);
+    const autolinking = spec.config.getAutolinkedHybridObjects();
+    const viewImplementation = autolinking[spec.name]?.swift;
+    if (viewImplementation == null) {
+        throw new Error(`Cannot create Swift HybridView ViewManager for ${spec.name} - it is not autolinked in nitro.json!`);
+    }
+    const propAssignments = spec.properties.map((p) => {
+        const name = escapeCppName(p.name);
+        const setter = p.getSetterName('swift');
+        const bridge = new SwiftCxxBridgedType(p.type, false);
+        const parse = bridge.parseFromCppToSwift(`newViewProps.${name}.value`, 'c++');
+        return `
+// ${p.jsSignature}
+if (newViewProps.${name}.isDirty) {
+  swiftPart.${setter}(${indent(parse, '  ')});
+  newViewProps.${name}.isDirty = false;
+}
+`.trim();
+    });
+    const mmFile = `
+${createFileMetadataString(`${component}.mm`)}
+
+#import "${component}.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "${HybridTSpecSwift}.hpp"
+#import "${getUmbrellaHeaderName()}"
+
+using namespace facebook;
+using namespace ${namespace};
+using namespace ${namespace}::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "${spec.name}" HybridView.
+ */
+@interface ${component}: RCTViewComponentView
+@end
+
+@implementation ${component} {
+  std::shared_ptr<${HybridTSpecSwift}> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[${component} class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<${descriptorClassName}>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<${HybridTSpec}> hybridView = ${getHybridObjectConstructorCall(spec.name)}
+    _hybridView = std::dynamic_pointer_cast<${HybridTSpecSwift}>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<${propsClassName} const>(props);
+  auto& newViewProps = const_cast<${propsClassName}&>(newViewPropsConst);
+  ${swiftNamespace}::${HybridTSpecCxx}& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  ${indent(propAssignments.join('\n'), '  ')}
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+  `;
+    return [
+        ...cppFiles,
+        {
+            content: mmFile,
+            language: 'c++',
+            name: `${component}.mm`,
+            platform: 'ios',
+            subdirectory: ['views'],
+        },
+    ];
+}

package/lib/writeFile.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from './syntax/SourceFile.js';
+/**
+ * Writes the given file to disk and returns it's actual path.
+ */
+export declare function writeFile(basePath: string, file: SourceFile): Promise<string>;

package/lib/writeFile.js

@@ -0,0 +1,19 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { capitalizeName } from './utils.js';
+import chalk from 'chalk';
+import { Logger } from './Logger.js';
+/**
+ * Writes the given file to disk and returns it's actual path.
+ */
+export async function writeFile(basePath, file) {
+    const filepath = path.join(basePath, ...file.subdirectory, file.name);
+    const language = capitalizeName(file.language);
+    Logger.debug(`          ${chalk.dim(language)}: Creating ${file.name}...`);
+    const dir = path.dirname(filepath);
+    // Create directory if it doesn't exist yet
+    await fs.mkdir(dir, { recursive: true });
+    // Write file
+    await fs.writeFile(filepath, file.content.trim() + '\n', 'utf8');
+    return filepath;
+}

package/package.json

@@ -1,40 +1,69 @@
 {
   "name": "nitrogen",
-  "homepage": "https://github.com/nitrogenjs/client",
-  "author": "Tim Park <timfpark@gmail.com>",
-  "licenses": [
-    {
-      "type": "Apache",
-      "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
-    }
+  "version": "0.29.4",
+  "description": "The code-generator for react-native-nitro-modules.",
+  "main": "lib/index",
+  "types": "lib/index.d.ts",
+  "source": "src/index",
+  "type": "module",
+  "files": [
+    "lib",
+    "src",
+    "README.md"
   ],
-  "main": "./lib",
+  "bin": "./lib/index.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nitrogenjs/client.git"
+    "url": "git+https://github.com/mrousavy/nitro.git"
   },
-  "version": "0.2.23",
-  "dependencies": {
-    "async": "~0.2.10",
-    "request": "~2.36.0",
-    "socket.io-client": "~0.9.16"
+  "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mrousavy/nitro/issues"
   },
-  "devDependencies": {
-    "nitrogen-browser-request": "~0.3.2",
-    "mocha": "~1.17.1",
-    "uglify-js": "~2.4.13",
-    "jsdox": "~0.2.6"
+  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "test": "mocha",
-    "postpublish": "scripts/build-documentation"
+    "postinstall": "bun build || exit 0;",
+    "build": "bun tsc",
+    "start": "tsc && node lib/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
+    "release": "release-it"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "react-native-nitro-modules": "^0.29.4",
+    "ts-morph": "^25.0.0",
+    "yargs": "^17.7.2",
+    "zod": "^4.0.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.8.4"
   },
-  "keywords": [
-    "devices",
-    "iot",
-    "nitrogen",
-    "pi",
-    "raspberry",
-    "raspberry pi"
-  ]
+  "release-it": {
+    "npm": {
+      "publish": true
+    },
+    "git": false,
+    "github": {
+      "release": false
+    },
+    "hooks": {
+      "before:init": "bun typecheck && bun lint",
+      "after:bump": "bun run build"
+    },
+    "plugins": {
+      "@release-it/bumper": {
+        "out": {
+          "file": "package.json",
+          "path": "dependencies.react-native-nitro-modules",
+          "versionPrefix": "^"
+        }
+      }
+    }
+  }
 }

package/src/Logger.ts

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

package/src/autolinking/Autolinking.ts

@@ -0,0 +1,9 @@
+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[]
+}

package/src/autolinking/android/createCMakeExtension.ts

@@ -0,0 +1,123 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent, toLowerCamelCase, toUnixPath } from '../../utils.js'
+import {
+  createFileMetadataString,
+  getRelativeDirectory,
+  getRelativeDirectoryGenerated,
+  isCppFile,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface CMakeFile extends Omit<SourceFile, 'language'> {
+  language: 'cmake'
+}
+
+export function getBuildingWithGeneratedCmakeDefinition(): string {
+  const moduleName = NitroConfig.current.getAndroidCxxLibName()
+  const upper = toLowerCamelCase(moduleName).toUpperCase()
+  return `BUILDING_${upper}_WITH_GENERATED_CMAKE_PROJECT`
+}
+
+export function createCMakeExtension(files: SourceFile[]): CMakeFile {
+  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/src/autolinking/android/createGradleExtension.ts

@@ -0,0 +1,43 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface GradleFile extends Omit<SourceFile, 'language'> {
+  language: 'gradle'
+}
+
+export function createGradleExtension(): GradleFile {
+  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/src/autolinking/android/createHybridObjectInitializer.ts

@@ -0,0 +1,174 @@
+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 type { SourceFile, SourceImport } from '../../syntax/SourceFile.js'
+import { indent } from '../../utils.js'
+import { getBuildingWithGeneratedCmakeDefinition } from './createCMakeExtension.js'
+
+export function createHybridObjectIntializer(): SourceFile[] {
+  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: SourceImport[] = []
+  const cppRegistrations: string[] = []
+  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('.')],
+    },
+  ]
+}