nitrogen 0.2.23 → 0.29.4

package/src/autolinking/createAndroidAutolinking.ts

@@ -0,0 +1,28 @@
+import type { SourceFile, SourceImport } from '../syntax/SourceFile.js'
+import { createCMakeExtension } from './android/createCMakeExtension.js'
+import { createGradleExtension } from './android/createGradleExtension.js'
+import { createHybridObjectIntializer } from './android/createHybridObjectInitializer.js'
+import type { Autolinking } from './Autolinking.js'
+
+interface JNIHybridRegistration {
+  sourceImport: SourceImport
+  registrationCode: string
+}
+
+interface AndroidAutolinking extends Autolinking {
+  jniHybridRegistrations: JNIHybridRegistration[]
+}
+
+export function createAndroidAutolinking(
+  allFiles: SourceFile[]
+): AndroidAutolinking {
+  const cmakeExtension = createCMakeExtension(allFiles)
+  const gradleExtension = createGradleExtension()
+  const hybridObjectInitializer = createHybridObjectIntializer()
+
+  return {
+    platform: 'android',
+    jniHybridRegistrations: [],
+    sourceFiles: [cmakeExtension, gradleExtension, ...hybridObjectInitializer],
+  }
+}

package/src/autolinking/createIOSAutolinking.ts

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

package/src/autolinking/ios/createHybridObjectInitializer.ts

@@ -0,0 +1,112 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createCppHybridObjectRegistration } from '../../syntax/c++/CppHybridObjectRegistration.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile, SourceImport } from '../../syntax/SourceFile.js'
+import { createSwiftHybridObjectRegistration } from '../../syntax/swift/SwiftHybridObjectRegistration.js'
+import { indent } from '../../utils.js'
+import { getUmbrellaHeaderName } from './createSwiftUmbrellaHeader.js'
+
+type ObjcFile = Omit<SourceFile, 'language'> & { language: 'objective-c++' }
+type SwiftFile = Omit<SourceFile, 'language'> & { language: 'swift' }
+
+export function createHybridObjectIntializer(): [ObjcFile, SwiftFile] | [] {
+  const autolinkingClassName = `${NitroConfig.current.getIosModuleName()}Autolinking`
+  const umbrellaHeaderName = getUmbrellaHeaderName()
+  const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('swift')
+
+  const autolinkedHybridObjects =
+    NitroConfig.current.getAutolinkedHybridObjects()
+
+  const swiftFunctions: string[] = []
+  const cppRegistrations: string[] = []
+  const cppImports: SourceImport[] = []
+  let containsSwiftObjects = false
+  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,
+      })
+      cppImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+    }
+    if (config?.swift != null) {
+      // Autolink a Swift HybridObject!
+      containsSwiftObjects = true
+      const { cppCode, requiredImports, swiftFunction } =
+        createSwiftHybridObjectRegistration({
+          hybridObjectName: hybridObjectName,
+          swiftClassName: config.swift,
+        })
+      cppImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+      swiftFunctions.push(swiftFunction)
+    }
+  }
+
+  if (cppRegistrations.length === 0) {
+    // Nothing to autolink!
+    return []
+  }
+
+  const umbrellaImport = containsSwiftObjects
+    ? `#import "${umbrellaHeaderName}"`
+    : ''
+  const imports = cppImports.map((i) => includeHeader(i, true)).join('\n')
+
+  const objcCode = `
+${createFileMetadataString(`${autolinkingClassName}.mm`)}
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+${umbrellaImport}
+#import <type_traits>
+
+${imports}
+
+@interface ${autolinkingClassName} : NSObject
+@end
+
+@implementation ${autolinkingClassName}
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace ${NitroConfig.current.getCxxNamespace('c++')};
+
+  ${indent(cppRegistrations.join('\n'), '  ')}
+}
+
+@end
+  `.trim()
+
+  const swiftCode = `
+${createFileMetadataString(`${autolinkingClassName}.swift`)}
+
+public final class ${autolinkingClassName} {
+  public typealias bridge = ${bridgeNamespace}
+
+  ${indent(swiftFunctions.join('\n\n'), '  ')}
+}
+  `.trim()
+
+  return [
+    {
+      content: objcCode,
+      language: 'objective-c++',
+      name: `${autolinkingClassName}.mm`,
+      platform: 'ios',
+      subdirectory: [],
+    },
+    {
+      content: swiftCode,
+      language: 'swift',
+      name: `${autolinkingClassName}.swift`,
+      platform: 'ios',
+      subdirectory: [],
+    },
+  ]
+}

