nitrogen 0.2.24 → 0.29.4

package/lib/syntax/kotlin/KotlinEnum.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import { EnumType } from '../types/EnumType.js';
+export declare function createKotlinEnum(enumType: EnumType): SourceFile[];

package/lib/syntax/kotlin/KotlinEnum.js

@@ -0,0 +1,113 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { capitalizeName, indent } from '../../utils.js';
+import { createFileMetadataString } from '../helpers.js';
+import { EnumType } from '../types/EnumType.js';
+export function createKotlinEnum(enumType) {
+    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 = [];
+    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, enumType) {
+    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/lib/syntax/kotlin/KotlinFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { FunctionType } from '../types/FunctionType.js';
+export declare function createKotlinFunction(functionType: FunctionType): SourceFile[];

package/lib/syntax/kotlin/KotlinFunction.js

@@ -0,0 +1,256 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { indent } from '../../utils.js';
+import { includeHeader } from '../c++/includeNitroHeader.js';
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
+import { addJNINativeRegistration } from './JNINativeRegistrations.js';
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
+export function createKotlinFunction(functionType) {
+    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;
+    let jniCallBody;
+    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 = [];
+    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/lib/syntax/kotlin/KotlinHybridObject.d.ts

@@ -0,0 +1,3 @@
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile } from '../SourceFile.js';
+export declare function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[];

package/lib/syntax/kotlin/KotlinHybridObject.js

@@ -0,0 +1,177 @@
+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 { Method } from '../Method.js';
+import { Property } from '../Property.js';
+import { HybridObjectType } from '../types/HybridObjectType.js';
+import { createFbjniHybridObject } from './FbjniHybridObject.js';
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
+export function createKotlinHybridObject(spec) {
+    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 = [];
+    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 = [];
+    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) {
+    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) {
+    const bridged = new KotlinCxxBridgedType(property.type);
+    if (bridged.needsSpecialHandling) {
+        let keyword = property.isReadonly ? 'val' : 'var';
+        let lines = [];
+        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/lib/syntax/kotlin/KotlinHybridObjectRegistration.d.ts

@@ -0,0 +1,17 @@
+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 declare function createJNIHybridObjectRegistration({ hybridObjectName, jniClassName, }: Props): JNIHybridObjectRegistration;
+export {};

package/lib/syntax/kotlin/KotlinHybridObjectRegistration.js

@@ -0,0 +1,26 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { getHybridObjectName } from '../getHybridObjectName.js';
+export function createJNIHybridObjectRegistration({ hybridObjectName, jniClassName, }) {
+    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(),
+    };
+}

package/lib/syntax/kotlin/KotlinStruct.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { StructType } from '../types/StructType.js';
+export declare function createKotlinStruct(structType: StructType): SourceFile[];