nitrogen 0.2.23 → 0.29.4

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.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 RecordType implements Type {
+    readonly keyType: Type;
+    readonly valueType: Type;
+    constructor(keyType: Type, valueType: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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.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 ResultWrappingType implements Type {
+    readonly result: Type;
+    readonly error: Type;
+    constructor(result: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type FileWithReferencedTypes, type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class StructType implements Type {
+    readonly structName: string;
+    readonly properties: NamedType[];
+    readonly declarationFile: FileWithReferencedTypes;
+    constructor(structName: string, properties: NamedType[]);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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.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 TupleType implements Type {
+    readonly itemTypes: Type[];
+    constructor(itemTypes: Type[]);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

@@ -0,0 +1,55 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+export type TypeKind = 'array-buffer' | 'array' | 'bigint' | 'boolean' | 'custom-type' | 'enum' | 'error' | 'function' | 'hybrid-object' | 'hybrid-object-base' | 'map' | 'null' | 'number' | 'optional' | 'promise' | 'record' | 'string' | 'struct' | 'tuple' | 'variant' | 'result-wrapper' | 'date' | 'void';
+export interface GetCodeOptions {
+    /**
+     * Specifies whether the name (e.g. a C++ class name)
+     * should use the fully qualified namespace name prefix.
+     */
+    fullyQualified?: boolean;
+}
+/**
+ * Represents a TypeScript Type that can be represented in a native language (C++, Swift, Kotlin)
+ */
+export interface Type {
+    /**
+     * Get whether this type can be passed by reference in C++ (`const T&` vs `T`)
+     */
+    readonly canBePassedByReference: boolean;
+    /**
+     * Get the kind of the type.
+     */
+    readonly kind: TypeKind;
+    /**
+     * Get the native code required to represent this type for the given language (C++, Swift, Kotlin).
+     *
+     * E.g. for a `number` type, this would return `'double'` in C++.
+     *
+     * The `options` parameter can specify custom options. Subclasses may have more options.
+     */
+    getCode(language: Language, options?: GetCodeOptions): string;
+    /**
+     * Get all required extra files that need to be **created** for this type to properly work.
+     *
+     * E.g. for `type Gender = 'male' | 'female'`, the enum `Gender` needs to be created first (as a separate file).
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get all required extra imports that need to be **imported** for this type to properly work.
+     */
+    getRequiredImports(language: Language): SourceImport[];
+}
+export interface NamedType extends Type {
+    /**
+     * Get the name of the value if it is a member or parameter.
+     *
+     * E.g. for a class member `double _something`, this returns `'_something'`.
+     */
+    readonly name: string;
+    /**
+     * Get the name of the value escaped as a valid C++ variable name.
+     *
+     * E.g. for a class member `double some-value`, this returns `'some_value'`.
+     */
+    readonly escapedName: string;
+}

package/lib/syntax/types/Type.js

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

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

@@ -0,0 +1,19 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare const VariantLabels: readonly ["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eigth", "ninth", "tenth"];
+type VariantLabel = (typeof VariantLabels)[number];
+export declare class VariantType implements Type {
+    readonly variants: Type[];
+    readonly aliasName?: string;
+    constructor(variants: Type[], aliasName?: string);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get jsType(): string;
+    get cases(): [VariantLabel, Type][];
+    getAliasName(language: Language, options?: GetCodeOptions): string;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};

package/lib/syntax/types/VariantType.js

@@ -0,0 +1,75 @@
+import { escapeCppName, isNotDuplicate } from '../helpers.js';
+import {} from '../SourceFile.js';
+export const VariantLabels = [
+    'first',
+    'second',
+    'third',
+    'fourth',
+    'fifth',
+    'sixth',
+    'seventh',
+    'eigth',
+    'ninth',
+    'tenth',
+];
+export class VariantType {
+    variants;
+    aliasName;
+    constructor(variants, aliasName) {
+        this.variants = variants;
+        this.aliasName = aliasName;
+    }
+    get canBePassedByReference() {
+        // It's a variant<..> - heavy to copy
+        return true;
+    }
+    get kind() {
+        return 'variant';
+    }
+    get jsType() {
+        return this.variants.map((v) => v.kind).join(' | ');
+    }
+    get cases() {
+        return this.variants.map((v, i) => {
+            const label = VariantLabels[i];
+            if (label == null)
+                throw new Error(`Variant<...> (\`${this.jsType}\`) does not support ${i} cases!`);
+            return [label, v];
+        });
+    }
+    getAliasName(language, options) {
+        if (this.aliasName == null) {
+            const variants = this.variants.map((v) => v.getCode(language, options));
+            return escapeCppName(`Variant_${variants.join('_')}`);
+        }
+        return this.aliasName;
+    }
+    getCode(language, options) {
+        const types = this.variants
+            .map((v) => v.getCode(language, options))
+            .filter(isNotDuplicate);
+        switch (language) {
+            case 'c++':
+                return `std::variant<${types.join(', ')}>`;
+            case 'swift':
+            case 'kotlin':
+                return this.getAliasName(language, options);
+            default:
+                throw new Error(`Language ${language} is not yet supported for VariantType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.variants.flatMap((v) => v.getExtraFiles());
+    }
+    getRequiredImports(language) {
+        const imports = this.variants.flatMap((v) => v.getRequiredImports(language));
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'variant',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

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

package/lib/syntax/types/VoidType.js

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

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

@@ -0,0 +1,2 @@
+import type { Type } from './Type.js';
+export declare function getTypeAs<T>(type: Type, classReference: new (...args: any[]) => T): T;

package/lib/syntax/types/getTypeAs.js

@@ -0,0 +1,12 @@
+import { NamedWrappingType } from './NamedWrappingType.js';
+export function getTypeAs(type, classReference) {
+    if (type instanceof classReference) {
+        return type;
+    }
+    else if (type instanceof NamedWrappingType) {
+        return getTypeAs(type.type, classReference);
+    }
+    else {
+        throw new Error(`Type of kind "${type.kind}" is not a ${classReference}!`);
+    }
+}

package/lib/utils.d.ts

@@ -0,0 +1,22 @@
+import type { SourceFile } from './syntax/SourceFile.js';
+import type { SwiftCxxHelper } from './syntax/swift/SwiftCxxTypeHelper.js';
+import type { Type } from 'ts-morph';
+import { NitroConfig } from './config/NitroConfig.js';
+export declare const NITROGEN_VERSION: string;
+export declare function capitalizeName(name: string): string;
+export declare function createIndentation(spacesCount: number): string;
+export declare function indent(string: string, spacesCount: number): string;
+export declare function indent(string: string, indentation: string): string;
+export declare function errorToString(error: unknown): string;
+export declare function escapeComments(string: string): string;
+export declare function toUnixPath(p: string): string;
+export declare function unsafeFastJoin(...segments: string[]): string;
+/**
+ * Deduplicates all files via their full path.
+ * If content differs, you are f*cked.
+ */
+export declare function deduplicateFiles(files: SourceFile[]): SourceFile[];
+export declare function filterDuplicateHelperBridges(bridge: SwiftCxxHelper, i: number, array: SwiftCxxHelper[]): boolean;
+export declare function toLowerCamelCase(string: string): string;
+export declare function getBaseTypes(type: Type): Type[];
+export declare function getHybridObjectNitroModuleConfig(type: Type): NitroConfig | undefined;