nitrogen 0.2.24 → 0.29.5

package/lib/syntax/types/HybridObjectBaseType.js

@@ -0,0 +1,38 @@
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+export class HybridObjectBaseType {
+    constructor() { }
+    get canBePassedByReference() {
+        // It's a shared_ptr<..>, no copy.
+        return true;
+    }
+    get kind() {
+        return 'hybrid-object-base';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return `std::shared_ptr<HybridObject>`;
+            default:
+                throw new Error(`The base type \`HybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'memory',
+                space: 'system',
+            }, {
+                name: `NitroModules/HybridObject.hpp`,
+                forwardDeclaration: getForwardDeclaration('class', 'HybridObject', 'margelo::nitro'),
+                language: 'c++',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/HybridObjectType.js

@@ -0,0 +1,131 @@
+import {} from '../../config/NitroConfig.js';
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+import { getHybridObjectName } from '../getHybridObjectName.js';
+export class HybridObjectType {
+    hybridObjectName;
+    implementationLanguage;
+    baseTypes;
+    sourceConfig;
+    constructor(...args) {
+        if (args.length === 1) {
+            const [spec] = args;
+            this.hybridObjectName = spec.name;
+            this.implementationLanguage = spec.language;
+            this.sourceConfig = spec.config;
+            this.baseTypes = spec.baseTypes.map((b) => new HybridObjectType(b));
+        }
+        else {
+            const [hybridObjectName, implementationLanguage, baseTypes, sourceConfig,] = args;
+            this.hybridObjectName = hybridObjectName;
+            this.implementationLanguage = implementationLanguage;
+            this.baseTypes = baseTypes;
+            this.sourceConfig = sourceConfig;
+        }
+        if (this.hybridObjectName.startsWith('__')) {
+            throw new Error(`HybridObject name cannot start with two underscores (__)! (In ${this.hybridObjectName})`);
+        }
+    }
+    get canBePassedByReference() {
+        // It's a shared_ptr<..>, no copy.
+        return true;
+    }
+    get kind() {
+        return 'hybrid-object';
+    }
+    getCode(language, options = {}) {
+        const name = getHybridObjectName(this.hybridObjectName);
+        const mode = options.mode ?? 'strong';
+        const fullyQualified = options.fullyQualified ?? this.sourceConfig.isExternalConfig;
+        switch (language) {
+            case 'c++': {
+                const ptrType = mode === 'strong' ? 'std::shared_ptr' : 'std::weak_ptr';
+                if (fullyQualified) {
+                    const fullName = this.sourceConfig.getCxxNamespace('c++', name.HybridTSpec);
+                    return `${ptrType}<${fullName}>`;
+                }
+                else {
+                    return `${ptrType}<${name.HybridTSpec}>`;
+                }
+            }
+            case 'swift': {
+                return `(any ${name.HybridTSpec})`;
+            }
+            case 'kotlin': {
+                if (fullyQualified) {
+                    // full qualified name: "com.margelo.nitro.image.Image"
+                    return this.sourceConfig.getAndroidPackage('java/kotlin', name.HybridTSpec);
+                }
+                else {
+                    // "Image"
+                    return name.HybridTSpec;
+                }
+            }
+            default:
+                throw new Error(`Language ${language} is not yet supported for HybridObjectType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getExternalCxxImportName() {
+        // TODO: We currently don't have a xplat way of handling import paths, therefore iosModuleName and androidCxxLibName need to have the same value.
+        if (this.sourceConfig.getIosModuleName() !==
+            this.sourceConfig.getAndroidCxxLibName()) {
+            throw new Error(`Cannot import external HybridObject "${this.hybridObjectName}" if it's nitro.json's iosModuleName and androidCxxLibName are not the same value!`);
+        }
+        return this.sourceConfig.getIosModuleName();
+    }
+    getRequiredImports(language) {
+        const name = getHybridObjectName(this.hybridObjectName);
+        const cxxNamespace = this.sourceConfig.getCxxNamespace('c++');
+        const imports = [];
+        switch (language) {
+            case 'c++': {
+                imports.push({
+                    language: 'c++',
+                    name: 'memory',
+                    space: 'system',
+                });
+                if (this.sourceConfig.isExternalConfig) {
+                    const cxxImport = this.getExternalCxxImportName();
+                    imports.push({
+                        name: `${cxxImport}/${name.HybridTSpec}.hpp`,
+                        forwardDeclaration: getForwardDeclaration('class', name.HybridTSpec, cxxNamespace),
+                        language: 'c++',
+                        space: 'system',
+                    });
+                }
+                else {
+                    imports.push({
+                        name: `${name.HybridTSpec}.hpp`,
+                        forwardDeclaration: getForwardDeclaration('class', name.HybridTSpec, cxxNamespace),
+                        language: 'c++',
+                        space: 'user',
+                    });
+                }
+                break;
+            }
+            case 'kotlin': {
+                if (this.sourceConfig.isExternalConfig) {
+                    imports.push({
+                        language: 'kotlin',
+                        name: this.sourceConfig.getAndroidPackage('java/kotlin', name.HybridTSpec),
+                        space: 'system',
+                    });
+                }
+                break;
+            }
+            case 'swift': {
+                if (this.sourceConfig.isExternalConfig) {
+                    imports.push({
+                        language: 'swift',
+                        name: this.sourceConfig.getIosModuleName(),
+                        space: 'system',
+                    });
+                }
+                break;
+            }
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/MapType.js

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

package/lib/syntax/types/NamedWrappingType.js

@@ -0,0 +1,27 @@
+import { escapeCppName } from '../helpers.js';
+export class NamedWrappingType {
+    type;
+    name;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+    get escapedName() {
+        return escapeCppName(this.name);
+    }
+    get kind() {
+        return this.type.kind;
+    }
+    get canBePassedByReference() {
+        return this.type.canBePassedByReference;
+    }
+    getCode(language, options) {
+        return this.type.getCode(language, options);
+    }
+    getExtraFiles() {
+        return this.type.getExtraFiles();
+    }
+    getRequiredImports(language) {
+        return this.type.getRequiredImports(language);
+    }
+}

package/lib/syntax/types/NullType.js

@@ -0,0 +1,23 @@
+export class NullType {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'null';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'std::nullptr_t';
+            default:
+                throw new Error(`Language ${language} is not yet supported for NullType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/lib/syntax/types/NumberType.js

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

package/lib/syntax/types/OptionalType.js

@@ -0,0 +1,59 @@
+import {} from '../SourceFile.js';
+export class OptionalType {
+    wrappingType;
+    constructor(wrappingType) {
+        this.wrappingType = wrappingType;
+    }
+    get canBePassedByReference() {
+        // depends whether the wrapping type is heavy to copy or not.
+        return this.wrappingType.canBePassedByReference;
+    }
+    get kind() {
+        return 'optional';
+    }
+    get needsBraces() {
+        switch (this.wrappingType.kind) {
+            case 'function':
+                return true;
+            default:
+                return false;
+        }
+    }
+    getCode(language, options) {
+        const wrapping = this.wrappingType.getCode(language, options);
+        switch (language) {
+            case 'c++':
+                return `std::optional<${wrapping}>`;
+            case 'swift':
+                if (this.needsBraces) {
+                    return `(${wrapping})?`;
+                }
+                else {
+                    return `${wrapping}?`;
+                }
+            case 'kotlin':
+                if (this.needsBraces) {
+                    return `(${wrapping})?`;
+                }
+                else {
+                    return `${wrapping}?`;
+                }
+            default:
+                throw new Error(`Language ${language} is not yet supported for OptionalType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.wrappingType.getExtraFiles();
+    }
+    getRequiredImports(language) {
+        const imports = this.wrappingType.getRequiredImports(language);
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'optional',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/PromiseType.js

@@ -0,0 +1,62 @@
+import {} from '../SourceFile.js';
+import { ErrorType } from './ErrorType.js';
+import { FunctionType } from './FunctionType.js';
+import { NamedWrappingType } from './NamedWrappingType.js';
+import { VoidType } from './VoidType.js';
+export class PromiseType {
+    resultingType;
+    errorType;
+    constructor(resultingType) {
+        this.resultingType = resultingType;
+        this.errorType = new ErrorType();
+    }
+    get canBePassedByReference() {
+        // It's a future<..>, it cannot be copied.
+        return true;
+    }
+    get kind() {
+        return 'promise';
+    }
+    get resolverFunction() {
+        if (this.resultingType.kind === 'void') {
+            return new FunctionType(new VoidType(), []);
+        }
+        else {
+            return new FunctionType(new VoidType(), [
+                new NamedWrappingType('value', this.resultingType),
+            ]);
+        }
+    }
+    get rejecterFunction() {
+        return new FunctionType(new VoidType(), [
+            new NamedWrappingType('error', this.errorType),
+        ]);
+    }
+    getCode(language, options) {
+        const resultingCode = this.resultingType.getCode(language, options);
+        switch (language) {
+            case 'c++':
+                return `std::shared_ptr<Promise<${resultingCode}>>`;
+            case 'swift':
+                return `Promise<${resultingCode}>`;
+            case 'kotlin':
+                return `Promise<${resultingCode}>`;
+            default:
+                throw new Error(`Language ${language} is not yet supported for PromiseType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.resultingType.getExtraFiles();
+    }
+    getRequiredImports(language) {
+        const imports = this.resultingType.getRequiredImports(language);
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'NitroModules/Promise.hpp',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/RecordType.js

@@ -0,0 +1,47 @@
+import {} from '../SourceFile.js';
+export class RecordType {
+    keyType;
+    valueType;
+    constructor(keyType, valueType) {
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+    get canBePassedByReference() {
+        // It's a unordered_map<..>, heavy to copy.
+        return true;
+    }
+    get kind() {
+        return 'record';
+    }
+    getCode(language, options) {
+        const keyCode = this.keyType.getCode(language, options);
+        const valueCode = this.valueType.getCode(language, options);
+        switch (language) {
+            case 'c++':
+                return `std::unordered_map<${keyCode}, ${valueCode}>`;
+            case 'swift':
+                return `Dictionary<${keyCode}, ${valueCode}>`;
+            case 'kotlin':
+                return `Map<${keyCode}, ${valueCode}>`;
+            default:
+                throw new Error(`Language ${language} is not yet supported for RecordType!`);
+        }
+    }
+    getExtraFiles() {
+        return [...this.keyType.getExtraFiles(), ...this.valueType.getExtraFiles()];
+    }
+    getRequiredImports(language) {
+        const imports = [
+            ...this.keyType.getRequiredImports(language),
+            ...this.valueType.getRequiredImports(language),
+        ];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'unordered_map',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/ResultWrappingType.js

@@ -0,0 +1,44 @@
+import {} from '../SourceFile.js';
+import { ErrorType } from './ErrorType.js';
+export class ResultWrappingType {
+    result;
+    error;
+    constructor(result) {
+        this.result = result;
+        this.error = new ErrorType();
+    }
+    get canBePassedByReference() {
+        return this.result.canBePassedByReference;
+    }
+    get kind() {
+        return 'result-wrapper';
+    }
+    getCode(language, options) {
+        const type = this.result.getCode(language, options);
+        switch (language) {
+            case 'c++':
+                return `Result<${type}>`;
+            case 'swift':
+                return type;
+            default:
+                throw new Error(`Language ${language} is not yet supported for VariantType!`);
+        }
+    }
+    getExtraFiles() {
+        return [...this.result.getExtraFiles(), ...this.error.getExtraFiles()];
+    }
+    getRequiredImports(language) {
+        const imports = [
+            ...this.result.getRequiredImports(language),
+            ...this.error.getRequiredImports(language),
+        ];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'NitroModules/Result.hpp',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/StringType.js

@@ -0,0 +1,35 @@
+export class StringType {
+    get canBePassedByReference() {
+        // It's a string<..>, heavy to copy.
+        return true;
+    }
+    get kind() {
+        return 'string';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'std::string';
+            case 'swift':
+                return 'String';
+            case 'kotlin':
+                return 'String';
+            default:
+                throw new Error(`Language ${language} is not yet supported for StringType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'string',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/StructType.js

@@ -0,0 +1,61 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { createCppStruct } from '../c++/CppStruct.js';
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+import {} from '../SourceFile.js';
+export class StructType {
+    structName;
+    properties;
+    declarationFile;
+    constructor(structName, properties) {
+        this.structName = structName;
+        this.properties = properties;
+        this.declarationFile = createCppStruct(structName, properties);
+        if (this.structName.startsWith('__')) {
+            throw new Error(`Struct name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${this.structName})`);
+        }
+        if (this.properties.length === 0) {
+            throw new Error(`Empty structs are not supported in Nitrogen! Add at least one property to ${this.structName}.`);
+        }
+    }
+    get canBePassedByReference() {
+        // It's a struct, heavy to copy.
+        return true;
+    }
+    get kind() {
+        return 'struct';
+    }
+    getCode(language, { fullyQualified } = {}) {
+        switch (language) {
+            case 'c++':
+                if (fullyQualified) {
+                    return NitroConfig.current.getCxxNamespace('c++', this.structName);
+                }
+                else {
+                    return this.structName;
+                }
+            case 'swift':
+                return this.structName;
+            case 'kotlin':
+                return this.structName;
+            default:
+                throw new Error(`Language ${language} is not yet supported for StructType!`);
+        }
+    }
+    getExtraFiles() {
+        const referencedTypes = this.declarationFile.referencedTypes.flatMap((r) => r.getExtraFiles());
+        return [this.declarationFile, ...referencedTypes];
+    }
+    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('struct', this.structName, cxxNamespace),
+                space: 'user',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/TupleType.js

@@ -0,0 +1,39 @@
+import {} from '../SourceFile.js';
+export class TupleType {
+    itemTypes;
+    constructor(itemTypes) {
+        this.itemTypes = itemTypes;
+    }
+    get canBePassedByReference() {
+        // It's a tuple<..> - heavy to copy
+        return true;
+    }
+    get kind() {
+        return 'tuple';
+    }
+    getCode(language, options) {
+        const types = this.itemTypes.map((t) => t.getCode(language, options));
+        switch (language) {
+            case 'c++':
+                return `std::tuple<${types.join(', ')}>`;
+            case 'swift':
+                throw new Error(`Tuple (${types.join(', ')}) is not yet supported in Swift due to a Swift bug! See https://github.com/swiftlang/swift/issues/75865`);
+            default:
+                throw new Error(`Language ${language} is not yet supported for TupleType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.itemTypes.flatMap((t) => t.getExtraFiles());
+    }
+    getRequiredImports(language) {
+        const imports = this.itemTypes.flatMap((t) => t.getRequiredImports(language));
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'tuple',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/Type.js

@@ -0,0 +1 @@
+export {};