nitrogen 0.2.23 → 0.29.4

package/lib/syntax/getHybridObjectName.d.ts

@@ -0,0 +1,36 @@
+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 declare function getHybridObjectName(hybridObjectName: string): HybridObjectName;

package/lib/syntax/getHybridObjectName.js

@@ -0,0 +1,10 @@
+export function getHybridObjectName(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/lib/syntax/getInterfaceProperties.d.ts

@@ -0,0 +1,4 @@
+import type { ts, Type } from 'ts-morph';
+import type { NamedType } from './types/Type.js';
+import type { Language } from '../getPlatformSpecs.js';
+export declare function getInterfaceProperties(language: Language, interfaceType: Type<ts.ObjectType>): NamedType[];

package/lib/syntax/getInterfaceProperties.js

@@ -0,0 +1,9 @@
+import { createNamedType } from './createType.js';
+export function getInterfaceProperties(language, interfaceType) {
+    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/lib/syntax/getReferencedTypes.d.ts

@@ -0,0 +1,2 @@
+import type { Type } from './types/Type.js';
+export declare function getReferencedTypes(type: Type): Type[];

package/lib/syntax/getReferencedTypes.js

@@ -0,0 +1,47 @@
+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 { VariantType } from './types/VariantType.js';
+export function getReferencedTypes(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/lib/syntax/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { SourceFile } from './SourceFile.js';
+import type { Type } from './types/Type.js';
+type Comment = '///' | '#';
+export declare function createFileMetadataString(filename: string, comment?: Comment): string;
+export declare function isFunction(type: Type): boolean;
+export declare function toReferenceType(type: string): `const ${typeof type}&`;
+export declare function escapeCppName(string: string): string;
+export declare function isBooleanPropertyPrefix(name: string): boolean;
+export declare function isNotDuplicate<T>(item: T, index: number, array: T[]): boolean;
+export declare function isCppFile(file: SourceFile): boolean;
+export declare function getRelativeDirectory(file: SourceFile): string;
+export declare function getRelativeDirectoryGenerated(...subpath: string[]): string;
+export {};

package/lib/syntax/helpers.js

@@ -0,0 +1,53 @@
+import path from 'path';
+import { getTypeAs } from './types/getTypeAs.js';
+import { OptionalType } from './types/OptionalType.js';
+export function createFileMetadataString(filename, comment = '///') {
+    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) {
+    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) {
+    return `const ${type}&`;
+}
+export function escapeCppName(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) {
+    return name.startsWith('is') || name.startsWith('has');
+}
+export function isNotDuplicate(item, index, array) {
+    return array.indexOf(item) === index;
+}
+export function isCppFile(file) {
+    return file.name.endsWith('cpp') || file.name.endsWith('c');
+}
+export function getRelativeDirectory(file) {
+    return path.join('..', 'nitrogen', 'generated', file.platform, file.language, ...file.subdirectory, file.name);
+}
+export function getRelativeDirectoryGenerated(...subpath) {
+    return path.join('..', 'nitrogen', 'generated', ...subpath);
+}

package/lib/syntax/isCoreType.d.ts

@@ -0,0 +1,9 @@
+import { Type as TSMorphType } from 'ts-morph';
+export declare function isPromise(type: TSMorphType): boolean;
+export declare function isRecord(type: TSMorphType): boolean;
+export declare function isArrayBuffer(type: TSMorphType): boolean;
+export declare function isDate(type: TSMorphType): boolean;
+export declare function isMap(type: TSMorphType): boolean;
+export declare function isError(type: TSMorphType): boolean;
+export declare function isCustomType(type: TSMorphType): boolean;
+export declare function isSyncFunction(type: TSMorphType): boolean;

package/lib/syntax/isCoreType.js

@@ -0,0 +1,47 @@
+import { Type as TSMorphType } from 'ts-morph';
+function isSymbol(type, symbolName) {
+    // 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) {
+    return isSymbol(type, 'Promise');
+}
+export function isRecord(type) {
+    return isSymbol(type, 'Record');
+}
+export function isArrayBuffer(type) {
+    return isSymbol(type, 'ArrayBuffer');
+}
+export function isDate(type) {
+    return isSymbol(type, 'Date');
+}
+export function isMap(type) {
+    return isSymbol(type, 'AnyMap');
+}
+export function isError(type) {
+    return isSymbol(type, 'Error');
+}
+export function isCustomType(type) {
+    return (type.getProperty('__customTypeName') != null &&
+        type.getProperty('__customTypeConfig') != null);
+}
+export function isSyncFunction(type) {
+    if (type.getCallSignatures().length < 1)
+        // not a function.
+        return false;
+    const syncTag = type.getProperty('__syncTag');
+    return syncTag != null;
+}

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

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

package/lib/syntax/kotlin/FbjniHybridObject.js

@@ -0,0 +1,261 @@
+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 { Method } from '../Method.js';
+import { addJNINativeRegistration } from './JNINativeRegistrations.js';
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
+export function createFbjniHybridObject(spec) {
+    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 = [];
+    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 = [];
+    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, method, jniMethodName) {
+    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;
+    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, property) {
+    const methods = [];
+    // 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) {
+    return spec.baseTypes.flatMap((b) => getAllTypes(b));
+}

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

@@ -0,0 +1,8 @@
+import type { SourceImport } from '../SourceFile.js';
+export interface JNINativeRegistration {
+    namespace: string;
+    className: string;
+    import: SourceImport;
+}
+export declare function addJNINativeRegistration(registerFunc: JNINativeRegistration): void;
+export declare function getJNINativeRegistrations(): JNINativeRegistration[];

package/lib/syntax/kotlin/JNINativeRegistrations.js

@@ -0,0 +1,7 @@
+const jniNativeRegistrations = [];
+export function addJNINativeRegistration(registerFunc) {
+    jniNativeRegistrations.push(registerFunc);
+}
+export function getJNINativeRegistrations() {
+    return jniNativeRegistrations;
+}

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

@@ -0,0 +1,7 @@
+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 declare function getKotlinBoxedPrimitiveType(type: Type): string;

package/lib/syntax/kotlin/KotlinBoxedPrimitive.js

@@ -0,0 +1,17 @@
+/**
+ * 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) {
+    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!`);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { BridgedType } from '../BridgedType.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type } from '../types/Type.js';
+export declare class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
+    readonly type: Type;
+    constructor(type: Type);
+    get hasType(): boolean;
+    get canBePassedByReference(): boolean;
+    get needsSpecialHandling(): boolean;
+    getRequiredImports(language: Language): SourceImport[];
+    getExtraFiles(): SourceFile[];
+    asJniReferenceType(referenceType?: 'alias' | 'local' | 'global'): string;
+    getTypeCode(language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    parse(parameterName: string, from: 'c++' | 'kotlin', to: 'kotlin' | 'c++', inLanguage: 'kotlin' | 'c++'): string;
+    parseFromCppToKotlin(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    parseFromKotlinToCpp(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    private getFullJHybridObjectName;
+}