nitrogen 0.2.24 → 0.29.5

package/src/nitrogen.ts

@@ -0,0 +1,246 @@
+import { Project } from 'ts-morph'
+import {
+  extendsHybridObject,
+  isHybridView,
+  getHybridObjectPlatforms,
+  getHybridViewPlatforms,
+  type Platform,
+} from './getPlatformSpecs.js'
+import { generatePlatformFiles } from './createPlatformSpec.js'
+import path from 'path'
+import { prettifyDirectory } from './prettifyDirectory.js'
+import {
+  capitalizeName,
+  deduplicateFiles,
+  errorToString,
+  indent,
+  NITROGEN_VERSION,
+} from './utils.js'
+import { writeFile } from './writeFile.js'
+import chalk from 'chalk'
+import { groupByPlatform, type SourceFile } from './syntax/SourceFile.js'
+import { Logger } from './Logger.js'
+import { NitroConfig } from './config/NitroConfig.js'
+import { createIOSAutolinking } from './autolinking/createIOSAutolinking.js'
+import { createAndroidAutolinking } from './autolinking/createAndroidAutolinking.js'
+import type { Autolinking } from './autolinking/Autolinking.js'
+import { createGitAttributes } from './createGitAttributes.js'
+import type { PlatformSpec } from 'react-native-nitro-modules'
+
+interface NitrogenOptions {
+  baseDirectory: string
+  outputDirectory: string
+}
+
+interface NitrogenResult {
+  generatedFiles: string[]
+  targetSpecsCount: number
+  generatedSpecsCount: number
+}
+
+export async function runNitrogen({
+  baseDirectory,
+  outputDirectory,
+}: NitrogenOptions): Promise<NitrogenResult> {
+  let targetSpecs = 0
+  let generatedSpecs = 0
+
+  // Create the TS project
+  const project = new Project({
+    compilerOptions: {
+      strict: true,
+      strictNullChecks: true,
+      noUncheckedIndexedAccess: true,
+    },
+  })
+
+  const ignorePaths = NitroConfig.current.getIgnorePaths()
+  const globPattern = [path.join(baseDirectory, '**', '*.nitro.ts')]
+  ignorePaths.forEach((ignorePath) => {
+    globPattern.push('!' + path.join(baseDirectory, ignorePath))
+  })
+  project.addSourceFilesAtPaths(globPattern)
+
+  // Loop through all source files to log them
+  Logger.info(
+    chalk.reset(
+      `🚀  Nitrogen ${chalk.bold(NITROGEN_VERSION)} runs at ${chalk.underline(prettifyDirectory(baseDirectory))}`
+    )
+  )
+  for (const dir of project.getDirectories()) {
+    const specs = dir.getSourceFiles().length
+    const relativePath = prettifyDirectory(dir.getPath())
+    Logger.info(
+      `    🔍  Nitrogen found ${specs} spec${specs === 1 ? '' : 's'} in ${chalk.underline(relativePath)}`
+    )
+  }
+
+  // If no source files are found, we can exit
+  if (project.getSourceFiles().length === 0) {
+    const searchDir = prettifyDirectory(
+      path.join(path.resolve(baseDirectory), '**', '*.nitro.ts')
+    )
+    Logger.error(
+      `❌  Nitrogen didn't find any spec files in ${chalk.underline(searchDir)}! ` +
+        `To create a Nitro Module, create a TypeScript file with the "${chalk.underline('.nitro.ts')}" suffix ` +
+        'and export an interface that extends HybridObject<T>.'
+    )
+    process.exit()
+  }
+
+  const usedPlatforms: Platform[] = []
+  const filesAfter: string[] = []
+  const writtenFiles: SourceFile[] = []
+
+  for (const sourceFile of project.getSourceFiles()) {
+    Logger.info(`⏳  Parsing ${sourceFile.getBaseName()}...`)
+
+    const startedWithSpecs = generatedSpecs
+
+    // Find all interfaceDeclarations in the given file
+    const declarations = [
+      ...sourceFile.getInterfaces(),
+      ...sourceFile.getTypeAliases(),
+    ]
+    for (const declaration of declarations) {
+      let typeName = declaration.getName()
+      try {
+        let platformSpec: PlatformSpec
+        if (isHybridView(declaration.getType())) {
+          // Hybrid View Props
+          const targetPlatforms = getHybridViewPlatforms(declaration)
+          if (targetPlatforms == null) {
+            // It does not extend HybridView, continue..
+            continue
+          }
+          platformSpec = targetPlatforms
+        } else if (extendsHybridObject(declaration.getType(), true)) {
+          // Hybrid View
+          const targetPlatforms = getHybridObjectPlatforms(declaration)
+          if (targetPlatforms == null) {
+            // It does not extend HybridObject, continue..
+            continue
+          }
+          platformSpec = targetPlatforms
+        } else {
+          continue
+        }
+
+        const platforms = Object.keys(platformSpec) as Platform[]
+
+        if (platforms.length === 0) {
+          Logger.warn(
+            `⚠️   ${typeName} does not declare any platforms in HybridObject<T> - nothing can be generated.`
+          )
+          continue
+        }
+
+        targetSpecs++
+
+        Logger.info(
+          `    ⚙️   Generating specs for HybridObject "${chalk.bold(typeName)}"...`
+        )
+
+        // Create all files and throw it into a big list
+        let allFiles = platforms.flatMap((p) => {
+          usedPlatforms.push(p)
+          const language = platformSpec[p]!
+          const r = generatePlatformFiles(declaration.getType(), language)
+          return r
+        })
+        allFiles = deduplicateFiles(allFiles)
+        // Group the files by platform ({ ios: [], android: [], shared: [] })
+        const filesPerPlatform = groupByPlatform(allFiles)
+        // Loop through each platform one by one so that it has some kind of order (per-platform)
+        for (const [p, files] of Object.entries(filesPerPlatform)) {
+          const platform = p as SourceFile['platform']
+          const language =
+            platform === 'shared' ? 'c++' : platformSpec[platform]
+          if (language == null) {
+            // if the language was never specified in the spec, skip it
+            continue
+          }
+          if (files.length === 0) {
+            // if no files exist on this platform, skip it
+            continue
+          }
+
+          Logger.info(
+            `        ${chalk.dim(platform)}: Generating ${capitalizeName(language)} code...`
+          )
+          // Write the actual files for this specific platform.
+          for (const file of files) {
+            const basePath = path.join(
+              outputDirectory,
+              file.platform,
+              file.language
+            )
+            const actualPath = await writeFile(basePath, file)
+            filesAfter.push(actualPath)
+            writtenFiles.push(file)
+          }
+        }
+
+        // Done!
+        generatedSpecs++
+      } catch (error) {
+        const message = indent(errorToString(error), '    ')
+        Logger.error(
+          chalk.redBright(
+            `        ❌  Failed to generate spec for ${typeName}! ${message}`
+          )
+        )
+        process.exitCode = 1
+      }
+    }
+
+    if (generatedSpecs === startedWithSpecs) {
+      Logger.error(
+        chalk.redBright(
+          `    ❌  No specs found in ${sourceFile.getBaseName()}!`
+        )
+      )
+    }
+  }
+
+  // Autolinking
+  Logger.info(`⛓️   Setting up build configs for autolinking...`)
+
+  const autolinkingFiles: Autolinking[] = []
+
+  if (usedPlatforms.includes('ios')) {
+    autolinkingFiles.push(createIOSAutolinking())
+  }
+  if (usedPlatforms.includes('android')) {
+    autolinkingFiles.push(createAndroidAutolinking(writtenFiles))
+  }
+
+  for (const autolinking of autolinkingFiles) {
+    Logger.info(
+      `    Creating autolinking build setup for ${chalk.dim(autolinking.platform)}...`
+    )
+    for (const file of autolinking.sourceFiles) {
+      const basePath = path.join(outputDirectory, file.platform)
+      const actualPath = await writeFile(
+        basePath,
+        file as unknown as SourceFile
+      )
+      filesAfter.push(actualPath)
+    }
+  }
+
+  try {
+    // write a .gitattributes file
+    const markAsGenerated = NitroConfig.current.getGitAttributesGeneratedFlag()
+    const file = await createGitAttributes(markAsGenerated, outputDirectory)
+    filesAfter.push(file)
+  } catch {
+    Logger.error(`❌  Failed to write ${chalk.dim(`.gitattributes`)}!`)
+  }
+
+  return {
+    generatedFiles: filesAfter,
+    targetSpecsCount: targetSpecs,
+    generatedSpecsCount: generatedSpecs,
+  }
+}

