nitrogen 0.2.23 → 0.29.4

package/lib/syntax/swift/SwiftHybridObjectRegistration.js

@@ -0,0 +1,42 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { indent } from '../../utils.js';
+import { getHybridObjectName } from '../getHybridObjectName.js';
+import { HybridObjectType } from '../types/HybridObjectType.js';
+import { SwiftCxxBridgedType } from './SwiftCxxBridgedType.js';
+export function getHybridObjectConstructorCall(hybridObjectName) {
+    const swiftNamespace = NitroConfig.current.getIosModuleName();
+    const autolinkingClassName = `${swiftNamespace}Autolinking`;
+    return `${swiftNamespace}::${autolinkingClassName}::create${hybridObjectName}();`;
+}
+export function createSwiftHybridObjectRegistration({ hybridObjectName, swiftClassName, }) {
+    const { HybridTSpecCxx, HybridTSpecSwift, HybridTSpec } = getHybridObjectName(hybridObjectName);
+    const type = new HybridObjectType(hybridObjectName, 'swift', [], NitroConfig.current);
+    const bridge = new SwiftCxxBridgedType(type);
+    return {
+        swiftFunction: `
+/**
+ * Creates an instance of a Swift class that implements \`${HybridTSpec}\`,
+ * and wraps it in a Swift class that can directly interop with C++ (\`${HybridTSpecCxx}\`)
+ *
+ * This is generated by Nitrogen and will initialize the class specified
+ * in the \`"autolinking"\` property of \`nitro.json\` (in this case, \`${swiftClassName}\`).
+ */
+public static func create${hybridObjectName}() -> ${bridge.getTypeCode('swift')} {
+  let hybridObject = ${swiftClassName}()
+  return ${indent(bridge.parseFromSwiftToCpp('hybridObject', 'swift'), '  ')}
+}
+    `.trim(),
+        requiredImports: [
+            { name: `${HybridTSpecSwift}.hpp`, language: 'c++', space: 'user' },
+        ],
+        cppCode: `
+HybridObjectRegistry::registerHybridObjectConstructor(
+  "${hybridObjectName}",
+  []() -> std::shared_ptr<HybridObject> {
+    ${type.getCode('c++')} hybridObject = ${getHybridObjectConstructorCall(hybridObjectName)}
+    return hybridObject;
+  }
+);
+      `.trim(),
+    };
+}

package/lib/syntax/swift/SwiftStruct.d.ts

@@ -0,0 +1,3 @@
+import type { FileWithReferencedTypes } from '../SourceFile.js';
+import { StructType } from '../types/StructType.js';
+export declare function createSwiftStructBridge(struct: StructType): FileWithReferencedTypes;

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.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { VariantType } from '../types/VariantType.js';
+export declare function createSwiftVariant(variant: VariantType): SourceFile;

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.d.ts

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

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.d.ts

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

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.d.ts

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

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.d.ts

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

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.d.ts

@@ -0,0 +1,23 @@
+import { EnumDeclaration } from 'ts-morph';
+import { Type as TSMorphType, type ts } from 'ts-morph';
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export interface EnumMember {
+    name: string;
+    value: number;
+    stringValue: string;
+}
+export declare class EnumType implements Type {
+    readonly enumName: string;
+    readonly enumMembers: EnumMember[];
+    readonly jsType: 'enum' | 'union';
+    readonly declarationFile: SourceFile;
+    constructor(enumName: string, enumDeclaration: EnumDeclaration);
+    constructor(enumName: string, union: TSMorphType<ts.UnionType>);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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.d.ts

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

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;
+    }
+}