nitrogen 0.2.24 → 0.29.4

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)
+  }
+}

package/src/syntax/Property.ts

@@ -0,0 +1,203 @@
+import type { CodeNode } from './CodeNode.js'
+import { capitalizeName } from '../utils.js'
+import { type SourceFile, type SourceImport } from './SourceFile.js'
+import type { Language } from '../getPlatformSpecs.js'
+import type { Type } from './types/Type.js'
+import { Method } from './Method.js'
+import { VoidType } from './types/VoidType.js'
+import { Parameter } from './Parameter.js'
+import { isBooleanPropertyPrefix } from './helpers.js'
+
+export interface PropertyBody {
+  getter: string
+  setter: string
+}
+
+export type LanguageEnvironment = 'jvm' | 'swift' | 'other'
+
+export interface PropertyModifiers {
+  /**
+   * The name of the class that defines this C++ property getter/setter method.
+   * Example: `Person` -> `int Person::getAge()`
+   */
+  classDefinitionName?: string
+  /**
+   * Whether the property should be marked as inlineable.
+   */
+  inline?: boolean
+  /*+
+   * Whether the property is a pure virtual C++ property (getter + setter).
+   */
+  virtual?: boolean
+  /**
+   * Whether the property is marked as `noexcept` (doesn't throw) or not.
+   */
+  noexcept?: boolean
+  /**
+   * Whether this property overrides a base/super property.
+   */
+  override?: boolean
+  /**
+   * Whether this property 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 Property implements CodeNode {
+  readonly name: string
+  readonly type: Type
+  readonly isReadonly: boolean
+
+  constructor(name: string, type: Type, isReadonly: boolean) {
+    this.name = name
+    this.type = type
+    this.isReadonly = isReadonly
+    if (this.name.startsWith('__')) {
+      throw new Error(
+        `Property names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`
+      )
+    }
+  }
+
+  get jsSignature(): string {
+    return `${this.name}: ${this.type.kind}`
+  }
+
+  getExtraFiles(): SourceFile[] {
+    return this.type.getExtraFiles()
+  }
+
+  getRequiredImports(language: Language): SourceImport[] {
+    return this.type.getRequiredImports(language)
+  }
+
+  getGetterName(environment: LanguageEnvironment): string {
+    if (this.type.kind === 'boolean' && isBooleanPropertyPrefix(this.name)) {
+      // Boolean accessors where the property starts with "is" or "has" are renamed in JVM and Swift
+      switch (environment) {
+        case 'jvm':
+        case 'swift':
+          // isSomething -> isSomething()
+          return this.name
+        default:
+          break
+      }
+    }
+    // isSomething -> getIsSomething()
+    return `get${capitalizeName(this.name)}`
+  }
+
+  getSetterName(environment: LanguageEnvironment): string {
+    if (this.type.kind === 'boolean' && this.name.startsWith('is')) {
+      // Boolean accessors where the property starts with "is" are renamed in JVM
+      if (environment === 'jvm') {
+        // isSomething -> setSomething()
+        const cleanName = this.name.replace('is', '')
+        return `set${capitalizeName(cleanName)}`
+      }
+    }
+    // isSomething -> setIsSomething()
+    return `set${capitalizeName(this.name)}`
+  }
+
+  get cppGetter(): Method {
+    return new Method(this.getGetterName('other'), this.type, [])
+  }
+
+  get cppSetter(): Method | undefined {
+    if (this.isReadonly) return undefined
+    const parameter = new Parameter(this.name, this.type)
+    return new Method(this.getSetterName('other'), new VoidType(), [parameter])
+  }
+
+  getCppMethods(): [getter: Method] | [getter: Method, setter: Method] {
+    if (this.cppSetter != null) {
+      // get + set
+      return [this.cppGetter, this.cppSetter]
+    } else {
+      // get
+      return [this.cppGetter]
+    }
+  }
+
+  getCode(
+    language: Language,
+    modifiers?: PropertyModifiers,
+    body?: PropertyBody
+  ): string {
+    if (body != null) {
+      body.getter = body.getter.trim()
+      body.setter = body.setter.trim()
+    }
+
+    switch (language) {
+      case 'c++': {
+        const methods = this.getCppMethods()
+        const [getter, setter] = methods
+        const lines: string[] = []
+        lines.push(getter.getCode('c++', modifiers, body?.getter))
+        if (setter != null) {
+          lines.push(setter.getCode('c++', modifiers, body?.setter))
+        }
+
+        return lines.join('\n')
+      }
+      case 'swift': {
+        const type = this.type.getCode('swift')
+        let accessors: string
+        if (body == null) {
+          accessors = this.isReadonly ? `get` : `get set`
+        } else {
+          const lines: string[] = []
+          lines.push(`
+get {
+  ${body.getter}
+}
+          `)
+          if (!this.isReadonly) {
+            lines.push(`
+set {
+  ${body.setter}
+}
+            `)
+          }
+          accessors = '\n' + lines.join('\n') + '\n'
+        }
+        return `var ${this.name}: ${type} { ${accessors} }`
+      }
+      case 'kotlin': {
+        const type = this.type.getCode('kotlin')
+        let keyword = this.isReadonly ? 'val' : 'var'
+        if (modifiers?.virtual) keyword = `abstract ${keyword}`
+        const lines: string[] = []
+        if (modifiers?.doNotStrip) {
+          lines.push('@get:DoNotStrip', '@get:Keep')
+          if (!this.isReadonly) {
+            lines.push('@set:DoNotStrip', '@set:Keep')
+          }
+        }
+        lines.push(`${keyword} ${this.name}: ${type}`)
+        if (body != null) {
+          lines.push(`
+  get() {
+    ${body.getter}
+  }
+          `)
+          if (!this.isReadonly) {
+            lines.push(`
+  set(value) {
+    ${body.setter}
+  }
+            `)
+          }
+        }
+        return lines.join('\n')
+      }
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for properties!`
+        )
+    }
+  }
+}

package/src/syntax/SourceFile.ts

@@ -0,0 +1,80 @@
+import type { Language, Platform } from '../getPlatformSpecs.js'
+import type { Type } from './types/Type.js'
+
+/**
+ * Represents a file with source code, in a specific programming language.
+ */
+export interface SourceFile {
+  /**
+   * The name of the file with extension (e.g. `Image.hpp`)
+   */
+  name: string
+  /**
+   * The subdirectory/subdirectories of the file, or empty (`[]`) if none.
+   */
+  subdirectory: string[]
+  /**
+   * The full content of the file.
+   */
+  content: string
+  /**
+   * The language the {@linkcode content} is written in (e.g. `c++`)
+   */
+  language: Language
+  /**
+   * The platform this file can be used on or is created for. (e.g. `ios`)
+   */
+  platform: Platform | 'shared'
+}
+
+/**
+ * Represents a {@linkcode SourceFile} that also references other types.
+ */
+export interface FileWithReferencedTypes extends SourceFile {
+  /**
+   * All external types this {@linkcode SourceFile} references,
+   * either as return types, parameter types, or member types.
+   */
+  referencedTypes: Type[]
+}
+
+/**
+ * Represents an import for a specific header or module.
+ *
+ * E.g. `include "Image.hpp"`, or `import NitroModules`
+ */
+export interface SourceImport {
+  /**
+   * The name of the header or module to import (e.g. `Image.hpp`)
+   */
+  name: string
+  /**
+   * If this is a C++ import, it could also be forward-declared.
+   * @example
+   * ```cpp
+   * namespace NitroTest {
+   *   class HybridImage;
+   * }
+   * ```
+   */
+  forwardDeclaration?: string
+  /**
+   * The language this file is written in (e.g. `c++`)
+   */
+  language: Language
+  /**
+   * Whether the import is a user-defined header (something local, like `"MyObject.hpp"`)
+   * or a shared system header (like `<NitroModules/HybridObject.hpp>`)
+   */
+  space: 'user' | 'system'
+}
+
+type GroupedFiles = Record<SourceFile['platform'], SourceFile[]>
+
+export function groupByPlatform(files: SourceFile[]): GroupedFiles {
+  const result: GroupedFiles = { shared: [], ios: [], android: [] }
+  for (const file of files) {
+    result[file.platform].push(file)
+  }
+  return result
+}

package/src/syntax/c++/CppEnum.ts

@@ -0,0 +1,128 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent, toLowerCamelCase } from '../../utils.js'
+import type { SourceFile } from '../SourceFile.js'
+import { createFileMetadataString } from '../helpers.js'
+import type { EnumMember } from '../types/EnumType.js'
+import { includeNitroHeader } from './includeNitroHeader.js'
+
+function getEnumMinValue(enumMembers: EnumMember[]): number {
+  return Math.min(...enumMembers.map((m) => m.value))
+}
+function getEnumMaxValue(enumMembers: EnumMember[]): number {
+  return Math.max(...enumMembers.map((m) => m.value))
+}
+
+function isIncrementingEnum(enumMembers: EnumMember[]): boolean {
+  let lastValue = getEnumMinValue(enumMembers) - 1
+  for (const enumMember of enumMembers) {
+    if (enumMember.value !== lastValue + 1) {
+      // it is not just one higher than the last value!
+      return false
+    }
+    lastValue = enumMember.value
+  }
+  // all enum values were incrementing!
+  return true
+}
+
+/**
+ * Creates a C++ enum that converts to a JS enum (aka just int)
+ */
+export function createCppEnum(
+  typename: string,
+  enumMembers: EnumMember[]
+): SourceFile {
+  // Namespace typename
+  const fullyQualifiedTypename = NitroConfig.current.getCxxNamespace(
+    'c++',
+    typename
+  )
+  // Map enum to C++ code
+  const cppEnumMembers = enumMembers
+    .map(
+      (m) =>
+        `${m.name}      SWIFT_NAME(${toLowerCamelCase(m.name)}) = ${m.value},`
+    )
+    .join('\n')
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+
+  let isInsideValidValues: string | undefined
+  if (isIncrementingEnum(enumMembers)) {
+    // It's just incrementing one after another, so we can simplify this to a bounds check
+    const minValue = getEnumMinValue(enumMembers)
+    const maxValue = getEnumMaxValue(enumMembers)
+    isInsideValidValues = `
+// Check if we are within the bounds of the enum.
+return integer >= ${minValue} && integer <= ${maxValue};
+    `.trim()
+  } else {
+    const cases = enumMembers.map(
+      (m) => `case ${m.value} /* ${m.name} */: return true;`
+    )
+    isInsideValidValues = `
+switch (integer) {
+  ${indent(cases.join('\n'), '  ')}
+  default: return false;
+}
+    `.trim()
+  }
+
+  // Create entire C++ file
+  const cppCode = `
+${createFileMetadataString(`${typename}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('JSIConverter.hpp')}
+${includeNitroHeader('NitroDefines.hpp')}
+
+namespace ${cxxNamespace} {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (${typename}).
+   */
+  enum class ${typename} {
+    ${indent(cppEnumMembers, '    ')}
+  } CLOSED_ENUM;
+
+} // namespace ${cxxNamespace}
+
+namespace margelo::nitro {
+
+  // C++ ${typename} <> JS ${typename} (enum)
+  template <>
+  struct JSIConverter<${fullyQualifiedTypename}> final {
+    static inline ${fullyQualifiedTypename} fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<${fullyQualifiedTypename}>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, ${fullyQualifiedTypename} arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      ${indent(isInsideValidValues, '      ')}
+    }
+  };
+
+} // namespace margelo::nitro
+        `
+
+  return {
+    content: cppCode,
+    subdirectory: [],
+    name: `${typename}.hpp`,
+    language: 'c++',
+    platform: 'shared',
+  }
+}