package/src/prettifyDirectory.ts

@@ -0,0 +1,32 @@
+import os from 'os'
+import path from 'path'
+
+export function prettifyDirectory(directory: string): string {
+  let relativePath = path.relative(process.cwd(), path.resolve(directory))
+  if (!relativePath.startsWith('.') && relativePath.length > 0) {
+    // Make sure all relative paths start with "./something", not just "something"
+    relativePath = `./${relativePath}`
+  }
+
+  const home = os.homedir()
+  const homeShorthand = os.platform() === 'win32' ? '$HOME' : '~'
+  const prettifiedHomeShorthand = directory.startsWith(home)
+    ? `${homeShorthand}${directory.slice(home.length)}`
+    : directory
+
+  if (relativePath.length < 1) {
+    // If relativePath is ".", we don't want to return it
+    return prettifiedHomeShorthand
+  }
+
+  if (
+    relativePath.length > 0 &&
+    relativePath.length < prettifiedHomeShorthand.length
+  ) {
+    // If relativePath is shroter than the ~/... home path, we use the relative one.
+    return relativePath
+  } else {
+    // ..otherwise just use the ~/... home relative path.
+    return prettifiedHomeShorthand
+  }
+}

package/src/syntax/BridgedType.ts

@@ -0,0 +1,59 @@
+import type { Language } from '../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from './SourceFile.js'
+import type { Type } from './types/Type.js'
+
+export interface BridgedType<
+  FromLanguage extends Language,
+  ToLanguage extends Language,
+> {
+  /**
+   * The underlying type that is being bridged between {@linkcode FromLanguage} and {@linkcode ToLanguage}
+   */
+  readonly type: Type
+  /**
+   * Whether the underlying type has a valid type (is not void or null)
+   */
+  readonly hasType: boolean
+  /**
+   * Whether this type can be passed by reference
+   */
+  readonly canBePassedByReference: boolean
+  /**
+   * Whether this bridged type needs special handling, or can just be used as-is
+   */
+  readonly needsSpecialHandling: boolean
+
+  /**
+   * Get all imports required for this bridge to work
+   */
+  getRequiredImports(language: Language): SourceImport[]
+
+  /**
+   * Get all extra files that need to be created for this type, as well as the bridge.
+   */
+  getExtraFiles(): SourceFile[]
+
+  /**
+   * Get the code for the type itself in the given language
+   */
+  getTypeCode(language: FromLanguage | ToLanguage): string
+
+  /**
+   * Parse the given parameter from the source language to the given target language, in the given language.
+   * For example, to convert an ArrayBuffer from Swift ({@linkcode from}) to C++ ({@linkcode to}) we
+   * have to wrap it in an ArrayBufferHolder in Swift ({@linkcode inLanguage}), and unwrap
+   * it from the ArrayBufferHolder again in C++ ({@linkcode inLanguage})
+   */
+  parse(
+    parameterName: string,
+    from: FromLanguage,
+    to: ToLanguage,
+    inLanguage: FromLanguage | ToLanguage
+  ): string
+  parse(
+    parameterName: string,
+    from: ToLanguage,
+    to: FromLanguage,
+    inLanguage: FromLanguage | ToLanguage
+  ): string
+}

