nitrogen 0.2.24 → 0.29.5

package/lib/syntax/swift/SwiftStruct.js

@@ -0,0 +1,75 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { indent } from '../../utils.js';
+import { createFileMetadataString } from '../helpers.js';
+import { Parameter } from '../Parameter.js';
+import { StructType } from '../types/StructType.js';
+import { SwiftCxxBridgedType } from './SwiftCxxBridgedType.js';
+export function createSwiftStructBridge(struct) {
+    const fullName = NitroConfig.current.getCxxNamespace('swift', struct.structName);
+    const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('swift');
+    const init = createSwiftBridgedConstructor(struct);
+    const bridgedProps = struct.properties
+        .map((p) => {
+        const bridge = new SwiftCxxBridgedType(p, true);
+        const cppName = `self.__${p.escapedName}`;
+        return `
+var ${p.escapedName}: ${p.getCode('swift')} {
+  @inline(__always)
+  get {
+    return ${indent(bridge.parseFromCppToSwift(cppName, 'swift'), '    ')}
+  }
+  @inline(__always)
+  set {
+    ${cppName} = ${indent(bridge.parseFromSwiftToCpp('newValue', 'swift'), '    ')}
+  }
+}
+    `.trim();
+    })
+        .join('\n\n');
+    const code = `
+${createFileMetadataString(`${struct.structName}.swift`)}
+
+import NitroModules
+
+/**
+ * Represents an instance of \`${struct.structName}\`, backed by a C++ struct.
+ */
+public typealias ${struct.structName} = ${fullName}
+
+public extension ${struct.structName} {
+  private typealias bridge = ${bridgeNamespace}
+
+  ${indent(init, '  ')}
+
+  ${indent(bridgedProps, '  ')}
+}
+  `.trim();
+    return {
+        content: code,
+        language: 'swift',
+        name: `${struct.structName}.swift`,
+        platform: 'ios',
+        subdirectory: [],
+        referencedTypes: struct.properties,
+    };
+}
+function createSwiftBridgedConstructor(struct) {
+    const params = struct.properties
+        .map((p) => new Parameter(p.escapedName, p))
+        .map((p) => p.getCode('swift'))
+        .join(', ');
+    const paramsForward = struct.properties
+        .map((p) => {
+        const bridged = new SwiftCxxBridgedType(p, true);
+        return bridged.parseFromSwiftToCpp(p.escapedName, 'swift');
+    })
+        .join(', ');
+    return `
+/**
+ * Create a new instance of \`${struct.structName}\`.
+ */
+init(${params}) {
+  self.init(${indent(paramsForward, '  ')})
+}
+  `.trim();
+}

package/lib/syntax/swift/SwiftVariant.js

@@ -0,0 +1,58 @@
+import { indent } from '../../utils.js';
+import { createFileMetadataString } from '../helpers.js';
+import { getTypeAs } from '../types/getTypeAs.js';
+import { OptionalType } from '../types/OptionalType.js';
+function isPrimitive(type) {
+    switch (type.kind) {
+        case 'bigint':
+        case 'boolean':
+        case 'number':
+        case 'string':
+        case 'void':
+        case 'result-wrapper':
+        case 'null':
+        case 'error':
+            return true;
+        case 'optional':
+            const optional = getTypeAs(type, OptionalType);
+            return isPrimitive(optional.wrappingType);
+        default:
+            return false;
+    }
+}
+export function createSwiftVariant(variant) {
+    const typename = variant.getAliasName('swift');
+    const cases = variant.cases
+        .map(([label, v]) => {
+        const type = v.getCode('swift');
+        return `case ${label}(${type})`;
+    })
+        .join('\n');
+    const jsSignature = variant.variants.map((t) => t.kind).join(' | ');
+    const allPrimitives = variant.variants.every((v) => isPrimitive(v));
+    const enumDeclaration = allPrimitives ? 'enum' : 'indirect enum';
+    const extraImports = variant.variants
+        .flatMap((t) => t.getRequiredImports('swift'))
+        .map((i) => `import ${i.name}`);
+    const code = `
+${createFileMetadataString(`${typename}.swift`)}
+
+${extraImports.join('\n')}
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: \`${jsSignature}\`
+ */
+@frozen
+public ${enumDeclaration} ${typename} {
+  ${indent(cases, '  ')}
+}
+  `.trim();
+    return {
+        content: code,
+        language: 'swift',
+        name: `${typename}.swift`,
+        platform: 'ios',
+        subdirectory: [],
+    };
+}

