nitrogen 0.2.24 → 0.29.5

package/src/syntax/getCustomTypeConfig.ts

@@ -0,0 +1,71 @@
+import type { CustomTypeConfig } from 'react-native-nitro-modules'
+import type { Type as TSMorphType } from 'ts-morph'
+
+interface Result {
+  name: string
+  config: CustomTypeConfig
+}
+
+export function getCustomTypeConfig(type: TSMorphType): Result {
+  const parts = type.getIntersectionTypes()
+  for (const part of parts) {
+    const typeNameProperty = part.getProperty('__customTypeName')
+    if (typeNameProperty == null) continue
+    const typeConfigProperty = part.getProperty('__customTypeConfig')
+    if (typeConfigProperty == null) continue
+
+    const declaration = type.getAliasSymbolOrThrow().getDeclarations()[0]
+    if (declaration == null)
+      throw new Error(`Type has no declaration! ${type.getText()}`)
+
+    const typeNameTypeOrUndefined =
+      typeNameProperty.getTypeAtLocation(declaration)
+    const typeConfigTypeOrUndefined =
+      typeConfigProperty.getTypeAtLocation(declaration)
+
+    const typeNameType = typeNameTypeOrUndefined
+      .getUnionTypes()
+      .find((t) => t.isLiteral())
+    if (typeNameType == null) continue
+    const typeConfigType = typeConfigTypeOrUndefined
+      .getUnionTypes()
+      .find((t) => t.isObject())
+    if (typeConfigType == null) continue
+
+    const typeName = typeNameType.getLiteralValue()
+    if (typeof typeName !== 'string') {
+      throw new Error(
+        `CustomType's second argument (TypeName) needs to be a string! Instead, it is a ${typeof typeName} (${typeName})`
+      )
+    }
+    const includeType = typeConfigType
+      .getPropertyOrThrow('include')
+      .getTypeAtLocation(declaration)
+    const include = includeType.getLiteralValue()
+    if (typeof include !== 'string')
+      throw new Error(
+        `CustomType's third argument (Config) needs to contain { include }, which should be a string! (It is ${includeType.getText()} instead)`
+      )
+    const canBePassedByReferenceType = typeConfigType
+      .getProperty('canBePassedByReference')
+      ?.getTypeAtLocation(declaration)
+      .getUnionTypes()
+      .find((u) => u.isBooleanLiteral())
+      ?.getLiteralValue()
+    const canBePassedByReference =
+      typeof canBePassedByReferenceType === 'boolean'
+        ? canBePassedByReferenceType
+        : false
+
+    return {
+      name: typeName,
+      config: {
+        include: include,
+        canBePassedByReference: canBePassedByReference,
+      },
+    }
+  }
+  throw new Error(
+    `Type looks like a CustomType<...>, but doesn't have generic arguments! ${type.getText()}`
+  )
+}

package/src/syntax/getHybridObjectName.ts

@@ -0,0 +1,48 @@
+export interface HybridObjectName {
+  /**
+   * The raw name of the Hybrid Object (same as the TS interface name).
+   * @example "Image"
+   */
+  T: string
+  /**
+   * The debug-only description name of the Hybrid Object as it can be described in natively.
+   * @example "HybridImage"
+   */
+  HybridT: string
+  /**
+   * The name of the C++ class, Kotlin interface or Swift protocol that represents the
+   * specification (all of it's virtual properties and methods) of the Hybrid Object.
+   * @example "HybridImageSpec"
+   */
+  HybridTSpec: string
+  /**
+   * The name of the Swift class that bridges any types from
+   * {@linkcode HybridTSpec} over to C++.
+   * This includes a few type conversions or result/exception wrapping.
+   * @example "HybridImage_cxx"
+   */
+  HybridTSpecCxx: string
+  /**
+   * The name of the C++ class that actually bridges to the Java Hybrid Object.
+   * @example "JHybridImage"
+   */
+  JHybridTSpec: string
+  /**
+   * The name of the C++ class that extends the Hybrid Object and bridges over to the Swift C++ wrapper class.
+   * @example "HybridImageSwift"
+   */
+  HybridTSpecSwift: string
+}
+
+export function getHybridObjectName(
+  hybridObjectName: string
+): HybridObjectName {
+  return {
+    T: hybridObjectName,
+    HybridT: `Hybrid${hybridObjectName}`,
+    HybridTSpec: `Hybrid${hybridObjectName}Spec`,
+    HybridTSpecCxx: `Hybrid${hybridObjectName}Spec_cxx`,
+    JHybridTSpec: `JHybrid${hybridObjectName}Spec`,
+    HybridTSpecSwift: `Hybrid${hybridObjectName}SpecSwift`,
+  }
+}

