nitrogen 0.2.24 → 0.29.5

package/src/syntax/swift/SwiftVariant.ts

@@ -0,0 +1,67 @@
+import { indent } from '../../utils.js'
+import { createFileMetadataString } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import { getTypeAs } from '../types/getTypeAs.js'
+import { OptionalType } from '../types/OptionalType.js'
+import type { Type } from '../types/Type.js'
+import type { VariantType } from '../types/VariantType.js'
+
+function isPrimitive(type: Type): boolean {
+  switch (type.kind) {
+    case 'bigint':
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'void':
+    case 'result-wrapper':
+    case 'null':
+    case 'error':
+      return true
+    case 'optional':
+      const optional = getTypeAs(type, OptionalType)
+      return isPrimitive(optional.wrappingType)
+    default:
+      return false
+  }
+}
+
+export function createSwiftVariant(variant: VariantType): SourceFile {
+  const typename = variant.getAliasName('swift')
+  const cases = variant.cases
+    .map(([label, v]) => {
+      const type = v.getCode('swift')
+      return `case ${label}(${type})`
+    })
+    .join('\n')
+  const jsSignature = variant.variants.map((t) => t.kind).join(' | ')
+
+  const allPrimitives = variant.variants.every((v) => isPrimitive(v))
+  const enumDeclaration = allPrimitives ? 'enum' : 'indirect enum'
+
+  const extraImports = variant.variants
+    .flatMap((t) => t.getRequiredImports('swift'))
+    .map((i) => `import ${i.name}`)
+
+  const code = `
+${createFileMetadataString(`${typename}.swift`)}
+
+${extraImports.join('\n')}
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: \`${jsSignature}\`
+ */
+@frozen
+public ${enumDeclaration} ${typename} {
+  ${indent(cases, '  ')}
+}
+  `.trim()
+
+  return {
+    content: code,
+    language: 'swift',
+    name: `${typename}.swift`,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/syntax/types/ArrayBufferType.ts

@@ -0,0 +1,49 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class ArrayBufferType implements Type {
+  get canBePassedByReference(): boolean {
+    // It's a shared_ptr.
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'array-buffer'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'std::shared_ptr<ArrayBuffer>'
+      case 'swift':
+        return 'ArrayBuffer'
+      case 'kotlin':
+        return 'ArrayBuffer'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for ArrayBufferType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push({
+        name: 'NitroModules/ArrayBuffer.hpp',
+        forwardDeclaration: getForwardDeclaration(
+          'class',
+          'ArrayBuffer',
+          'NitroModules'
+        ),
+        language: 'c++',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/ArrayType.ts

@@ -0,0 +1,62 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+export class ArrayType implements Type {
+  readonly itemType: Type
+
+  constructor(itemType: Type) {
+    this.itemType = itemType
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a vector<..>, heavy to copy
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'array'
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const itemCode = this.itemType.getCode(language, options)
+
+    switch (language) {
+      case 'c++':
+        return `std::vector<${itemCode}>`
+      case 'swift':
+        return `[${itemCode}]`
+      case 'kotlin':
+        switch (this.itemType.kind) {
+          case 'number':
+            return 'DoubleArray'
+          case 'boolean':
+            return 'BooleanArray'
+          case 'bigint':
+            return 'LongArray'
+          default:
+            return `Array<${itemCode}>`
+        }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for ArrayType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return this.itemType.getExtraFiles()
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = [
+      ...this.itemType.getRequiredImports(language),
+    ]
+    if (language === 'c++') {
+      imports.push({
+        name: 'vector',
+        language: 'c++',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/BigIntType.ts

@@ -0,0 +1,35 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class BigIntType implements Type {
+  get canBePassedByReference(): boolean {
+    // It's a primitive.
+    return false
+  }
+
+  get kind(): TypeKind {
+    return 'bigint'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'int64_t'
+      case 'swift':
+        return 'Int64'
+      case 'kotlin':
+        return 'Long'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for BigIntType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(): SourceImport[] {
+    return []
+  }
+}

package/src/syntax/types/BooleanType.ts

@@ -0,0 +1,35 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class BooleanType implements Type {
+  get canBePassedByReference(): boolean {
+    // It's a primitive.
+    return false
+  }
+
+  get kind(): TypeKind {
+    return 'boolean'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'bool'
+      case 'swift':
+        return 'Bool'
+      case 'kotlin':
+        return 'Boolean'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for BooleanType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(): SourceImport[] {
+    return []
+  }
+}

package/src/syntax/types/CustomType.ts

@@ -0,0 +1,47 @@
+import type { CustomTypeConfig } from 'react-native-nitro-modules'
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class CustomType implements Type {
+  typeConfig: CustomTypeConfig
+  typeName: string
+
+  constructor(typeName: string, typeConfig: CustomTypeConfig) {
+    this.typeName = typeName
+    this.typeConfig = typeConfig
+  }
+
+  get canBePassedByReference() {
+    return this.typeConfig.canBePassedByReference ?? false
+  }
+
+  get kind(): TypeKind {
+    return 'custom-type'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return this.typeName
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for CustomType "${this.typeName}"!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push({
+        name: this.typeConfig.include,
+        language: 'c++',
+        space: 'user',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/DateType.ts

@@ -0,0 +1,43 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class DateType implements Type {
+  get canBePassedByReference(): boolean {
+    // simple chrono value type
+    return false
+  }
+
+  get kind(): TypeKind {
+    return 'date'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'std::chrono::system_clock::time_point'
+      case 'swift':
+        return 'Date'
+      case 'kotlin':
+        return 'java.time.Instant'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for DateType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push({
+        name: 'chrono',
+        language: 'c++',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/EnumType.ts

@@ -0,0 +1,130 @@
+import { EnumDeclaration } from 'ts-morph'
+import { Type as TSMorphType, type ts } from 'ts-morph'
+import type { Language } from '../../getPlatformSpecs.js'
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+import { createCppEnum } from '../c++/CppEnum.js'
+import { escapeCppName } from '../helpers.js'
+import { createCppUnion } from '../c++/CppUnion.js'
+import { NitroConfig } from '../../config/NitroConfig.js'
+
+export interface EnumMember {
+  name: string
+  value: number
+  stringValue: string
+}
+
+export class EnumType implements Type {
+  readonly enumName: string
+  readonly enumMembers: EnumMember[]
+  readonly jsType: 'enum' | 'union'
+  readonly declarationFile: SourceFile
+
+  constructor(enumName: string, enumDeclaration: EnumDeclaration)
+  constructor(enumName: string, union: TSMorphType<ts.UnionType>)
+  constructor(
+    enumName: string,
+    declaration: EnumDeclaration | TSMorphType<ts.UnionType>
+  ) {
+    this.enumName = enumName
+    if (declaration instanceof EnumDeclaration) {
+      // It's a JS enum { ... }
+      this.jsType = 'enum'
+      this.enumMembers = declaration.getMembers().map<EnumMember>((m) => {
+        const name = m.getSymbolOrThrow().getEscapedName()
+        const value = m.getValue()
+        if (typeof value !== 'number') {
+          throw new Error(
+            `Enum member ${enumName}.${name} is ${value} (${typeof value}), which cannot be represented in C++ enums.\n` +
+              `Each enum member must be a number! If you want to use strings, use TypeScript unions ("a" | "b") instead!`
+          )
+        }
+        return {
+          name: escapeCppName(name).toUpperCase(),
+          value: value,
+          stringValue: name,
+        }
+      })
+      this.declarationFile = createCppEnum(enumName, this.enumMembers)
+    } else {
+      // It's a TS union '..' | '..'
+      this.jsType = 'union'
+      this.enumMembers = declaration
+        .getNonNullableType()
+        .getUnionTypes()
+        .map((t, i) => {
+          if (t.isStringLiteral()) {
+            const literalValue = t.getLiteralValueOrThrow()
+            if (typeof literalValue !== 'string')
+              throw new Error(
+                `${enumName}: Value "${literalValue}" is not a string - it is ${typeof literalValue}!`
+              )
+            return {
+              name: escapeCppName(literalValue).toUpperCase(),
+              value: i,
+              stringValue: literalValue,
+            }
+          } else {
+            throw new Error(
+              `${enumName}: Value "${t.getText()}" is not a string literal - it cannot be represented in a C++ enum!`
+            )
+          }
+        })
+      this.declarationFile = createCppUnion(enumName, this.enumMembers)
+    }
+    if (this.enumName.startsWith('__')) {
+      throw new Error(
+        `Enum name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${this.enumName}: ${this.enumMembers.map((m) => m.name).join(' | ')})`
+      )
+    }
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a primitive.
+    return false
+  }
+
+  get kind(): TypeKind {
+    return 'enum'
+  }
+
+  getCode(language: Language, { fullyQualified }: GetCodeOptions = {}): string {
+    switch (language) {
+      case 'c++':
+        if (fullyQualified) {
+          return NitroConfig.current.getCxxNamespace('c++', this.enumName)
+        } else {
+          return this.enumName
+        }
+      case 'swift':
+        return this.enumName
+      case 'kotlin':
+        return this.enumName
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for NumberType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return [this.declarationFile]
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+      imports.push({
+        name: this.declarationFile.name,
+        language: this.declarationFile.language,
+        forwardDeclaration: getForwardDeclaration(
+          'enum class',
+          this.enumName,
+          cxxNamespace
+        ),
+        space: 'user',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/ErrorType.ts

@@ -0,0 +1,44 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class ErrorType implements Type {
+  constructor() {}
+
+  get canBePassedByReference(): boolean {
+    // It's a exception<..>, pass by reference.
+    return true
+  }
+  get kind(): TypeKind {
+    return 'error'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return `std::exception_ptr`
+      case 'swift':
+        return `Error`
+      case 'kotlin':
+        return `Throwable`
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for ThrowableType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'exception',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/FunctionType.ts

@@ -0,0 +1,167 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { escapeCppName, toReferenceType } from '../helpers.js'
+import { Parameter } from '../Parameter.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import { PromiseType } from './PromiseType.js'
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js'
+
+export interface GetFunctionCodeOptions extends GetCodeOptions {
+  includeNameInfo?: boolean
+}
+
+export class FunctionType implements Type {
+  readonly returnType: Type
+  readonly parameters: NamedType[]
+
+  constructor(returnType: Type, parameters: NamedType[], isSync = false) {
+    if (returnType.kind === 'void' || isSync) {
+      // void callbacks are async, but we don't care about the result.
+      this.returnType = returnType
+    } else {
+      // non-void callbacks are async and need to be awaited to get the result from JS.
+      this.returnType = new PromiseType(returnType)
+    }
+    this.parameters = parameters
+
+    if (isSync && returnType.kind === 'void') {
+      throw new Error(
+        `Function \`${this.jsName}\` cannot be sync (\`Sync<...>\`) AND return \`void\`, as this is ambiguous. ` +
+          `Either return a value (even if it's just a \`boolean\`) to keep it sync, or make it async.`
+      )
+    }
+  }
+
+  get specializationName(): string {
+    return (
+      'Func_' +
+      [this.returnType, ...this.parameters]
+        .map((p) => escapeCppName(p.getCode('c++')))
+        .join('_')
+    )
+  }
+
+  get jsName(): string {
+    const paramsJs = this.parameters
+      .map((p) => `${p.name}: ${p.kind}`)
+      .join(', ')
+    const returnType = this.returnType.getCode('c++')
+    return `(${paramsJs}) => ${returnType}`
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a function<..>, heavy to copy.
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'function'
+  }
+
+  /**
+   * For a function, get the forward recreation of it:
+   * If variable is called `func`, this would return:
+   * ```cpp
+   * [func = std::move(func)](Params... params) -> ReturnType {
+   *   return func(params...);
+   * }
+   * ```
+   */
+  getForwardRecreationCode(variableName: string, language: Language): string {
+    const returnType = this.returnType.getCode(language)
+    const parameters = this.parameters
+      .map((p) => new Parameter(p.name, p))
+      .map((p) => p.getCode('c++'))
+    const forwardedParameters = this.parameters.map(
+      (p) => `std::forward<decltype(${p.name})>(${p.name})`
+    )
+
+    switch (language) {
+      case 'c++':
+        const closure = `[${variableName} = std::move(${variableName})]`
+        const signature = `(${parameters.join(', ')}) -> ${returnType}`
+        const body = `{ return ${variableName}(${forwardedParameters.join(', ')}); }`
+        return `${closure} ${signature} ${body}`
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for function forward recreations!`
+        )
+    }
+  }
+
+  getCppFunctionPointerType(name: string, includeNameInfo = true): string {
+    const params = this.parameters
+      .map((p) => {
+        const type = p.getCode('c++')
+        const code = p.canBePassedByReference ? toReferenceType(type) : type
+        if (includeNameInfo) return `${code} /* ${p.name} */`
+        else return code
+      })
+      .join(', ')
+    const returnType = this.returnType.getCode('c++')
+    return `${returnType}(*${name})(${params})`
+  }
+
+  getCode(language: Language, options: GetFunctionCodeOptions = {}): string {
+    const includeNameInfo = options.includeNameInfo ?? true
+    switch (language) {
+      case 'c++': {
+        const params = this.parameters
+          .map((p) => {
+            const type = p.getCode('c++', options)
+            const code = p.canBePassedByReference ? toReferenceType(type) : type
+            if (includeNameInfo) return `${code} /* ${p.name} */`
+            else return code
+          })
+          .join(', ')
+        const returnType = this.returnType.getCode(language, options)
+        return `std::function<${returnType}(${params})>`
+      }
+      case 'swift': {
+        const params = this.parameters
+          .map((p) => {
+            if (includeNameInfo)
+              return `_ ${p.escapedName}: ${p.getCode(language, options)}`
+            else return p.getCode(language, options)
+          })
+          .join(', ')
+        const returnType = this.returnType.getCode(language, options)
+        return `(${params}) -> ${returnType}`
+      }
+      case 'kotlin': {
+        const params = this.parameters
+          .map((p) => {
+            if (includeNameInfo)
+              return `${p.escapedName}: ${p.getCode(language, options)}`
+            else return p.getCode(language, options)
+          })
+          .join(', ')
+        const returnType = this.returnType.getCode(language, options)
+        return `(${params}) -> ${returnType}`
+      }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for FunctionType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return [
+      ...this.returnType.getExtraFiles(),
+      ...this.parameters.flatMap((p) => p.getExtraFiles()),
+    ]
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = [
+      ...this.returnType.getRequiredImports(language),
+      ...this.parameters.flatMap((p) => p.getRequiredImports(language)),
+    ]
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'functional',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}