package/src/autolinking/ios/createPodspecRubyExtension.ts

@@ -0,0 +1,76 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface RubyFile extends Omit<SourceFile, 'language'> {
+  language: 'ruby'
+}
+
+export function createPodspecRubyExtension(): RubyFile {
+  const name = NitroConfig.current.getIosModuleName()
+
+  const code = `
+${createFileMetadataString(`${name}+autolinking.rb`, '#')}
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# \`\`\`ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/${name}+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# \`\`\`
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 ${name} is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/${name}-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+  })
+end
+  `.trim()
+  return {
+    content: code,
+    language: 'ruby',
+    name: `${name}+autolinking.rb`,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/autolinking/ios/createSwiftCxxBridge.ts

@@ -0,0 +1,137 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { getAllKnownTypes } from '../../syntax/createType.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import { getReferencedTypes } from '../../syntax/getReferencedTypes.js'
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js'
+import { filterDuplicateHelperBridges, indent } from '../../utils.js'
+import { getTypeAs } from '../../syntax/types/getTypeAs.js'
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js'
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+
+export function createSwiftCxxBridge(): SourceFile[] {
+  const bridgeName = NitroConfig.current.getSwiftBridgeHeaderName()
+  const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('c++')
+
+  const types = getAllKnownTypes('swift').map((t) => new SwiftCxxBridgedType(t))
+
+  const bridges = types
+    .flatMap((t) => {
+      const referenced = getReferencedTypes(t.type)
+      return referenced.map((r) => {
+        const bridge = new SwiftCxxBridgedType(r)
+        return bridge.getRequiredBridge()
+      })
+    })
+    .filter((b) => b != null)
+    .flatMap((b) => [b, ...b?.dependencies])
+    .filter(filterDuplicateHelperBridges)
+  const headerHelperFunctions = bridges
+    .map((b) => `// pragma MARK: ${b.cxxType}\n${b.cxxHeader.code}`)
+    .filter(isNotDuplicate)
+    .join('\n\n')
+  const implementationHelperFunctions = bridges
+    .map((b) => {
+      if (b.cxxImplementation == null) return undefined
+      else return `// pragma MARK: ${b.cxxType}\n${b.cxxImplementation.code}`
+    })
+    .filter((c) => c != null)
+    .filter(isNotDuplicate)
+    .join('\n\n')
+
+  const requiredImportsHeader = bridges.flatMap(
+    (b) => b.cxxHeader.requiredIncludes
+  )
+  const includesHeader = requiredImportsHeader
+    .map((i) => includeHeader(i, true))
+    .filter(isNotDuplicate)
+  const forwardDeclarationsHeader = requiredImportsHeader
+    .map((i) => i.forwardDeclaration)
+    .filter((f) => f != null)
+    .filter(isNotDuplicate)
+
+  const includesImplementation = bridges
+    .flatMap((b) => b.cxxImplementation?.requiredIncludes)
+    .filter((i) => i != null)
+    .map((i) => includeHeader(i, true))
+    .filter(isNotDuplicate)
+
+  const forwardDeclaredSwiftTypes = types
+    .filter((t) => t.type.kind === 'hybrid-object')
+    .map((t) => {
+      const hybridObject = getTypeAs(t.type, HybridObjectType)
+      const hybridObjectModuleName =
+        hybridObject.sourceConfig.getIosModuleName()
+      const { HybridTSpecCxx } = getHybridObjectName(
+        hybridObject.hybridObjectName
+      )
+      return getForwardDeclaration(
+        'class',
+        HybridTSpecCxx,
+        hybridObjectModuleName
+      )
+    })
+    .filter(isNotDuplicate)
+
+  const header = `
+${createFileMetadataString(`${bridgeName}.hpp`)}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarationsHeader.sort().join('\n')}
+
+// Forward declarations of Swift defined types
+${forwardDeclaredSwiftTypes.sort().join('\n')}
+
+// Include C++ defined types
+${includesHeader.sort().join('\n')}
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace ${bridgeNamespace} {
+
+  ${indent(headerHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`
+
+  const source = `
+${createFileMetadataString(`${bridgeName}.cpp`)}
+
+#include "${bridgeName}.hpp"
+
+// Include C++ implementation defined types
+${includesImplementation.sort().join('\n')}
+
+namespace ${bridgeNamespace} {
+
+  ${indent(implementationHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`
+
+  const files: SourceFile[] = []
+  files.push({
+    content: header,
+    language: 'c++',
+    name: `${bridgeName}.hpp`,
+    platform: 'ios',
+    subdirectory: [],
+  })
+  files.push({
+    content: source,
+    language: 'c++',
+    name: `${bridgeName}.cpp`,
+    platform: 'ios',
+    subdirectory: [],
+  })
+  return files
+}

package/src/autolinking/ios/createSwiftUmbrellaHeader.ts

@@ -0,0 +1,90 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { getAllKnownTypes } from '../../syntax/createType.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import { getTypeAs } from '../../syntax/types/getTypeAs.js'
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js'
+
+export function getUmbrellaHeaderName(): string {
+  const moduleName = NitroConfig.current.getIosModuleName()
+  return `${moduleName}-Swift-Cxx-Umbrella.hpp`
+}
+
+export function createSwiftUmbrellaHeader(): SourceFile {
+  const moduleName = NitroConfig.current.getIosModuleName()
+  const filename = getUmbrellaHeaderName()
+
+  const types = getAllKnownTypes('swift')
+
+  const swiftForwardDeclares = types
+    .filter((t) => t.kind === 'hybrid-object')
+    .map((t) => {
+      const hybridObjectType = getTypeAs(t, HybridObjectType)
+      const hybridObjectModuleName =
+        hybridObjectType.sourceConfig.getIosModuleName()
+      const name = getHybridObjectName(hybridObjectType.hybridObjectName)
+      return getForwardDeclaration(
+        'class',
+        name.HybridTSpecCxx,
+        hybridObjectModuleName
+      )
+    })
+    .filter(isNotDuplicate)
+
+  const imports = types.flatMap((t) => t.getRequiredImports('c++'))
+  const forwardDeclarations = imports
+    .map((i) => i.forwardDeclaration)
+    .filter((f) => f != null)
+    .filter(isNotDuplicate)
+  const includes = imports.map((i) => includeHeader(i)).filter(isNotDuplicate)
+
+  const code = `
+${createFileMetadataString(filename, '///')}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarations.sort().join('\n')}
+
+// Include C++ defined types
+${includes.sort().join('\n')}
+
+// C++ helpers for Swift
+#include "${moduleName}-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+${swiftForwardDeclares.sort().join('\n')}
+
+// Include Swift defined types
+#if __has_include("${moduleName}-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "${moduleName}".
+#include "${moduleName}-Swift.h"
+// Same as above, but used when building with frameworks (\`use_frameworks\`)
+#elif __has_include(<${moduleName}/${moduleName}-Swift.h>)
+#include <${moduleName}/${moduleName}-Swift.h>
+#else
+#error ${moduleName}'s autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "${moduleName}", and try building the app first.
+#endif
+`
+
+  return {
+    content: code,
+    language: 'c++',
+    name: filename,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/config/NitroConfig.ts

@@ -0,0 +1,139 @@
+import chalk from 'chalk'
+import { readUserConfig } from './getConfig.js'
+import type { NitroUserConfig } from './NitroUserConfig.js'
+
+const CXX_BASE_NAMESPACE = ['margelo', 'nitro']
+const ANDROID_BASE_NAMESPACE = ['com', 'margelo', 'nitro']
+
+/**
+ * Represents the properly parsed `nitro.json` config of the current executing directory.
+ */
+export class NitroConfig {
+  private readonly config: NitroUserConfig
+  private static singleton: NitroConfig | undefined
+
+  constructor(config: NitroUserConfig) {
+    this.config = config
+  }
+
+  static get current(): NitroConfig {
+    if (this.singleton == null) {
+      console.log(
+        chalk.reset(`🔧  Loading ${chalk.underline('nitro.json')} config...`)
+      )
+      const defaultConfigPath = './nitro.json'
+      const config = readUserConfig(defaultConfigPath)
+      this.singleton = new NitroConfig(config)
+    }
+    return this.singleton
+  }
+
+  /**
+   * Returns the name of the Android C++ library (aka name in CMakeLists.txt `add_library(..)`).
+   * This will be loaded via `System.loadLibrary(...)`.
+   * @example `NitroTest`
+   */
+  getAndroidCxxLibName(): string {
+    return this.config.android.androidCxxLibName
+  }
+
+  /**
+   * Returns the iOS module name (aka Pod name) of the module that will be generated.
+   * @example `NitroTest`
+   */
+  getIosModuleName(): string {
+    return this.config.ios.iosModuleName
+  }
+
+  /**
+   * Represents the C++ namespace of the module that will be generated.
+   * This can have multiple sub-namespaces, and is always relative to `margelo::nitro`.
+   * @example `['image']` -> `margelo::nitro::image`
+   */
+  getCxxNamespace(
+    language: 'c++' | 'swift',
+    ...subDefinitionName: string[]
+  ): string {
+    const userNamespace = this.config.cxxNamespace
+    const namespace = [
+      ...CXX_BASE_NAMESPACE,
+      ...userNamespace,
+      ...subDefinitionName,
+    ]
+    switch (language) {
+      case 'c++':
+        return namespace.join('::')
+      case 'swift':
+        return namespace.join('.')
+      default:
+        throw new Error(`Invalid language for getCxxNamespace: ${language}`)
+    }
+  }
+
+  /**
+   * Represents the Android namespace of the module that will be generated.
+   * This can have multiple sub-namespaces, and is always relative to `com.margelo.nitro`.
+   * @example `['image']` -> `com.margelo.nitro.image`
+   */
+  getAndroidPackage(
+    language: 'java/kotlin' | 'c++/jni',
+    ...subPackage: string[]
+  ): string {
+    const userPackage = this.config.android.androidNamespace
+    const namespace = [...ANDROID_BASE_NAMESPACE, ...userPackage, ...subPackage]
+
+    switch (language) {
+      case 'java/kotlin':
+        return namespace.join('.')
+      case 'c++/jni':
+        return namespace.join('/')
+      default:
+        throw new Error(`Invalid language for getAndroidPackage: ${language}`)
+    }
+  }
+
+  /**
+   * Return the directory of the android package, and a given sub-package.
+   * This will be used on android to put files from a package in their respective package folder.
+   */
+  getAndroidPackageDirectory(...subPackage: string[]): string[] {
+    const userPackage = this.config.android.androidNamespace
+    return [...ANDROID_BASE_NAMESPACE, ...userPackage, ...subPackage]
+  }
+
+  /**
+   * Get the autolinking configuration of all HybridObjects.
+   * Those will be generated and default-constructed.
+   */
+  getAutolinkedHybridObjects(): NitroUserConfig['autolinking'] {
+    return this.config.autolinking
+  }
+
+  /**
+   * Get the paths that will be ignored when loading the TypeScript project.
+   * In most cases, this just contains `node_modules/`.
+   */
+  getIgnorePaths(): string[] {
+    return this.config.ignorePaths ?? []
+  }
+
+  getGitAttributesGeneratedFlag(): boolean {
+    return this.config.gitAttributesGeneratedFlag ?? false
+  }
+
+  get isExternalConfig(): boolean {
+    // If the C++ namespaces are NOT equal, we are an external config.
+    return (
+      this.getCxxNamespace('c++') !== NitroConfig.current.getCxxNamespace('c++')
+    )
+  }
+
+  getSwiftBridgeHeaderName(): string {
+    const moduleName = this.getIosModuleName()
+    return `${moduleName}-Swift-Cxx-Bridge`
+  }
+
+  getSwiftBridgeNamespace(language: 'c++' | 'swift'): string {
+    return this.getCxxNamespace(language, 'bridge', 'swift')
+  }
+}