package/src/syntax/getInterfaceProperties.ts

@@ -0,0 +1,21 @@
+import type { ts, Type } from 'ts-morph'
+import type { NamedType } from './types/Type.js'
+import { createNamedType } from './createType.js'
+import type { Language } from '../getPlatformSpecs.js'
+
+export function getInterfaceProperties(
+  language: Language,
+  interfaceType: Type<ts.ObjectType>
+): NamedType[] {
+  return interfaceType.getProperties().map((prop) => {
+    const declaration = prop.getValueDeclarationOrThrow()
+    const propType = prop.getTypeAtLocation(declaration)
+    const refType = createNamedType(
+      language,
+      prop.getName(),
+      propType,
+      prop.isOptional() || propType.isNullable()
+    )
+    return refType
+  })
+}

package/src/syntax/getReferencedTypes.ts

@@ -0,0 +1,57 @@
+import { ArrayType } from './types/ArrayType.js'
+import { FunctionType } from './types/FunctionType.js'
+import { getTypeAs } from './types/getTypeAs.js'
+import { OptionalType } from './types/OptionalType.js'
+import { PromiseType } from './types/PromiseType.js'
+import { RecordType } from './types/RecordType.js'
+import { StructType } from './types/StructType.js'
+import { TupleType } from './types/TupleType.js'
+import type { Type } from './types/Type.js'
+import { VariantType } from './types/VariantType.js'
+
+export function getReferencedTypes(type: Type): Type[] {
+  switch (type.kind) {
+    case 'array':
+      const array = getTypeAs(type, ArrayType)
+      return [type, ...getReferencedTypes(array.itemType)]
+
+    case 'function':
+      const func = getTypeAs(type, FunctionType)
+      return [
+        type,
+        ...getReferencedTypes(func.returnType),
+        ...func.parameters.flatMap((t) => getReferencedTypes(t)),
+      ]
+
+    case 'optional':
+      const optional = getTypeAs(type, OptionalType)
+      return [type, ...getReferencedTypes(optional.wrappingType)]
+
+    case 'promise':
+      const promise = getTypeAs(type, PromiseType)
+      return [type, ...getReferencedTypes(promise.resultingType)]
+
+    case 'record':
+      const record = getTypeAs(type, RecordType)
+      return [
+        type,
+        ...getReferencedTypes(record.keyType),
+        ...getReferencedTypes(record.valueType),
+      ]
+
+    case 'struct':
+      const struct = getTypeAs(type, StructType)
+      return [type, ...struct.properties.flatMap((p) => getReferencedTypes(p))]
+
+    case 'tuple':
+      const tuple = getTypeAs(type, TupleType)
+      return [type, ...tuple.itemTypes.flatMap((t) => getReferencedTypes(t))]
+
+    case 'variant':
+      const variant = getTypeAs(type, VariantType)
+      return [type, ...variant.variants.flatMap((t) => getReferencedTypes(t))]
+
+    default:
+      return [type]
+  }
+}

package/src/syntax/helpers.ts

@@ -0,0 +1,79 @@
+import path from 'path'
+import type { SourceFile } from './SourceFile.js'
+import type { Type } from './types/Type.js'
+import { getTypeAs } from './types/getTypeAs.js'
+import { OptionalType } from './types/OptionalType.js'
+
+type Comment = '///' | '#'
+
+export function createFileMetadataString(
+  filename: string,
+  comment: Comment = '///'
+): string {
+  const now = new Date()
+  return `
+${comment}
+${comment} ${filename}
+${comment} This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+${comment} https://github.com/mrousavy/nitro
+${comment} Copyright © ${now.getFullYear()} Marc Rousavy @ Margelo
+${comment}
+`.trim()
+}
+
+export function isFunction(type: Type): boolean {
+  switch (type.kind) {
+    case 'function':
+      return true
+    case 'optional': {
+      const optional = getTypeAs(type, OptionalType)
+      return isFunction(optional.wrappingType)
+    }
+    default:
+      return false
+  }
+}
+
+export function toReferenceType(type: string): `const ${typeof type}&` {
+  return `const ${type}&`
+}
+
+export function escapeCppName(string: string): string {
+  // Replace non-alphanumeric characters with underscores
+  let escapedStr = string.replace(/[^a-zA-Z0-9_]/g, '_')
+
+  // Ensure the first character is a letter or underscore
+  if (!/^[a-zA-Z_]/.test(escapedStr)) {
+    escapedStr = '_' + escapedStr
+  }
+
+  return escapedStr
+}
+
+export function isBooleanPropertyPrefix(name: string): boolean {
+  return name.startsWith('is') || name.startsWith('has')
+}
+
+export function isNotDuplicate<T>(item: T, index: number, array: T[]): boolean {
+  return array.indexOf(item) === index
+}
+
+export function isCppFile(file: SourceFile): boolean {
+  return file.name.endsWith('cpp') || file.name.endsWith('c')
+}
+
+export function getRelativeDirectory(file: SourceFile): string {
+  return path.join(
+    '..',
+    'nitrogen',
+    'generated',
+    file.platform,
+    file.language,
+    ...file.subdirectory,
+    file.name
+  )
+}
+
+export function getRelativeDirectoryGenerated(...subpath: string[]): string {
+  return path.join('..', 'nitrogen', 'generated', ...subpath)
+}