package/lib/syntax/types/ArrayBufferType.js

@@ -0,0 +1,37 @@
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+export class ArrayBufferType {
+    get canBePassedByReference() {
+        // It's a shared_ptr.
+        return true;
+    }
+    get kind() {
+        return 'array-buffer';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'std::shared_ptr<ArrayBuffer>';
+            case 'swift':
+                return 'ArrayBuffer';
+            case 'kotlin':
+                return 'ArrayBuffer';
+            default:
+                throw new Error(`Language ${language} is not yet supported for ArrayBufferType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                name: 'NitroModules/ArrayBuffer.hpp',
+                forwardDeclaration: getForwardDeclaration('class', 'ArrayBuffer', 'NitroModules'),
+                language: 'c++',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/ArrayType.d.ts

@@ -0,0 +1,12 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare class ArrayType implements Type {
+    readonly itemType: Type;
+    constructor(itemType: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/ArrayType.js

@@ -0,0 +1,52 @@
+import {} from '../SourceFile.js';
+export class ArrayType {
+    itemType;
+    constructor(itemType) {
+        this.itemType = itemType;
+    }
+    get canBePassedByReference() {
+        // It's a vector<..>, heavy to copy
+        return true;
+    }
+    get kind() {
+        return 'array';
+    }
+    getCode(language, options) {
+        const itemCode = this.itemType.getCode(language, options);
+        switch (language) {
+            case 'c++':
+                return `std::vector<${itemCode}>`;
+            case 'swift':
+                return `[${itemCode}]`;
+            case 'kotlin':
+                switch (this.itemType.kind) {
+                    case 'number':
+                        return 'DoubleArray';
+                    case 'boolean':
+                        return 'BooleanArray';
+                    case 'bigint':
+                        return 'LongArray';
+                    default:
+                        return `Array<${itemCode}>`;
+                }
+            default:
+                throw new Error(`Language ${language} is not yet supported for ArrayType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.itemType.getExtraFiles();
+    }
+    getRequiredImports(language) {
+        const imports = [
+            ...this.itemType.getRequiredImports(language),
+        ];
+        if (language === 'c++') {
+            imports.push({
+                name: 'vector',
+                language: 'c++',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/BigIntType.js

@@ -0,0 +1,27 @@
+export class BigIntType {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'bigint';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'int64_t';
+            case 'swift':
+                return 'Int64';
+            case 'kotlin':
+                return 'Long';
+            default:
+                throw new Error(`Language ${language} is not yet supported for BigIntType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/lib/syntax/types/BooleanType.js

@@ -0,0 +1,27 @@
+export class BooleanType {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'boolean';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'bool';
+            case 'swift':
+                return 'Bool';
+            case 'kotlin':
+                return 'Boolean';
+            default:
+                throw new Error(`Language ${language} is not yet supported for BooleanType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/lib/syntax/types/CustomType.d.ts

@@ -0,0 +1,14 @@
+import type { CustomTypeConfig } from 'react-native-nitro-modules';
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class CustomType implements Type {
+    typeConfig: CustomTypeConfig;
+    typeName: string;
+    constructor(typeName: string, typeConfig: CustomTypeConfig);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/CustomType.js

@@ -0,0 +1,36 @@
+export class CustomType {
+    typeConfig;
+    typeName;
+    constructor(typeName, typeConfig) {
+        this.typeName = typeName;
+        this.typeConfig = typeConfig;
+    }
+    get canBePassedByReference() {
+        return this.typeConfig.canBePassedByReference ?? false;
+    }
+    get kind() {
+        return 'custom-type';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return this.typeName;
+            default:
+                throw new Error(`Language ${language} is not yet supported for CustomType "${this.typeName}"!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                name: this.typeConfig.include,
+                language: 'c++',
+                space: 'user',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/DateType.js

@@ -0,0 +1,35 @@
+export class DateType {
+    get canBePassedByReference() {
+        // simple chrono value type
+        return false;
+    }
+    get kind() {
+        return 'date';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'std::chrono::system_clock::time_point';
+            case 'swift':
+                return 'Date';
+            case 'kotlin':
+                return 'java.time.Instant';
+            default:
+                throw new Error(`Language ${language} is not yet supported for DateType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                name: 'chrono',
+                language: 'c++',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/EnumType.js

@@ -0,0 +1,101 @@
+import { EnumDeclaration } from 'ts-morph';
+import { Type as TSMorphType } from 'ts-morph';
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+import {} from '../SourceFile.js';
+import { createCppEnum } from '../c++/CppEnum.js';
+import { escapeCppName } from '../helpers.js';
+import { createCppUnion } from '../c++/CppUnion.js';
+import { NitroConfig } from '../../config/NitroConfig.js';
+export class EnumType {
+    enumName;
+    enumMembers;
+    jsType;
+    declarationFile;
+    constructor(enumName, declaration) {
+        this.enumName = enumName;
+        if (declaration instanceof EnumDeclaration) {
+            // It's a JS enum { ... }
+            this.jsType = 'enum';
+            this.enumMembers = declaration.getMembers().map((m) => {
+                const name = m.getSymbolOrThrow().getEscapedName();
+                const value = m.getValue();
+                if (typeof value !== 'number') {
+                    throw new Error(`Enum member ${enumName}.${name} is ${value} (${typeof value}), which cannot be represented in C++ enums.\n` +
+                        `Each enum member must be a number! If you want to use strings, use TypeScript unions ("a" | "b") instead!`);
+                }
+                return {
+                    name: escapeCppName(name).toUpperCase(),
+                    value: value,
+                    stringValue: name,
+                };
+            });
+            this.declarationFile = createCppEnum(enumName, this.enumMembers);
+        }
+        else {
+            // It's a TS union '..' | '..'
+            this.jsType = 'union';
+            this.enumMembers = declaration
+                .getNonNullableType()
+                .getUnionTypes()
+                .map((t, i) => {
+                if (t.isStringLiteral()) {
+                    const literalValue = t.getLiteralValueOrThrow();
+                    if (typeof literalValue !== 'string')
+                        throw new Error(`${enumName}: Value "${literalValue}" is not a string - it is ${typeof literalValue}!`);
+                    return {
+                        name: escapeCppName(literalValue).toUpperCase(),
+                        value: i,
+                        stringValue: literalValue,
+                    };
+                }
+                else {
+                    throw new Error(`${enumName}: Value "${t.getText()}" is not a string literal - it cannot be represented in a C++ enum!`);
+                }
+            });
+            this.declarationFile = createCppUnion(enumName, this.enumMembers);
+        }
+        if (this.enumName.startsWith('__')) {
+            throw new Error(`Enum name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${this.enumName}: ${this.enumMembers.map((m) => m.name).join(' | ')})`);
+        }
+    }
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'enum';
+    }
+    getCode(language, { fullyQualified } = {}) {
+        switch (language) {
+            case 'c++':
+                if (fullyQualified) {
+                    return NitroConfig.current.getCxxNamespace('c++', this.enumName);
+                }
+                else {
+                    return this.enumName;
+                }
+            case 'swift':
+                return this.enumName;
+            case 'kotlin':
+                return this.enumName;
+            default:
+                throw new Error(`Language ${language} is not yet supported for NumberType!`);
+        }
+    }
+    getExtraFiles() {
+        return [this.declarationFile];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
+            imports.push({
+                name: this.declarationFile.name,
+                language: this.declarationFile.language,
+                forwardDeclaration: getForwardDeclaration('enum class', this.enumName, cxxNamespace),
+                space: 'user',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/ErrorType.js

@@ -0,0 +1,37 @@
+import {} from '../SourceFile.js';
+export class ErrorType {
+    constructor() { }
+    get canBePassedByReference() {
+        // It's a exception<..>, pass by reference.
+        return true;
+    }
+    get kind() {
+        return 'error';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return `std::exception_ptr`;
+            case 'swift':
+                return `Error`;
+            case 'kotlin':
+                return `Throwable`;
+            default:
+                throw new Error(`Language ${language} is not yet supported for ThrowableType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'exception',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/FunctionType.js

@@ -0,0 +1,147 @@
+import { escapeCppName, toReferenceType } from '../helpers.js';
+import { Parameter } from '../Parameter.js';
+import {} from '../SourceFile.js';
+import { PromiseType } from './PromiseType.js';
+export class FunctionType {
+    returnType;
+    parameters;
+    constructor(returnType, parameters, isSync = false) {
+        if (returnType.kind === 'void' || isSync) {
+            // void callbacks are async, but we don't care about the result.
+            this.returnType = returnType;
+        }
+        else {
+            // non-void callbacks are async and need to be awaited to get the result from JS.
+            this.returnType = new PromiseType(returnType);
+        }
+        this.parameters = parameters;
+        if (isSync && returnType.kind === 'void') {
+            throw new Error(`Function \`${this.jsName}\` cannot be sync (\`Sync<...>\`) AND return \`void\`, as this is ambiguous. ` +
+                `Either return a value (even if it's just a \`boolean\`) to keep it sync, or make it async.`);
+        }
+    }
+    get specializationName() {
+        return ('Func_' +
+            [this.returnType, ...this.parameters]
+                .map((p) => escapeCppName(p.getCode('c++')))
+                .join('_'));
+    }
+    get jsName() {
+        const paramsJs = this.parameters
+            .map((p) => `${p.name}: ${p.kind}`)
+            .join(', ');
+        const returnType = this.returnType.getCode('c++');
+        return `(${paramsJs}) => ${returnType}`;
+    }
+    get canBePassedByReference() {
+        // It's a function<..>, heavy to copy.
+        return true;
+    }
+    get kind() {
+        return 'function';
+    }
+    /**
+     * For a function, get the forward recreation of it:
+     * If variable is called `func`, this would return:
+     * ```cpp
+     * [func = std::move(func)](Params... params) -> ReturnType {
+     *   return func(params...);
+     * }
+     * ```
+     */
+    getForwardRecreationCode(variableName, language) {
+        const returnType = this.returnType.getCode(language);
+        const parameters = this.parameters
+            .map((p) => new Parameter(p.name, p))
+            .map((p) => p.getCode('c++'));
+        const forwardedParameters = this.parameters.map((p) => `std::forward<decltype(${p.name})>(${p.name})`);
+        switch (language) {
+            case 'c++':
+                const closure = `[${variableName} = std::move(${variableName})]`;
+                const signature = `(${parameters.join(', ')}) -> ${returnType}`;
+                const body = `{ return ${variableName}(${forwardedParameters.join(', ')}); }`;
+                return `${closure} ${signature} ${body}`;
+            default:
+                throw new Error(`Language ${language} is not yet supported for function forward recreations!`);
+        }
+    }
+    getCppFunctionPointerType(name, includeNameInfo = true) {
+        const params = this.parameters
+            .map((p) => {
+            const type = p.getCode('c++');
+            const code = p.canBePassedByReference ? toReferenceType(type) : type;
+            if (includeNameInfo)
+                return `${code} /* ${p.name} */`;
+            else
+                return code;
+        })
+            .join(', ');
+        const returnType = this.returnType.getCode('c++');
+        return `${returnType}(*${name})(${params})`;
+    }
+    getCode(language, options = {}) {
+        const includeNameInfo = options.includeNameInfo ?? true;
+        switch (language) {
+            case 'c++': {
+                const params = this.parameters
+                    .map((p) => {
+                    const type = p.getCode('c++', options);
+                    const code = p.canBePassedByReference ? toReferenceType(type) : type;
+                    if (includeNameInfo)
+                        return `${code} /* ${p.name} */`;
+                    else
+                        return code;
+                })
+                    .join(', ');
+                const returnType = this.returnType.getCode(language, options);
+                return `std::function<${returnType}(${params})>`;
+            }
+            case 'swift': {
+                const params = this.parameters
+                    .map((p) => {
+                    if (includeNameInfo)
+                        return `_ ${p.escapedName}: ${p.getCode(language, options)}`;
+                    else
+                        return p.getCode(language, options);
+                })
+                    .join(', ');
+                const returnType = this.returnType.getCode(language, options);
+                return `(${params}) -> ${returnType}`;
+            }
+            case 'kotlin': {
+                const params = this.parameters
+                    .map((p) => {
+                    if (includeNameInfo)
+                        return `${p.escapedName}: ${p.getCode(language, options)}`;
+                    else
+                        return p.getCode(language, options);
+                })
+                    .join(', ');
+                const returnType = this.returnType.getCode(language, options);
+                return `(${params}) -> ${returnType}`;
+            }
+            default:
+                throw new Error(`Language ${language} is not yet supported for FunctionType!`);
+        }
+    }
+    getExtraFiles() {
+        return [
+            ...this.returnType.getExtraFiles(),
+            ...this.parameters.flatMap((p) => p.getExtraFiles()),
+        ];
+    }
+    getRequiredImports(language) {
+        const imports = [
+            ...this.returnType.getRequiredImports(language),
+            ...this.parameters.flatMap((p) => p.getRequiredImports(language)),
+        ];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'functional',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}