package/src/syntax/CodeNode.ts

@@ -0,0 +1,24 @@
+import type { Language } from '../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from './SourceFile.js'
+
+export interface CodeNode {
+  /**
+   * Get the code of this code node (e.g. property, method) in the given language.
+   */
+  getCode(language: Language): string
+  /**
+   * Get all extra definition files this code node needs (e.g. extra type/struct declarations
+   * for complex types), or `[]` if none are required (e.g. if this uses primitive types only)
+   *
+   * All files returned here must be created in the project.
+   * To include them, see {@linkcode getRequiredImports | getRequiredImports()}
+   */
+  getExtraFiles(): SourceFile[]
+  /**
+   * Get all required imports this code node needs (e.g. extra type/struct declarations for complex types),
+   * or `[]` if no imports are required (e.g. if this uses primitive types only).
+   *
+   * All imports returned here must be included in the current file (e.g. `#include "..."` or `import ...`)
+   */
+  getRequiredImports(language: Language): SourceImport[]
+}

package/src/syntax/HybridObjectSpec.ts

@@ -0,0 +1,14 @@
+import type { NitroConfig } from '../config/NitroConfig.js'
+import type { Language } from '../getPlatformSpecs.js'
+import type { Method } from './Method.js'
+import type { Property } from './Property.js'
+
+export interface HybridObjectSpec {
+  name: string
+  language: Language
+  properties: Property[]
+  methods: Method[]
+  baseTypes: HybridObjectSpec[]
+  isHybridView: boolean
+  config: NitroConfig
+}

