nitrogen 0.2.24 → 0.29.5

package/src/syntax/kotlin/KotlinEnum.ts

@@ -0,0 +1,130 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { capitalizeName, indent } from '../../utils.js'
+import { createFileMetadataString } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import { EnumType } from '../types/EnumType.js'
+
+export function createKotlinEnum(enumType: EnumType): SourceFile[] {
+  const members = enumType.enumMembers.map(
+    (m) => `${m.name.toUpperCase()}(${m.value})`
+  )
+  const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
+  const code = `
+${createFileMetadataString(`${enumType.enumName}.kt`)}
+
+package ${packageName}
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "${enumType.enumName}".
+ */
+@DoNotStrip
+@Keep
+enum class ${enumType.enumName}(@DoNotStrip @Keep val value: Int) {
+  ${indent(members.join(',\n'), '  ')};
+}
+  `.trim()
+
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+  const jniClassDescriptor = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    enumType.enumName
+  )
+  const cppToJniConverterCode = getCppToJniConverterCode('value', enumType)
+
+  const fbjniCode = `
+${createFileMetadataString(`J${enumType.enumName}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "${enumType.declarationFile.name}"
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "${enumType.enumName}" and the the Kotlin enum "${enumType.enumName}".
+   */
+  struct J${enumType.enumName} final: public jni::JavaClass<J${enumType.enumName}> {
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ${enumType.enumName}.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ${enumType.enumName} toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<${enumType.enumName}>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<J${enumType.enumName}> fromCpp(${enumType.enumName} value) {
+      ${indent(cppToJniConverterCode, '      ')}
+    }
+  };
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const files: SourceFile[] = []
+  files.push({
+    content: code,
+    language: 'kotlin',
+    name: `${enumType.enumName}.kt`,
+    subdirectory: NitroConfig.current.getAndroidPackageDirectory(),
+    platform: 'android',
+  })
+  files.push({
+    content: fbjniCode,
+    language: 'c++',
+    name: `J${enumType.enumName}.hpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  return files
+}
+
+function getCppToJniConverterCode(
+  cppValueName: string,
+  enumType: EnumType
+): string {
+  const jniEnumName = `J${enumType.enumName}`
+
+  const fields = enumType.enumMembers.map((m) => {
+    const fieldName = `field${capitalizeName(m.name)}`
+    return `static const auto ${fieldName} = clazz->getStaticField<${jniEnumName}>("${m.name}");`
+  })
+
+  const cases = enumType.enumMembers.map((m) => {
+    const fieldName = `field${capitalizeName(m.name)}`
+    return `
+case ${enumType.enumName}::${m.name}:
+  return clazz->getStaticFieldValue(${fieldName});
+`.trim()
+  })
+
+  return `
+static const auto clazz = javaClassStatic();
+${fields.join('\n')}
+
+switch (${cppValueName}) {
+  ${indent(cases.join('\n'), '  ')}
+  default:
+    std::string stringValue = std::to_string(static_cast<int>(${cppValueName}));
+    throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+}
+  `.trim()
+}

package/src/syntax/kotlin/KotlinFunction.ts

@@ -0,0 +1,277 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent } from '../../utils.js'
+import { includeHeader } from '../c++/includeNitroHeader.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import type { FunctionType } from '../types/FunctionType.js'
+import { addJNINativeRegistration } from './JNINativeRegistrations.js'
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
+
+export function createKotlinFunction(functionType: FunctionType): SourceFile[] {
+  const name = functionType.specializationName
+  const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
+  const kotlinReturnType = functionType.returnType.getCode('kotlin')
+  const kotlinParams = functionType.parameters.map(
+    (p) => `${p.escapedName}: ${p.getCode('kotlin')}`
+  )
+  const kotlinParamTypes = functionType.parameters.map((p) =>
+    p.getCode('kotlin')
+  )
+  const kotlinParamsForward = functionType.parameters.map((p) => p.escapedName)
+  const lambdaSignature = `(${kotlinParamTypes.join(', ')}) -> ${kotlinReturnType}`
+
+  const extraImports = functionType
+    .getRequiredImports('kotlin')
+    .map((i) => `import ${i.name}`)
+
+  const kotlinCode = `
+${createFileMetadataString(`${name}.kt`)}
+
+package ${packageName}
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+import dalvik.annotation.optimization.FastNative
+${extraImports.join('\n')}
+
+/**
+ * Represents the JavaScript callback \`${functionType.jsName}\`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface ${name}: ${lambdaSignature} {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(${kotlinParams.join(', ')}): ${kotlinReturnType}
+}
+
+/**
+ * Represents the JavaScript callback \`${functionType.jsName}\`.
+ * This is implemented in C++, via a \`std::function<...>\`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class ${name}_cxx: ${name} {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(${kotlinParams.join(', ')}): ${kotlinReturnType}
+    = invoke_cxx(${kotlinParamsForward.join(',')})
+
+  @FastNative
+  private external fun invoke_cxx(${kotlinParams.join(', ')}): ${kotlinReturnType}
+}
+
+/**
+ * Represents the JavaScript callback \`${functionType.jsName}\`.
+ * This is implemented in Java/Kotlin, via a \`${lambdaSignature}\`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class ${name}_java(private val function: ${lambdaSignature}): ${name} {
+  @DoNotStrip
+  @Keep
+  override fun invoke(${kotlinParams.join(', ')}): ${kotlinReturnType} {
+    return this.function(${kotlinParamsForward.join(', ')})
+  }
+}
+  `.trim()
+
+  const jniInterfaceDescriptor = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    name
+  )
+  const jniClassDescriptor = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    `${name}_cxx`
+  )
+  const bridgedReturn = new KotlinCxxBridgedType(functionType.returnType)
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+  const typename = functionType.getCode('c++')
+
+  // call() Java -> C++
+  const cppParams = functionType.parameters.map((p) => {
+    const bridge = new KotlinCxxBridgedType(p)
+    const type = bridge.asJniReferenceType('alias')
+    return `${type} ${p.escapedName}`
+  })
+  const paramsForward = functionType.parameters.map((p) => {
+    const bridge = new KotlinCxxBridgedType(p)
+    return bridge.parseFromKotlinToCpp(p.escapedName, 'c++', false)
+  })
+
+  // call() C++ -> Java
+  const jniParams = functionType.parameters.map((p) => {
+    if (p.canBePassedByReference) {
+      return `const ${p.getCode('c++')}& ${p.escapedName}`
+    } else {
+      return `${p.getCode('c++')} ${p.escapedName}`
+    }
+  })
+  const jniParamsForward = [
+    'self()',
+    ...functionType.parameters.map((p) => {
+      const bridge = new KotlinCxxBridgedType(p)
+      return bridge.parseFromCppToKotlin(p.escapedName, 'c++', false)
+    }),
+  ]
+  const jniSignature = `${bridgedReturn.asJniReferenceType('local')}(${functionType.parameters
+    .map((p) => {
+      const bridge = new KotlinCxxBridgedType(p)
+      return `${bridge.asJniReferenceType('alias')} /* ${p.escapedName} */`
+    })
+    .join(', ')})`
+
+  let cppCallBody: string
+  let jniCallBody: string
+  if (functionType.returnType.kind === 'void') {
+    // It returns void
+    cppCallBody = `_func(${indent(paramsForward.join(', '), '      ')});`
+    jniCallBody = `
+static const auto method = javaClassStatic()->getMethod<${jniSignature}>("invoke");
+method(${jniParamsForward.join(', ')});
+    `.trim()
+  } else {
+    // It returns a type!
+    cppCallBody = `
+${functionType.returnType.getCode('c++')} __result = _func(${indent(paramsForward.join(', '), '      ')});
+return ${bridgedReturn.parseFromCppToKotlin('__result', 'c++')};
+`.trim()
+    jniCallBody = `
+static const auto method = javaClassStatic()->getMethod<${jniSignature}>("invoke");
+auto __result = method(${jniParamsForward.join(', ')});
+return ${bridgedReturn.parseFromKotlinToCpp('__result', 'c++', false)};
+    `.trim()
+  }
+
+  const bridged = new KotlinCxxBridgedType(functionType)
+  const imports = bridged
+    .getRequiredImports('c++')
+    .filter((i) => i.name !== `J${name}.hpp`)
+  const includes = imports.map((i) => includeHeader(i)).filter(isNotDuplicate)
+
+  const fbjniCode = `
+${createFileMetadataString(`J${name}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+${includes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback \`${functionType.getCode('kotlin')}\`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct J${name}: public jni::JavaClass<J${name}> {
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniInterfaceDescriptor};";
+
+  public:
+    /**
+     * Invokes the function this \`J${name}\` instance holds through JNI.
+     */
+    ${functionType.returnType.getCode('c++')} invoke(${jniParams.join(', ')}) const {
+      ${indent(jniCallBody, '      ')}
+    }
+  };
+
+  /**
+   * An implementation of ${name} that is backed by a C++ implementation (using \`std::function<...>\`)
+   */
+  struct J${name}_cxx final: public jni::HybridClass<J${name}_cxx, J${name}> {
+  public:
+    static jni::local_ref<J${name}::javaobject> fromCpp(const ${typename}& func) {
+      return J${name}_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ \`std::function<...>\` this \`J${name}_cxx\` instance holds.
+     */
+    ${bridgedReturn.asJniReferenceType('local')} invoke_cxx(${cppParams.join(', ')}) {
+      ${indent(cppCallBody, '      ')}
+    }
+
+  public:
+    [[nodiscard]]
+    inline const ${typename}& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", J${name}_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit J${name}_cxx(const ${typename}& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    ${typename} _func;
+  };
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  // Make sure we register all native JNI methods on app startup
+  addJNINativeRegistration({
+    namespace: cxxNamespace,
+    className: `J${name}_cxx`,
+    import: {
+      name: `J${name}.hpp`,
+      space: 'user',
+      language: 'c++',
+    },
+  })
+
+  const files: SourceFile[] = []
+  files.push({
+    content: kotlinCode,
+    language: 'kotlin',
+    name: `${name}.kt`,
+    subdirectory: NitroConfig.current.getAndroidPackageDirectory(),
+    platform: 'android',
+  })
+  files.push({
+    content: fbjniCode,
+    language: 'c++',
+    name: `J${name}.hpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  return files
+}

package/src/syntax/kotlin/KotlinHybridObject.ts

@@ -0,0 +1,205 @@
+import { indent } from '../../utils.js'
+import { createKotlinHybridViewManager } from '../../views/kotlin/KotlinHybridViewManager.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 { Property } from '../Property.js'
+import type { SourceFile } from '../SourceFile.js'
+import { HybridObjectType } from '../types/HybridObjectType.js'
+import { createFbjniHybridObject } from './FbjniHybridObject.js'
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
+
+export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
+  const name = getHybridObjectName(spec.name)
+  const properties = spec.properties
+    .map((p) => getPropertyForwardImplementation(p))
+    .join('\n\n')
+  const methods = spec.methods
+    .map((m) => getMethodForwardImplementation(m))
+    .join('\n\n')
+
+  const extraImports = [
+    ...spec.properties.flatMap((p) => p.getRequiredImports('kotlin')),
+    ...spec.methods.flatMap((m) => m.getRequiredImports('kotlin')),
+    ...spec.baseTypes.flatMap((b) =>
+      new HybridObjectType(b).getRequiredImports('kotlin')
+    ),
+  ]
+
+  let kotlinBase = spec.isHybridView ? 'HybridView' : 'HybridObject'
+  if (spec.baseTypes.length > 0) {
+    if (spec.baseTypes.length > 1) {
+      throw new Error(
+        `${name.T}: Inheriting from multiple HybridObject bases is not yet supported in Kotlin!`
+      )
+    }
+    const base = spec.baseTypes[0]!
+    const baseHybrid = new HybridObjectType(base)
+    kotlinBase = baseHybrid.getCode('kotlin')
+  }
+
+  const imports: string[] = []
+  imports.push('import com.margelo.nitro.core.*')
+  if (spec.isHybridView) {
+    imports.push('import com.margelo.nitro.views.*')
+  }
+  imports.push(
+    ...extraImports.map((i) => `import ${i.name}`).filter(isNotDuplicate)
+  )
+
+  const javaPackage = spec.config.getAndroidPackage('java/kotlin')
+
+  // 1. Create Kotlin abstract class definition
+  const abstractClassCode = `
+${createFileMetadataString(`${name.HybridTSpec}.kt`)}
+
+package ${javaPackage}
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+${imports.join('\n')}
+
+/**
+ * A Kotlin class representing the ${spec.name} HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of ${spec.name}.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class ${name.HybridTSpec}: ${kotlinBase}() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  ${indent(properties, '  ')}
+
+  // Methods
+  ${indent(methods, '  ')}
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "${name.HybridTSpec}"
+  }
+}
+  `.trim()
+
+  // 2. Create C++ (fbjni) bindings
+  const cppFiles = createFbjniHybridObject(spec)
+
+  // 3. Create enums or structs in Kotlin
+  const extraFiles = getAllTypes(spec)
+    .map((t) => new KotlinCxxBridgedType(t))
+    .flatMap((b) => b.getExtraFiles())
+
+  const files: SourceFile[] = []
+  files.push({
+    content: abstractClassCode,
+    language: 'kotlin',
+    name: `${name.HybridTSpec}.kt`,
+    subdirectory: spec.config.getAndroidPackageDirectory(),
+    platform: 'android',
+  })
+  files.push(...cppFiles)
+  files.push(...extraFiles)
+
+  if (spec.isHybridView) {
+    const viewFiles = createKotlinHybridViewManager(spec)
+    files.push(...viewFiles)
+  }
+
+  return files
+}
+
+function getMethodForwardImplementation(method: Method): string {
+  const bridgedReturn = new KotlinCxxBridgedType(method.returnType)
+  const requiresBridge =
+    bridgedReturn.needsSpecialHandling ||
+    method.parameters.some((p) => {
+      const bridged = new KotlinCxxBridgedType(p.type)
+      return bridged.needsSpecialHandling
+    })
+
+  if (requiresBridge) {
+    const paramsSignature = method.parameters.map((p) => {
+      const bridge = new KotlinCxxBridgedType(p.type)
+      return `${p.name}: ${bridge.getTypeCode('kotlin')}`
+    })
+    const paramsForward = method.parameters.map((p) => {
+      const bridge = new KotlinCxxBridgedType(p.type)
+      return bridge.parseFromCppToKotlin(p.name, 'kotlin')
+    })
+    const returnForward = bridgedReturn.parseFromKotlinToCpp(
+      '__result',
+      'kotlin'
+    )
+    const code = method.getCode('kotlin', { virtual: true })
+    return `
+${code}
+
+@DoNotStrip
+@Keep
+private fun ${method.name}_cxx(${paramsSignature.join(', ')}): ${bridgedReturn.getTypeCode('kotlin')} {
+  val __result = ${method.name}(${paramsForward.join(', ')})
+  return ${returnForward}
+}
+    `.trim()
+  } else {
+    const code = method.getCode('kotlin', { doNotStrip: true, virtual: true })
+    return code
+  }
+}
+
+function getPropertyForwardImplementation(property: Property): string {
+  const bridged = new KotlinCxxBridgedType(property.type)
+  if (bridged.needsSpecialHandling) {
+    let keyword = property.isReadonly ? 'val' : 'var'
+    let lines: string[] = []
+    lines.push(
+      `
+@Keep
+@DoNotStrip
+get() {
+  return ${indent(bridged.parseFromKotlinToCpp(property.name, 'kotlin'), '  ')}
+}
+    `.trim()
+    )
+    if (!property.isReadonly) {
+      lines.push(
+        `
+@Keep
+@DoNotStrip
+set(value) {
+  ${property.name} = ${indent(bridged.parseFromCppToKotlin('value', 'kotlin'), '  ')}
+}
+      `.trim()
+      )
+    }
+    const code = property.getCode('kotlin', { virtual: true })
+    return `
+${code}
+
+private ${keyword} ${property.name}_cxx: ${bridged.getTypeCode('kotlin')}
+  ${indent(lines.join('\n'), '  ')}
+    `.trim()
+  } else {
+    const code = property.getCode('kotlin', { doNotStrip: true, virtual: true })
+    return code
+  }
+}

package/src/syntax/kotlin/KotlinHybridObjectRegistration.ts

@@ -0,0 +1,51 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { getHybridObjectName } from '../getHybridObjectName.js'
+import type { SourceImport } from '../SourceFile.js'
+
+interface Props {
+  /**
+   * The name of the Hybrid Object under which it should be registered and exposed to JS to.
+   */
+  hybridObjectName: string
+  /**
+   * The name of the Kotlin/Java class that will be default-constructed
+   */
+  jniClassName: string
+}
+
+interface JNIHybridObjectRegistration {
+  cppCode: string
+  requiredImports: SourceImport[]
+}
+
+export function createJNIHybridObjectRegistration({
+  hybridObjectName,
+  jniClassName,
+}: Props): JNIHybridObjectRegistration {
+  const { JHybridTSpec } = getHybridObjectName(hybridObjectName)
+  const jniNamespace = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    jniClassName
+  )
+
+  return {
+    requiredImports: [
+      { name: `${JHybridTSpec}.hpp`, language: 'c++', space: 'user' },
+      {
+        name: 'NitroModules/DefaultConstructableObject.hpp',
+        language: 'c++',
+        space: 'system',
+      },
+    ],
+    cppCode: `
+HybridObjectRegistry::registerHybridObjectConstructor(
+  "${hybridObjectName}",
+  []() -> std::shared_ptr<HybridObject> {
+    static DefaultConstructableObject<${JHybridTSpec}::javaobject> object("${jniNamespace}");
+    auto instance = object.create();
+    return instance->cthis()->shared();
+  }
+);
+      `.trim(),
+  }
+}