nitrogen 0.2.23 → 0.29.4

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

@@ -0,0 +1,29 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export interface GetFunctionCodeOptions extends GetCodeOptions {
+    includeNameInfo?: boolean;
+}
+export declare class FunctionType implements Type {
+    readonly returnType: Type;
+    readonly parameters: NamedType[];
+    constructor(returnType: Type, parameters: NamedType[], isSync?: boolean);
+    get specializationName(): string;
+    get jsName(): string;
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    /**
+     * 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: string, language: Language): string;
+    getCppFunctionPointerType(name: string, includeNameInfo?: boolean): string;
+    getCode(language: Language, options?: GetFunctionCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

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

@@ -0,0 +1,23 @@
+import { type NitroConfig } from '../../config/NitroConfig.js';
+import type { Language } from '../../getPlatformSpecs.js';
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+interface GetHybridObjectCodeOptions extends GetCodeOptions {
+    mode?: 'strong' | 'weak';
+}
+export declare class HybridObjectType implements Type {
+    readonly hybridObjectName: string;
+    readonly implementationLanguage: Language;
+    readonly baseTypes: HybridObjectType[];
+    readonly sourceConfig: NitroConfig;
+    constructor(hybridObjectName: string, implementationLanguage: Language, baseTypes: HybridObjectType[], sourceConfig: NitroConfig);
+    constructor(spec: HybridObjectSpec);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetHybridObjectCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    private getExternalCxxImportName;
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};

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.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 MapType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class NamedWrappingType<T extends Type> implements NamedType {
+    readonly type: T;
+    readonly name: string;
+    constructor(name: string, type: T);
+    get escapedName(): string;
+    get kind(): TypeKind;
+    get canBePassedByReference(): boolean;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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.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 NullType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

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.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 NumberType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

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

@@ -0,0 +1,13 @@
+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 OptionalType implements Type {
+    readonly wrappingType: Type;
+    constructor(wrappingType: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get needsBraces(): boolean;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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