package/src/syntax/isCoreType.ts

@@ -0,0 +1,60 @@
+import { Type as TSMorphType } from 'ts-morph'
+
+function isSymbol(type: TSMorphType, symbolName: string): boolean {
+  // check the symbol directly
+  const symbol = type.getSymbol()
+  if (symbol?.getName() === symbolName) {
+    return true
+  }
+
+  // loop through the alias symbol alias chain to test each one
+  let aliasSymbol = type.getAliasSymbol()
+  while (aliasSymbol != null) {
+    if (aliasSymbol.getName() === symbolName) {
+      return true
+    }
+    aliasSymbol = aliasSymbol.getAliasedSymbol()
+  }
+
+  // nothing found.
+  return false
+}
+
+export function isPromise(type: TSMorphType): boolean {
+  return isSymbol(type, 'Promise')
+}
+
+export function isRecord(type: TSMorphType): boolean {
+  return isSymbol(type, 'Record')
+}
+
+export function isArrayBuffer(type: TSMorphType): boolean {
+  return isSymbol(type, 'ArrayBuffer')
+}
+
+export function isDate(type: TSMorphType): boolean {
+  return isSymbol(type, 'Date')
+}
+
+export function isMap(type: TSMorphType): boolean {
+  return isSymbol(type, 'AnyMap')
+}
+
+export function isError(type: TSMorphType): boolean {
+  return isSymbol(type, 'Error')
+}
+
+export function isCustomType(type: TSMorphType): boolean {
+  return (
+    type.getProperty('__customTypeName') != null &&
+    type.getProperty('__customTypeConfig') != null
+  )
+}
+
+export function isSyncFunction(type: TSMorphType): boolean {
+  if (type.getCallSignatures().length < 1)
+    // not a function.
+    return false
+  const syncTag = type.getProperty('__syncTag')
+  return syncTag != null
+}

package/src/syntax/kotlin/FbjniHybridObject.ts