package/src/syntax/Method.ts

@@ -0,0 +1,154 @@
+import type { CodeNode } from './CodeNode.js'
+import type { Language } from '../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from './SourceFile.js'
+import { Parameter } from './Parameter.js'
+import type { Type } from './types/Type.js'
+import { indent } from '../utils.js'
+
+export type MethodBody = string
+
+export interface MethodModifiers {
+  /**
+   * The name of the class that defines this C++ method.
+   * Example: `Person` -> `void Person::sayHi()`
+   */
+  classDefinitionName?: string
+  /**
+   * Whether the function should be marked as inlineable.
+   */
+  inline?: boolean
+  /*+
+   * Whether the func is a pure virtual C++ function.
+   */
+  virtual?: boolean
+  /**
+   * Whether the function is marked as `noexcept` (doesn't throw) or not.
+   */
+  noexcept?: boolean
+  /**
+   * Whether this function overrides a base/super function.
+   */
+  override?: boolean
+  /**
+   * Whether this method has a `@DoNotStrip` and `@Keep` attribute to avoid
+   * it from being stripped from the binary by the Java compiler or ProGuard.
+   */
+  doNotStrip?: boolean
+}
+
+export class Method implements CodeNode {
+  readonly name: string
+  readonly returnType: Type
+  readonly parameters: Parameter[]
+
+  constructor(name: string, returnType: Type, parameters: Parameter[]) {
+    this.name = name
+    this.returnType = returnType
+    this.parameters = parameters
+    if (this.name.startsWith('__')) {
+      throw new Error(
+        `Method names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`
+      )
+    }
+  }
+
+  get jsSignature(): string {
+    const returnType = this.returnType.kind
+    const params = this.parameters.map((p) => `${p.name}: ${p.type.kind}`)
+    return `${this.name}(${params.join(', ')}): ${returnType}`
+  }
+
+  getCode(
+    language: Language,
+    modifiers?: MethodModifiers,
+    body?: MethodBody
+  ): string {
+    body = body?.trim()
+
+    switch (language) {
+      case 'c++': {
+        const returnType = this.returnType.getCode('c++')
+        const params = this.parameters.map((p) => p.getCode('c++'))
+
+        // C++ modifiers start in the beginning
+        const name = modifiers?.classDefinitionName
+          ? `${modifiers.classDefinitionName}::${this.name}`
+          : this.name
+        let signature = `${returnType} ${name}(${params.join(', ')})`
+        if (modifiers?.inline) signature = `inline ${signature}`
+        if (modifiers?.virtual) signature = `virtual ${signature}`
+        if (modifiers?.noexcept) signature = `${signature} noexcept`
+        if (modifiers?.override) signature = `${signature} override`
+
+        if (body == null) {
+          // It's a function declaration (no body)
+          if (modifiers?.virtual) {
+            // if it is a virtual function, we have no implementation (= 0)
+            signature = `${signature} = 0`
+          }
+          return `${signature};`
+        } else {
+          return `
+${signature} {
+  ${indent(body, '  ')}
+}`.trim()
+        }
+      }
+      case 'swift': {
+        const params = this.parameters.map((p) => p.getCode('swift'))
+        const returnType = this.returnType.getCode('swift')
+        let signature = `func ${this.name}(${params.join(', ')}) throws -> ${returnType}`
+
+        if (modifiers?.inline) signature = `@inline(__always)\n${signature}`
+
+        if (body == null) {
+          return signature
+        } else {
+          return `
+${signature} {
+  ${indent(body, '  ')}
+}`.trim()
+        }
+      }
+      case 'kotlin': {
+        const params = this.parameters.map((p) => p.getCode('kotlin'))
+        const returnType = this.returnType.getCode('kotlin')
+        let signature = `fun ${this.name}(${params.join(', ')}): ${returnType}`
+
+        if (modifiers?.inline) signature = `inline ${signature}`
+        if (modifiers?.override) signature = `override ${signature}`
+        if (modifiers?.virtual) signature = `abstract ${signature}`
+        if (modifiers?.doNotStrip)
+          signature = `@DoNotStrip\n@Keep\n${signature}`
+
+        if (body == null) {
+          return signature
+        } else {
+          return `
+${signature} {
+  ${indent(body, '  ')}
+}
+          `.trim()
+        }
+      }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for property getters!`
+        )
+    }
+  }
+
+  getExtraFiles(): SourceFile[] {
+    const returnTypeExtraFiles = this.returnType.getExtraFiles()
+    const paramsExtraFiles = this.parameters.flatMap((p) => p.getExtraFiles())
+    return [...returnTypeExtraFiles, ...paramsExtraFiles]
+  }
+
+  getRequiredImports(language: Language): SourceImport[] {
+    const returnTypeFiles = this.returnType.getRequiredImports(language)
+    const paramsImports = this.parameters.flatMap((p) =>
+      p.getRequiredImports(language)
+    )
+    return [...returnTypeFiles, ...paramsImports]
+  }
+}

package/src/syntax/Parameter.ts

@@ -0,0 +1,81 @@
+import type { ParameterDeclaration } from 'ts-morph'
+import type { CodeNode } from './CodeNode.js'
+import { escapeCppName, toReferenceType } from './helpers.js'
+import type { Language } from '../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from './SourceFile.js'
+import type { NamedType, Type } from './types/Type.js'
+import { NamedWrappingType } from './types/NamedWrappingType.js'
+import { createNamedType } from './createType.js'
+
+export class Parameter implements CodeNode {
+  readonly type: NamedType
+
+  constructor(name: string, type: Type)
+  constructor(parameter: ParameterDeclaration, language: Language)
+  constructor(...args: [string, Type] | [ParameterDeclaration, Language]) {
+    if (typeof args[0] === 'string' && typeof args[1] === 'object') {
+      // constructor(...) #1
+      if (args.length !== 2)
+        throw new Error(`Missing arguments for new Parameter(...) overload #1!`)
+      const [name, type] = args
+      this.type = new NamedWrappingType(name, type)
+    } else if (typeof args[0] === 'object' && typeof args[1] === 'string') {
+      // constructor(...) #2
+      const [param, language] = args
+      const name = param.getSymbolOrThrow().getEscapedName()
+      const type = param.getType()
+      const isOptional =
+        param.hasQuestionToken() || param.isOptional() || type.isNullable()
+      this.type = createNamedType(language, name, type, isOptional)
+    } else {
+      // constructor(...)???
+      throw new Error(`Invalid constructor! Arguments: ${args}`)
+    }
+    if (this.type.name.startsWith('__')) {
+      throw new Error(
+        `Parameter names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`
+      )
+    }
+  }
+
+  get jsSignature(): string {
+    return `${this.type.name}: ${this.type.kind}`
+  }
+
+  get name(): string {
+    return this.type.name
+  }
+
+  getCode(language: Language): string {
+    const name = escapeCppName(this.name)
+    switch (language) {
+      case 'c++':
+        let cppType = this.type.getCode('c++')
+        if (this.type.canBePassedByReference) {
+          // T -> const T&
+          cppType = toReferenceType(cppType)
+        }
+        return `${cppType} ${name}`
+      case 'swift':
+        let flags = ''
+        if (this.type.kind === 'function') {
+          flags = '@escaping '
+        }
+        return `${name}: ${flags + this.type.getCode('swift')}`
+      case 'kotlin':
+        return `${name}: ${this.type.getCode('kotlin')}`
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for parameters!`
+        )
+    }
+  }
+
+  getExtraFiles(): SourceFile[] {
+    return this.type.getExtraFiles()
+  }
+
+  getRequiredImports(language: Language): SourceImport[] {
+    return this.type.getRequiredImports(language)
+  }
+}