nitrogen 0.2.24 → 0.29.5

package/src/syntax/types/HybridObjectBaseType.ts

@@ -0,0 +1,54 @@
+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 HybridObjectBaseType implements Type {
+  constructor() {}
+
+  get canBePassedByReference(): boolean {
+    // It's a shared_ptr<..>, no copy.
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'hybrid-object-base'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return `std::shared_ptr<HybridObject>`
+      default:
+        throw new Error(
+          `The base type \`HybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push(
+        {
+          language: 'c++',
+          name: 'memory',
+          space: 'system',
+        },
+        {
+          name: `NitroModules/HybridObject.hpp`,
+          forwardDeclaration: getForwardDeclaration(
+            'class',
+            'HybridObject',
+            'margelo::nitro'
+          ),
+          language: 'c++',
+          space: 'system',
+        }
+      )
+    }
+    return imports
+  }
+}

package/src/syntax/types/HybridObjectType.ts

@@ -0,0 +1,198 @@
+import { type NitroConfig } from '../../config/NitroConfig.js'
+import type { Language } from '../../getPlatformSpecs.js'
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
+import { getHybridObjectName } from '../getHybridObjectName.js'
+import type { HybridObjectSpec } from '../HybridObjectSpec.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+interface GetHybridObjectCodeOptions extends GetCodeOptions {
+  mode?: 'strong' | 'weak'
+}
+
+export class HybridObjectType implements Type {
+  readonly hybridObjectName: string
+  readonly implementationLanguage: Language
+  readonly baseTypes: HybridObjectType[]
+  readonly sourceConfig: NitroConfig
+
+  constructor(
+    hybridObjectName: string,
+    implementationLanguage: Language,
+    baseTypes: HybridObjectType[],
+    sourceConfig: NitroConfig
+  )
+  constructor(spec: HybridObjectSpec)
+  constructor(
+    ...args:
+      | [
+          hybridObjectName: string,
+          implementationLanguage: Language,
+          baseTypes: HybridObjectType[],
+          sourceConfig: NitroConfig,
+        ]
+      | [HybridObjectSpec]
+  ) {
+    if (args.length === 1) {
+      const [spec] = args
+
+      this.hybridObjectName = spec.name
+      this.implementationLanguage = spec.language
+      this.sourceConfig = spec.config
+      this.baseTypes = spec.baseTypes.map((b) => new HybridObjectType(b))
+    } else {
+      const [
+        hybridObjectName,
+        implementationLanguage,
+        baseTypes,
+        sourceConfig,
+      ] = args
+
+      this.hybridObjectName = hybridObjectName
+      this.implementationLanguage = implementationLanguage
+      this.baseTypes = baseTypes
+      this.sourceConfig = sourceConfig
+    }
+
+    if (this.hybridObjectName.startsWith('__')) {
+      throw new Error(
+        `HybridObject name cannot start with two underscores (__)! (In ${this.hybridObjectName})`
+      )
+    }
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a shared_ptr<..>, no copy.
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'hybrid-object'
+  }
+
+  getCode(
+    language: Language,
+    options: GetHybridObjectCodeOptions = {}
+  ): string {
+    const name = getHybridObjectName(this.hybridObjectName)
+    const mode = options.mode ?? 'strong'
+    const fullyQualified =
+      options.fullyQualified ?? this.sourceConfig.isExternalConfig
+
+    switch (language) {
+      case 'c++': {
+        const ptrType = mode === 'strong' ? 'std::shared_ptr' : 'std::weak_ptr'
+        if (fullyQualified) {
+          const fullName = this.sourceConfig.getCxxNamespace(
+            'c++',
+            name.HybridTSpec
+          )
+          return `${ptrType}<${fullName}>`
+        } else {
+          return `${ptrType}<${name.HybridTSpec}>`
+        }
+      }
+      case 'swift': {
+        return `(any ${name.HybridTSpec})`
+      }
+      case 'kotlin': {
+        if (fullyQualified) {
+          // full qualified name: "com.margelo.nitro.image.Image"
+          return this.sourceConfig.getAndroidPackage(
+            'java/kotlin',
+            name.HybridTSpec
+          )
+        } else {
+          // "Image"
+          return name.HybridTSpec
+        }
+      }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for HybridObjectType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+
+  private getExternalCxxImportName(): string {
+    // TODO: We currently don't have a xplat way of handling import paths, therefore iosModuleName and androidCxxLibName need to have the same value.
+    if (
+      this.sourceConfig.getIosModuleName() !==
+      this.sourceConfig.getAndroidCxxLibName()
+    ) {
+      throw new Error(
+        `Cannot import external HybridObject "${this.hybridObjectName}" if it's nitro.json's iosModuleName and androidCxxLibName are not the same value!`
+      )
+    }
+    return this.sourceConfig.getIosModuleName()
+  }
+
+  getRequiredImports(language: Language): SourceImport[] {
+    const name = getHybridObjectName(this.hybridObjectName)
+    const cxxNamespace = this.sourceConfig.getCxxNamespace('c++')
+    const imports: SourceImport[] = []
+
+    switch (language) {
+      case 'c++': {
+        imports.push({
+          language: 'c++',
+          name: 'memory',
+          space: 'system',
+        })
+        if (this.sourceConfig.isExternalConfig) {
+          const cxxImport = this.getExternalCxxImportName()
+          imports.push({
+            name: `${cxxImport}/${name.HybridTSpec}.hpp`,
+            forwardDeclaration: getForwardDeclaration(
+              'class',
+              name.HybridTSpec,
+              cxxNamespace
+            ),
+            language: 'c++',
+            space: 'system',
+          })
+        } else {
+          imports.push({
+            name: `${name.HybridTSpec}.hpp`,
+            forwardDeclaration: getForwardDeclaration(
+              'class',
+              name.HybridTSpec,
+              cxxNamespace
+            ),
+            language: 'c++',
+            space: 'user',
+          })
+        }
+        break
+      }
+      case 'kotlin': {
+        if (this.sourceConfig.isExternalConfig) {
+          imports.push({
+            language: 'kotlin',
+            name: this.sourceConfig.getAndroidPackage(
+              'java/kotlin',
+              name.HybridTSpec
+            ),
+            space: 'system',
+          })
+        }
+        break
+      }
+      case 'swift': {
+        if (this.sourceConfig.isExternalConfig) {
+          imports.push({
+            language: 'swift',
+            name: this.sourceConfig.getIosModuleName(),
+            space: 'system',
+          })
+        }
+        break
+      }
+    }
+
+    return imports
+  }
+}

package/src/syntax/types/MapType.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 MapType implements Type {
+  get canBePassedByReference(): boolean {
+    // It's a shared_ptr<..>, no ref.
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'map'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'std::shared_ptr<AnyMap>'
+      case 'swift':
+        return 'AnyMap'
+      case 'kotlin':
+        return 'AnyMap'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for MapType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      imports.push({
+        name: 'NitroModules/AnyMap.hpp',
+        forwardDeclaration: getForwardDeclaration(
+          'class',
+          'AnyMap',
+          'NitroModules'
+        ),
+        language: 'c++',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/NamedWrappingType.ts

@@ -0,0 +1,33 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { escapeCppName } from '../helpers.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js'
+
+export class NamedWrappingType<T extends Type> implements NamedType {
+  readonly type: T
+  readonly name: string
+
+  constructor(name: string, type: T) {
+    this.name = name
+    this.type = type
+  }
+
+  get escapedName(): string {
+    return escapeCppName(this.name)
+  }
+  get kind(): TypeKind {
+    return this.type.kind
+  }
+  get canBePassedByReference(): boolean {
+    return this.type.canBePassedByReference
+  }
+  getCode(language: Language, options?: GetCodeOptions): string {
+    return this.type.getCode(language, options)
+  }
+  getExtraFiles(): SourceFile[] {
+    return this.type.getExtraFiles()
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    return this.type.getRequiredImports(language)
+  }
+}

package/src/syntax/types/NullType.ts

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

package/src/syntax/types/NumberType.ts

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

package/src/syntax/types/OptionalType.ts

@@ -0,0 +1,66 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+export class OptionalType implements Type {
+  readonly wrappingType: Type
+
+  constructor(wrappingType: Type) {
+    this.wrappingType = wrappingType
+  }
+
+  get canBePassedByReference(): boolean {
+    // depends whether the wrapping type is heavy to copy or not.
+    return this.wrappingType.canBePassedByReference
+  }
+  get kind(): TypeKind {
+    return 'optional'
+  }
+  get needsBraces(): boolean {
+    switch (this.wrappingType.kind) {
+      case 'function':
+        return true
+      default:
+        return false
+    }
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const wrapping = this.wrappingType.getCode(language, options)
+    switch (language) {
+      case 'c++':
+        return `std::optional<${wrapping}>`
+      case 'swift':
+        if (this.needsBraces) {
+          return `(${wrapping})?`
+        } else {
+          return `${wrapping}?`
+        }
+      case 'kotlin':
+        if (this.needsBraces) {
+          return `(${wrapping})?`
+        } else {
+          return `${wrapping}?`
+        }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for OptionalType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return this.wrappingType.getExtraFiles()
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] =
+      this.wrappingType.getRequiredImports(language)
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'optional',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/PromiseType.ts

@@ -0,0 +1,72 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import { ErrorType } from './ErrorType.js'
+import { FunctionType } from './FunctionType.js'
+import { NamedWrappingType } from './NamedWrappingType.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+import { VoidType } from './VoidType.js'
+
+export class PromiseType implements Type {
+  readonly resultingType: Type
+  readonly errorType: Type
+
+  constructor(resultingType: Type) {
+    this.resultingType = resultingType
+    this.errorType = new ErrorType()
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a future<..>, it cannot be copied.
+    return true
+  }
+  get kind(): TypeKind {
+    return 'promise'
+  }
+
+  get resolverFunction(): FunctionType {
+    if (this.resultingType.kind === 'void') {
+      return new FunctionType(new VoidType(), [])
+    } else {
+      return new FunctionType(new VoidType(), [
+        new NamedWrappingType('value', this.resultingType),
+      ])
+    }
+  }
+
+  get rejecterFunction(): FunctionType {
+    return new FunctionType(new VoidType(), [
+      new NamedWrappingType('error', this.errorType),
+    ])
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const resultingCode = this.resultingType.getCode(language, options)
+    switch (language) {
+      case 'c++':
+        return `std::shared_ptr<Promise<${resultingCode}>>`
+      case 'swift':
+        return `Promise<${resultingCode}>`
+      case 'kotlin':
+        return `Promise<${resultingCode}>`
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for PromiseType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return this.resultingType.getExtraFiles()
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] =
+      this.resultingType.getRequiredImports(language)
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'NitroModules/Promise.hpp',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/RecordType.ts

@@ -0,0 +1,56 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+export class RecordType implements Type {
+  readonly keyType: Type
+  readonly valueType: Type
+
+  constructor(keyType: Type, valueType: Type) {
+    this.keyType = keyType
+    this.valueType = valueType
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a unordered_map<..>, heavy to copy.
+    return true
+  }
+  get kind(): TypeKind {
+    return 'record'
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const keyCode = this.keyType.getCode(language, options)
+    const valueCode = this.valueType.getCode(language, options)
+
+    switch (language) {
+      case 'c++':
+        return `std::unordered_map<${keyCode}, ${valueCode}>`
+      case 'swift':
+        return `Dictionary<${keyCode}, ${valueCode}>`
+      case 'kotlin':
+        return `Map<${keyCode}, ${valueCode}>`
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for RecordType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return [...this.keyType.getExtraFiles(), ...this.valueType.getExtraFiles()]
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = [
+      ...this.keyType.getRequiredImports(language),
+      ...this.valueType.getRequiredImports(language),
+    ]
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'unordered_map',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/ResultWrappingType.ts

@@ -0,0 +1,53 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import { ErrorType } from './ErrorType.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+export class ResultWrappingType implements Type {
+  readonly result: Type
+  readonly error: Type
+
+  constructor(result: Type) {
+    this.result = result
+    this.error = new ErrorType()
+  }
+
+  get canBePassedByReference(): boolean {
+    return this.result.canBePassedByReference
+  }
+
+  get kind(): TypeKind {
+    return 'result-wrapper'
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const type = this.result.getCode(language, options)
+    switch (language) {
+      case 'c++':
+        return `Result<${type}>`
+      case 'swift':
+        return type
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for VariantType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return [...this.result.getExtraFiles(), ...this.error.getExtraFiles()]
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = [
+      ...this.result.getRequiredImports(language),
+      ...this.error.getRequiredImports(language),
+    ]
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'NitroModules/Result.hpp',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/StringType.ts

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