@@ -0,0 +1,313 @@
+import { createIndentation, indent } from '../../utils.js'
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
+import { includeHeader } from '../c++/includeNitroHeader.js'
+import { getAllTypes } from '../getAllTypes.js'
+import { getHybridObjectName } from '../getHybridObjectName.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { HybridObjectSpec } from '../HybridObjectSpec.js'
+import { Method } from '../Method.js'
+import type { Property } from '../Property.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type } from '../types/Type.js'
+import { addJNINativeRegistration } from './JNINativeRegistrations.js'
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
+
+export function createFbjniHybridObject(spec: HybridObjectSpec): SourceFile[] {
+  const name = getHybridObjectName(spec.name)
+
+  // Because we cache JNI methods as `static` inside our method bodies,
+  // we need to re-create the method bodies per inherited class.
+  // This way `Child`'s statically cached `someMethod()` JNI reference
+  // is not the same as `Base`'s statically cached `someMethod()` JNI reference.
+  const properties = [
+    ...spec.properties,
+    ...spec.baseTypes.flatMap((b) => b.properties),
+  ]
+  const methods = [...spec.methods, ...spec.baseTypes.flatMap((b) => b.methods)]
+
+  const propertiesDecl = properties
+    .map((p) => p.getCode('c++', { override: true }))
+    .join('\n')
+  const methodsDecl = methods
+    .map((p) => p.getCode('c++', { override: true }))
+    .join('\n')
+  const jniClassDescriptor = spec.config.getAndroidPackage(
+    'c++/jni',
+    name.HybridTSpec
+  )
+  const cxxNamespace = spec.config.getCxxNamespace('c++')
+  const spaces = createIndentation(name.JHybridTSpec.length)
+
+  let cppBase = 'JHybridObject'
+  if (spec.baseTypes.length > 0) {
+    if (spec.baseTypes.length > 1) {
+      throw new Error(
+        `${name.T}: Inheriting from multiple HybridObject bases is not yet supported on Kotlin!`
+      )
+    }
+    const base = spec.baseTypes[0]!
+    cppBase = getHybridObjectName(base.name).JHybridTSpec
+    if (base.config.isExternalConfig) {
+      // It's an external type we inherit from - we have to prefix the namespace
+      cppBase = base.config.getCxxNamespace('c++', cppBase)
+    }
+  }
+  const cppImports: SourceImport[] = []
+  for (const base of spec.baseTypes) {
+    const { JHybridTSpec } = getHybridObjectName(base.name)
+
+    const headerName = base.config.isExternalConfig
+      ? `${base.config.getAndroidCxxLibName()}/${JHybridTSpec}.hpp`
+      : `${JHybridTSpec}.hpp`
+    cppImports.push({
+      language: 'c++',
+      name: headerName,
+      space: base.config.isExternalConfig ? 'system' : 'user',
+      forwardDeclaration: getForwardDeclaration(
+        'class',
+        JHybridTSpec,
+        base.config.getCxxNamespace('c++')
+      ),
+    })
+  }
+
+  const cppHeaderCode = `
+${createFileMetadataString(`${name.HybridTSpec}.hpp`)}
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "${name.HybridTSpec}.hpp"
+
+${cppImports
+  .map((i) => i.forwardDeclaration)
+  .filter((f) => f != null)
+  .join('\n')}
+${cppImports.map((i) => includeHeader(i)).join('\n')}
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  class ${name.JHybridTSpec}: public jni::HybridClass<${name.JHybridTSpec}, ${cppBase}>,
+${spaces}          public virtual ${name.HybridTSpec} {
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via \`initHybrid()\`)
+    explicit ${name.JHybridTSpec}(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(${name.HybridTSpec}::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~${name.JHybridTSpec}() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<${name.JHybridTSpec}::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    ${indent(propertiesDecl, '    ')}
+
+  public:
+    // Methods
+    ${indent(methodsDecl, '    ')}
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<${name.JHybridTSpec}::javaobject> _javaPart;
+  };
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  // Make sure we register all native JNI methods on app startup
+  addJNINativeRegistration({
+    namespace: cxxNamespace,
+    className: `${name.JHybridTSpec}`,
+    import: {
+      name: `${name.JHybridTSpec}.hpp`,
+      space: 'user',
+      language: 'c++',
+    },
+  })
+
+  const propertiesImpl = properties
+    .map((m) => getFbjniPropertyForwardImplementation(spec, m))
+    .join('\n')
+  const methodsImpl = methods
+    .map((m) => getFbjniMethodForwardImplementation(spec, m, m.name))
+    .join('\n')
+  const allTypes = getAllTypes(spec)
+  allTypes.push(...getAllBaseTypes(spec)) // <-- remember, we copy all base methods & properties over too
+  const jniImports = allTypes
+    .map((t) => new KotlinCxxBridgedType(t))
+    .flatMap((t) => t.getRequiredImports('c++'))
+    .filter((i) => i != null)
+  const cppIncludes = jniImports
+    .map((i) => includeHeader(i))
+    .filter(isNotDuplicate)
+  const cppForwardDeclarations = jniImports
+    .map((i) => i.forwardDeclaration)
+    .filter((d) => d != null)
+    .filter(isNotDuplicate)
+
+  const cppImplCode = `
+${createFileMetadataString(`${name.JHybridTSpec}.cpp`)}
+
+#include "${name.JHybridTSpec}.hpp"
+
+${cppForwardDeclarations.join('\n')}
+
+${cppIncludes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  jni::local_ref<${name.JHybridTSpec}::jhybriddata> ${name.JHybridTSpec}::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void ${name.JHybridTSpec}::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", ${name.JHybridTSpec}::initHybrid),
+    });
+  }
+
+  size_t ${name.JHybridTSpec}::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void ${name.JHybridTSpec}::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  ${indent(propertiesImpl, '  ')}
+
+  // Methods
+  ${indent(methodsImpl, '  ')}
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const files: SourceFile[] = []
+  files.push({
+    content: cppHeaderCode,
+    language: 'c++',
+    name: `${name.JHybridTSpec}.hpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  files.push({
+    content: cppImplCode,
+    language: 'c++',
+    name: `${name.JHybridTSpec}.cpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  return files
+}
+
+function getFbjniMethodForwardImplementation(
+  spec: HybridObjectSpec,
+  method: Method,
+  jniMethodName: string
+): string {
+  const name = getHybridObjectName(spec.name)
+
+  const returnJNI = new KotlinCxxBridgedType(method.returnType)
+  const requiresBridge =
+    returnJNI.needsSpecialHandling ||
+    method.parameters.some((p) => {
+      const bridged = new KotlinCxxBridgedType(p.type)
+      return bridged.needsSpecialHandling
+    })
+  const methodName = requiresBridge ? `${jniMethodName}_cxx` : jniMethodName
+
+  const returnType = returnJNI.asJniReferenceType('local')
+  const paramsTypes = method.parameters
+    .map((p) => {
+      const bridge = new KotlinCxxBridgedType(p.type)
+      return `${bridge.asJniReferenceType('alias')} /* ${p.name} */`
+    })
+    .join(', ')
+  const cxxSignature = `${returnType}(${paramsTypes})`
+
+  const paramsForward = method.parameters.map((p) => {
+    const bridged = new KotlinCxxBridgedType(p.type)
+    return bridged.parse(p.name, 'c++', 'kotlin', 'c++')
+  })
+  paramsForward.unshift('_javaPart') // <-- first param is always Java `this`
+
+  let body: string
+  if (returnJNI.hasType) {
+    // return something - we need to parse it
+    body = `
+static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+auto __result = method(${paramsForward.join(', ')});
+return ${returnJNI.parse('__result', 'kotlin', 'c++', 'c++')};
+    `
+  } else {
+    // void method. no return
+    body = `
+static const auto method = javaClassStatic()->getMethod<${cxxSignature}>("${methodName}");
+method(${paramsForward.join(', ')});
+   `
+  }
+  const code = method.getCode(
+    'c++',
+    {
+      classDefinitionName: name.JHybridTSpec,
+    },
+    body.trim()
+  )
+  return code
+}
+
+function getFbjniPropertyForwardImplementation(
+  spec: HybridObjectSpec,
+  property: Property
+): string {
+  const methods: string[] = []
+
+  // getter
+  const getter = getFbjniMethodForwardImplementation(
+    spec,
+    property.cppGetter,
+    property.getGetterName('jvm')
+  )
+  methods.push(getter)
+
+  if (property.cppSetter != null) {
+    // setter
+    const setter = getFbjniMethodForwardImplementation(
+      spec,
+      property.cppSetter,
+      property.getSetterName('jvm')
+    )
+    methods.push(setter)
+  }
+
+  return methods.join('\n')
+}
+
+function getAllBaseTypes(spec: HybridObjectSpec): Type[] {
+  return spec.baseTypes.flatMap((b) => getAllTypes(b))
+}

package/src/syntax/kotlin/JNINativeRegistrations.ts

@@ -0,0 +1,19 @@
+import type { SourceImport } from '../SourceFile.js'
+
+export interface JNINativeRegistration {
+  namespace: string
+  className: string
+  import: SourceImport
+}
+
+const jniNativeRegistrations: JNINativeRegistration[] = []
+
+export function addJNINativeRegistration(
+  registerFunc: JNINativeRegistration
+): void {
+  jniNativeRegistrations.push(registerFunc)
+}
+
+export function getJNINativeRegistrations(): JNINativeRegistration[] {
+  return jniNativeRegistrations
+}

package/src/syntax/kotlin/KotlinBoxedPrimitive.ts

@@ -0,0 +1,19 @@
+import type { Type } from '../types/Type.js'
+
+/**
+ * Returns a boxed version of the given primitive type.
+ * In JNI/Kotlin, primitive types (like `double` or `boolean`)
+ * cannot be nullable, so we need to box them - e.g. as `JDouble` or `JBoolean`.
+ */
+export function getKotlinBoxedPrimitiveType(type: Type): string {
+  switch (type.kind) {
+    case 'number':
+      return 'jni::JDouble'
+    case 'boolean':
+      return 'jni::JBoolean'
+    case 'bigint':
+      return 'jni::JLong'
+    default:
+      throw new Error(`Type ${type.kind} is not a primitive!`)
+  }
+}