nitrogen 0.2.23 → 0.29.4

package/lib/init.js

@@ -0,0 +1,123 @@
+import path from 'path';
+import { prettifyDirectory } from './prettifyDirectory.js';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { Logger } from './Logger.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { randomUUID } from 'crypto';
+export async function initNewNitroModule(baseDirectory, moduleName, ref = 'main') {
+    Logger.info(`⚙️  Creating new Nitro Module "${chalk.bold(moduleName)}" in ${chalk.underline(prettifyDirectory(baseDirectory))}...`);
+    const directory = path.join(baseDirectory, moduleName);
+    if (existsSync(directory)) {
+        Logger.error(`❌ A folder named "${chalk.underline(moduleName)}" already exists in the directory ${chalk.underline(prettifyDirectory(baseDirectory))}!`);
+        process.exit(1);
+    }
+    await fs.mkdir(directory);
+    const modulePath = await downloadGitHubFolder('mrousavy', 'nitro', ref, 'packages/template', directory);
+    Logger.info(`🏗️  Constructing template...`);
+    const cleanLibraryName = moduleName.replace('react-native-', '');
+    const cxxNamespace = cleanLibraryName.replaceAll('-', '');
+    let camelCaseName = cleanLibraryName
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+    if (!camelCaseName.startsWith('Nitro')) {
+        camelCaseName = 'Nitro' + camelCaseName;
+    }
+    await replaceTemplate(modulePath, `cxxNamespace`, cxxNamespace);
+    await replaceTemplate(modulePath, `androidNamespace`, cxxNamespace);
+    await replaceTemplate(modulePath, `androidCxxLibName`, camelCaseName);
+    await replaceTemplate(modulePath, `iosModuleName`, camelCaseName);
+    await replaceTemplate(modulePath, `packageName`, moduleName);
+    await replaceTemplate(modulePath, `packageDescription`, moduleName);
+    Logger.info(`🎉 Created Nitro Module "${chalk.bold(moduleName)}" in ${chalk.underline(prettifyDirectory(directory))}!`);
+    Logger.info(`👉 To install dependencies, use your package manager of choice (e.g. ${chalk.bold('npm install')})`);
+    Logger.info(`👉 To create your first Hybrid Object, add a ${chalk.underline(`*.nitro.ts`)} file, declare a TypeScript interface that extends ${chalk.bold('HybridObject<...>')}, and run ${chalk.bold('npx nitrogen')}.`);
+    Logger.info(`👉 To test your module in an app, create a new React Native app somewhere (e.g. in ${chalk.underline(`./${moduleName}/example`)}) and add ${chalk.bold(moduleName)} as a local dependency.`);
+}
+async function isGitInstalled() {
+    try {
+        execSync('git --version');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function downloadGitHubFolder(owner, repo, branch, folder, outputPath) {
+    if (!isGitInstalled()) {
+        console.error(`❌ ${chalk.bold('git')} is not installed or available in the current path! Make sure to install ${chalk.bold('git')} and try again.`);
+        process.exit(1);
+    }
+    const repoUrl = `https://github.com/${owner}/${repo}`;
+    Logger.info(`⏳ Cloning ${chalk.underline(repoUrl)}...`);
+    const tempPath = randomUUID();
+    const tempDir = path.join(outputPath, tempPath);
+    execSync(`git clone --depth 1 --filter=blob:none -b ${branch} --quiet --sparse ${repoUrl} ${tempDir}`);
+    const prettyOutputPath = prettifyDirectory(outputPath);
+    const initialDir = process.cwd();
+    try {
+        process.chdir(tempDir);
+        Logger.debug(`⏳ Checking out ${chalk.underline(folder)}...`);
+        execSync(`git sparse-checkout set ${folder}`);
+        Logger.debug(`📁 Copying files from ${chalk.underline(`${prettyOutputPath}/${tempPath}`)} to ${chalk.underline(prettyOutputPath)}...`);
+        const sourcePath = path.join(tempDir, folder);
+        await fs.mkdir(outputPath, { recursive: true });
+        await copyFolder(sourcePath, outputPath);
+        return outputPath;
+    }
+    finally {
+        // change dir back to original
+        process.chdir(initialDir);
+        Logger.debug(`🗑️  Removing temporary folder ${chalk.underline(prettifyDirectory(tempDir))}...`);
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function copyFolder(src, dest) {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await fs.mkdir(destPath, { recursive: true });
+            await copyFolder(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+async function replaceTemplate(dir, templateName, replacementValue) {
+    const replaceInFile = async (filePath) => {
+        const content = await fs.readFile(filePath, 'utf8');
+        const updatedContent = content.replaceAll(`$$${templateName}$$`, replacementValue);
+        if (content !== updatedContent) {
+            await fs.writeFile(filePath, updatedContent, 'utf8');
+        }
+    };
+    const replaceInName = (name) => {
+        return name.replaceAll(`$$${templateName}$$`, replacementValue);
+    };
+    const processDirectory = async (currentDir) => {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const oldPath = path.join(currentDir, entry.name);
+            const updatedName = replaceInName(entry.name);
+            const newPath = path.join(currentDir, updatedName);
+            if (oldPath !== newPath) {
+                await fs.rename(oldPath, newPath);
+            }
+            if (entry.isDirectory()) {
+                await processDirectory(newPath);
+            }
+            else if (entry.isFile()) {
+                await replaceInFile(newPath);
+            }
+        }
+    };
+    if (!existsSync(dir)) {
+        throw new Error(`The directory "${dir}" does not exist.`);
+    }
+    await processDirectory(dir);
+}

package/lib/nitrogen.d.ts

@@ -0,0 +1,11 @@
+interface NitrogenOptions {
+    baseDirectory: string;
+    outputDirectory: string;
+}
+interface NitrogenResult {
+    generatedFiles: string[];
+    targetSpecsCount: number;
+    generatedSpecsCount: number;
+}
+export declare function runNitrogen({ baseDirectory, outputDirectory, }: NitrogenOptions): Promise<NitrogenResult>;
+export {};

package/lib/nitrogen.js

@@ -0,0 +1,165 @@
+import { Project } from 'ts-morph';
+import { extendsHybridObject, isHybridView, getHybridObjectPlatforms, getHybridViewPlatforms, } from './getPlatformSpecs.js';
+import { generatePlatformFiles } from './createPlatformSpec.js';
+import path from 'path';
+import { prettifyDirectory } from './prettifyDirectory.js';
+import { capitalizeName, deduplicateFiles, errorToString, indent, NITROGEN_VERSION, } from './utils.js';
+import { writeFile } from './writeFile.js';
+import chalk from 'chalk';
+import { groupByPlatform } from './syntax/SourceFile.js';
+import { Logger } from './Logger.js';
+import { NitroConfig } from './config/NitroConfig.js';
+import { createIOSAutolinking } from './autolinking/createIOSAutolinking.js';
+import { createAndroidAutolinking } from './autolinking/createAndroidAutolinking.js';
+import { createGitAttributes } from './createGitAttributes.js';
+export async function runNitrogen({ baseDirectory, outputDirectory, }) {
+    let targetSpecs = 0;
+    let generatedSpecs = 0;
+    // Create the TS project
+    const project = new Project({
+        compilerOptions: {
+            strict: true,
+            strictNullChecks: true,
+            noUncheckedIndexedAccess: true,
+        },
+    });
+    const ignorePaths = NitroConfig.current.getIgnorePaths();
+    const globPattern = [path.join(baseDirectory, '**', '*.nitro.ts')];
+    ignorePaths.forEach((ignorePath) => {
+        globPattern.push('!' + path.join(baseDirectory, ignorePath));
+    });
+    project.addSourceFilesAtPaths(globPattern);
+    // Loop through all source files to log them
+    Logger.info(chalk.reset(`🚀  Nitrogen ${chalk.bold(NITROGEN_VERSION)} runs at ${chalk.underline(prettifyDirectory(baseDirectory))}`));
+    for (const dir of project.getDirectories()) {
+        const specs = dir.getSourceFiles().length;
+        const relativePath = prettifyDirectory(dir.getPath());
+        Logger.info(`    🔍  Nitrogen found ${specs} spec${specs === 1 ? '' : 's'} in ${chalk.underline(relativePath)}`);
+    }
+    // If no source files are found, we can exit
+    if (project.getSourceFiles().length === 0) {
+        const searchDir = prettifyDirectory(path.join(path.resolve(baseDirectory), '**', '*.nitro.ts'));
+        Logger.error(`❌  Nitrogen didn't find any spec files in ${chalk.underline(searchDir)}! ` +
+            `To create a Nitro Module, create a TypeScript file with the "${chalk.underline('.nitro.ts')}" suffix ` +
+            'and export an interface that extends HybridObject<T>.');
+        process.exit();
+    }
+    const usedPlatforms = [];
+    const filesAfter = [];
+    const writtenFiles = [];
+    for (const sourceFile of project.getSourceFiles()) {
+        Logger.info(`⏳  Parsing ${sourceFile.getBaseName()}...`);
+        const startedWithSpecs = generatedSpecs;
+        // Find all interfaceDeclarations in the given file
+        const declarations = [
+            ...sourceFile.getInterfaces(),
+            ...sourceFile.getTypeAliases(),
+        ];
+        for (const declaration of declarations) {
+            let typeName = declaration.getName();
+            try {
+                let platformSpec;
+                if (isHybridView(declaration.getType())) {
+                    // Hybrid View Props
+                    const targetPlatforms = getHybridViewPlatforms(declaration);
+                    if (targetPlatforms == null) {
+                        // It does not extend HybridView, continue..
+                        continue;
+                    }
+                    platformSpec = targetPlatforms;
+                }
+                else if (extendsHybridObject(declaration.getType(), true)) {
+                    // Hybrid View
+                    const targetPlatforms = getHybridObjectPlatforms(declaration);
+                    if (targetPlatforms == null) {
+                        // It does not extend HybridObject, continue..
+                        continue;
+                    }
+                    platformSpec = targetPlatforms;
+                }
+                else {
+                    continue;
+                }
+                const platforms = Object.keys(platformSpec);
+                if (platforms.length === 0) {
+                    Logger.warn(`⚠️   ${typeName} does not declare any platforms in HybridObject<T> - nothing can be generated.`);
+                    continue;
+                }
+                targetSpecs++;
+                Logger.info(`    ⚙️   Generating specs for HybridObject "${chalk.bold(typeName)}"...`);
+                // Create all files and throw it into a big list
+                let allFiles = platforms.flatMap((p) => {
+                    usedPlatforms.push(p);
+                    const language = platformSpec[p];
+                    const r = generatePlatformFiles(declaration.getType(), language);
+                    return r;
+                });
+                allFiles = deduplicateFiles(allFiles);
+                // Group the files by platform ({ ios: [], android: [], shared: [] })
+                const filesPerPlatform = groupByPlatform(allFiles);
+                // Loop through each platform one by one so that it has some kind of order (per-platform)
+                for (const [p, files] of Object.entries(filesPerPlatform)) {
+                    const platform = p;
+                    const language = platform === 'shared' ? 'c++' : platformSpec[platform];
+                    if (language == null) {
+                        // if the language was never specified in the spec, skip it
+                        continue;
+                    }
+                    if (files.length === 0) {
+                        // if no files exist on this platform, skip it
+                        continue;
+                    }
+                    Logger.info(`        ${chalk.dim(platform)}: Generating ${capitalizeName(language)} code...`);
+                    // Write the actual files for this specific platform.
+                    for (const file of files) {
+                        const basePath = path.join(outputDirectory, file.platform, file.language);
+                        const actualPath = await writeFile(basePath, file);
+                        filesAfter.push(actualPath);
+                        writtenFiles.push(file);
+                    }
+                }
+                // Done!
+                generatedSpecs++;
+            }
+            catch (error) {
+                const message = indent(errorToString(error), '    ');
+                Logger.error(chalk.redBright(`        ❌  Failed to generate spec for ${typeName}! ${message}`));
+                process.exitCode = 1;
+            }
+        }
+        if (generatedSpecs === startedWithSpecs) {
+            Logger.error(chalk.redBright(`    ❌  No specs found in ${sourceFile.getBaseName()}!`));
+        }
+    }
+    // Autolinking
+    Logger.info(`⛓️   Setting up build configs for autolinking...`);
+    const autolinkingFiles = [];
+    if (usedPlatforms.includes('ios')) {
+        autolinkingFiles.push(createIOSAutolinking());
+    }
+    if (usedPlatforms.includes('android')) {
+        autolinkingFiles.push(createAndroidAutolinking(writtenFiles));
+    }
+    for (const autolinking of autolinkingFiles) {
+        Logger.info(`    Creating autolinking build setup for ${chalk.dim(autolinking.platform)}...`);
+        for (const file of autolinking.sourceFiles) {
+            const basePath = path.join(outputDirectory, file.platform);
+            const actualPath = await writeFile(basePath, file);
+            filesAfter.push(actualPath);
+        }
+    }
+    try {
+        // write a .gitattributes file
+        const markAsGenerated = NitroConfig.current.getGitAttributesGeneratedFlag();
+        const file = await createGitAttributes(markAsGenerated, outputDirectory);
+        filesAfter.push(file);
+    }
+    catch {
+        Logger.error(`❌  Failed to write ${chalk.dim(`.gitattributes`)}!`);
+    }
+    return {
+        generatedFiles: filesAfter,
+        targetSpecsCount: targetSpecs,
+        generatedSpecsCount: generatedSpecs,
+    };
+}

package/lib/prettifyDirectory.d.ts

@@ -0,0 +1 @@
+export declare function prettifyDirectory(directory: string): string;

package/lib/prettifyDirectory.js

@@ -0,0 +1,27 @@
+import os from 'os';
+import path from 'path';
+export function prettifyDirectory(directory) {
+    let relativePath = path.relative(process.cwd(), path.resolve(directory));
+    if (!relativePath.startsWith('.') && relativePath.length > 0) {
+        // Make sure all relative paths start with "./something", not just "something"
+        relativePath = `./${relativePath}`;
+    }
+    const home = os.homedir();
+    const homeShorthand = os.platform() === 'win32' ? '$HOME' : '~';
+    const prettifiedHomeShorthand = directory.startsWith(home)
+        ? `${homeShorthand}${directory.slice(home.length)}`
+        : directory;
+    if (relativePath.length < 1) {
+        // If relativePath is ".", we don't want to return it
+        return prettifiedHomeShorthand;
+    }
+    if (relativePath.length > 0 &&
+        relativePath.length < prettifiedHomeShorthand.length) {
+        // If relativePath is shroter than the ~/... home path, we use the relative one.
+        return relativePath;
+    }
+    else {
+        // ..otherwise just use the ~/... home relative path.
+        return prettifiedHomeShorthand;
+    }
+}

package/lib/syntax/BridgedType.d.ts

@@ -0,0 +1,41 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from './SourceFile.js';
+import type { Type } from './types/Type.js';
+export interface BridgedType<FromLanguage extends Language, ToLanguage extends Language> {
+    /**
+     * The underlying type that is being bridged between {@linkcode FromLanguage} and {@linkcode ToLanguage}
+     */
+    readonly type: Type;
+    /**
+     * Whether the underlying type has a valid type (is not void or null)
+     */
+    readonly hasType: boolean;
+    /**
+     * Whether this type can be passed by reference
+     */
+    readonly canBePassedByReference: boolean;
+    /**
+     * Whether this bridged type needs special handling, or can just be used as-is
+     */
+    readonly needsSpecialHandling: boolean;
+    /**
+     * Get all imports required for this bridge to work
+     */
+    getRequiredImports(language: Language): SourceImport[];
+    /**
+     * Get all extra files that need to be created for this type, as well as the bridge.
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get the code for the type itself in the given language
+     */
+    getTypeCode(language: FromLanguage | ToLanguage): string;
+    /**
+     * Parse the given parameter from the source language to the given target language, in the given language.
+     * For example, to convert an ArrayBuffer from Swift ({@linkcode from}) to C++ ({@linkcode to}) we
+     * have to wrap it in an ArrayBufferHolder in Swift ({@linkcode inLanguage}), and unwrap
+     * it from the ArrayBufferHolder again in C++ ({@linkcode inLanguage})
+     */
+    parse(parameterName: string, from: FromLanguage, to: ToLanguage, inLanguage: FromLanguage | ToLanguage): string;
+    parse(parameterName: string, from: ToLanguage, to: FromLanguage, inLanguage: FromLanguage | ToLanguage): string;
+}

package/lib/syntax/BridgedType.js

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

package/lib/syntax/CodeNode.d.ts

@@ -0,0 +1,23 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from './SourceFile.js';
+export interface CodeNode {
+    /**
+     * Get the code of this code node (e.g. property, method) in the given language.
+     */
+    getCode(language: Language): string;
+    /**
+     * Get all extra definition files this code node needs (e.g. extra type/struct declarations
+     * for complex types), or `[]` if none are required (e.g. if this uses primitive types only)
+     *
+     * All files returned here must be created in the project.
+     * To include them, see {@linkcode getRequiredImports | getRequiredImports()}
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get all required imports this code node needs (e.g. extra type/struct declarations for complex types),
+     * or `[]` if no imports are required (e.g. if this uses primitive types only).
+     *
+     * All imports returned here must be included in the current file (e.g. `#include "..."` or `import ...`)
+     */
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/CodeNode.js

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

package/lib/syntax/HybridObjectSpec.d.ts

@@ -0,0 +1,13 @@
+import type { NitroConfig } from '../config/NitroConfig.js';
+import type { Language } from '../getPlatformSpecs.js';
+import type { Method } from './Method.js';
+import type { Property } from './Property.js';
+export interface HybridObjectSpec {
+    name: string;
+    language: Language;
+    properties: Property[];
+    methods: Method[];
+    baseTypes: HybridObjectSpec[];
+    isHybridView: boolean;
+    config: NitroConfig;
+}

package/lib/syntax/HybridObjectSpec.js

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

package/lib/syntax/Method.d.ts

@@ -0,0 +1,41 @@
+import type { CodeNode } from './CodeNode.js';
+import type { Language } from '../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from './SourceFile.js';
+import { Parameter } from './Parameter.js';
+import type { Type } from './types/Type.js';
+export type MethodBody = string;
+export interface MethodModifiers {
+    /**
+     * The name of the class that defines this C++ method.
+     * Example: `Person` -> `void Person::sayHi()`
+     */
+    classDefinitionName?: string;
+    /**
+     * Whether the function should be marked as inlineable.
+     */
+    inline?: boolean;
+    virtual?: boolean;
+    /**
+     * Whether the function is marked as `noexcept` (doesn't throw) or not.
+     */
+    noexcept?: boolean;
+    /**
+     * Whether this function overrides a base/super function.
+     */
+    override?: boolean;
+    /**
+     * Whether this method has a `@DoNotStrip` and `@Keep` attribute to avoid
+     * it from being stripped from the binary by the Java compiler or ProGuard.
+     */
+    doNotStrip?: boolean;
+}
+export declare class Method implements CodeNode {
+    readonly name: string;
+    readonly returnType: Type;
+    readonly parameters: Parameter[];
+    constructor(name: string, returnType: Type, parameters: Parameter[]);
+    get jsSignature(): string;
+    getCode(language: Language, modifiers?: MethodModifiers, body?: MethodBody): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/Method.js

@@ -0,0 +1,108 @@
+import {} from './SourceFile.js';
+import { Parameter } from './Parameter.js';
+import { indent } from '../utils.js';
+export class Method {
+    name;
+    returnType;
+    parameters;
+    constructor(name, returnType, parameters) {
+        this.name = name;
+        this.returnType = returnType;
+        this.parameters = parameters;
+        if (this.name.startsWith('__')) {
+            throw new Error(`Method names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`);
+        }
+    }
+    get jsSignature() {
+        const returnType = this.returnType.kind;
+        const params = this.parameters.map((p) => `${p.name}: ${p.type.kind}`);
+        return `${this.name}(${params.join(', ')}): ${returnType}`;
+    }
+    getCode(language, modifiers, body) {
+        body = body?.trim();
+        switch (language) {
+            case 'c++': {
+                const returnType = this.returnType.getCode('c++');
+                const params = this.parameters.map((p) => p.getCode('c++'));
+                // C++ modifiers start in the beginning
+                const name = modifiers?.classDefinitionName
+                    ? `${modifiers.classDefinitionName}::${this.name}`
+                    : this.name;
+                let signature = `${returnType} ${name}(${params.join(', ')})`;
+                if (modifiers?.inline)
+                    signature = `inline ${signature}`;
+                if (modifiers?.virtual)
+                    signature = `virtual ${signature}`;
+                if (modifiers?.noexcept)
+                    signature = `${signature} noexcept`;
+                if (modifiers?.override)
+                    signature = `${signature} override`;
+                if (body == null) {
+                    // It's a function declaration (no body)
+                    if (modifiers?.virtual) {
+                        // if it is a virtual function, we have no implementation (= 0)
+                        signature = `${signature} = 0`;
+                    }
+                    return `${signature};`;
+                }
+                else {
+                    return `
+${signature} {
+  ${indent(body, '  ')}
+}`.trim();
+                }
+            }
+            case 'swift': {
+                const params = this.parameters.map((p) => p.getCode('swift'));
+                const returnType = this.returnType.getCode('swift');
+                let signature = `func ${this.name}(${params.join(', ')}) throws -> ${returnType}`;
+                if (modifiers?.inline)
+                    signature = `@inline(__always)\n${signature}`;
+                if (body == null) {
+                    return signature;
+                }
+                else {
+                    return `
+${signature} {
+  ${indent(body, '  ')}
+}`.trim();
+                }
+            }
+            case 'kotlin': {
+                const params = this.parameters.map((p) => p.getCode('kotlin'));
+                const returnType = this.returnType.getCode('kotlin');
+                let signature = `fun ${this.name}(${params.join(', ')}): ${returnType}`;
+                if (modifiers?.inline)
+                    signature = `inline ${signature}`;
+                if (modifiers?.override)
+                    signature = `override ${signature}`;
+                if (modifiers?.virtual)
+                    signature = `abstract ${signature}`;
+                if (modifiers?.doNotStrip)
+                    signature = `@DoNotStrip\n@Keep\n${signature}`;
+                if (body == null) {
+                    return signature;
+                }
+                else {
+                    return `
+${signature} {
+  ${indent(body, '  ')}
+}
+          `.trim();
+                }
+            }
+            default:
+                throw new Error(`Language ${language} is not yet supported for property getters!`);
+        }
+    }
+    getExtraFiles() {
+        const returnTypeExtraFiles = this.returnType.getExtraFiles();
+        const paramsExtraFiles = this.parameters.flatMap((p) => p.getExtraFiles());
+        return [...returnTypeExtraFiles, ...paramsExtraFiles];
+    }
+    getRequiredImports(language) {
+        const returnTypeFiles = this.returnType.getRequiredImports(language);
+        const paramsImports = this.parameters.flatMap((p) => p.getRequiredImports(language));
+        return [...returnTypeFiles, ...paramsImports];
+    }
+}

package/lib/syntax/Parameter.d.ts

@@ -0,0 +1,15 @@
+import type { ParameterDeclaration } from 'ts-morph';
+import type { CodeNode } from './CodeNode.js';
+import type { Language } from '../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from './SourceFile.js';
+import type { NamedType, Type } from './types/Type.js';
+export declare class Parameter implements CodeNode {
+    readonly type: NamedType;
+    constructor(name: string, type: Type);
+    constructor(parameter: ParameterDeclaration, language: Language);
+    get jsSignature(): string;
+    get name(): string;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/Parameter.js

@@ -0,0 +1,65 @@
+import { escapeCppName, toReferenceType } from './helpers.js';
+import {} from './SourceFile.js';
+import { NamedWrappingType } from './types/NamedWrappingType.js';
+import { createNamedType } from './createType.js';
+export class Parameter {
+    type;
+    constructor(...args) {
+        if (typeof args[0] === 'string' && typeof args[1] === 'object') {
+            // constructor(...) #1
+            if (args.length !== 2)
+                throw new Error(`Missing arguments for new Parameter(...) overload #1!`);
+            const [name, type] = args;
+            this.type = new NamedWrappingType(name, type);
+        }
+        else if (typeof args[0] === 'object' && typeof args[1] === 'string') {
+            // constructor(...) #2
+            const [param, language] = args;
+            const name = param.getSymbolOrThrow().getEscapedName();
+            const type = param.getType();
+            const isOptional = param.hasQuestionToken() || param.isOptional() || type.isNullable();
+            this.type = createNamedType(language, name, type, isOptional);
+        }
+        else {
+            // constructor(...)???
+            throw new Error(`Invalid constructor! Arguments: ${args}`);
+        }
+        if (this.type.name.startsWith('__')) {
+            throw new Error(`Parameter names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`);
+        }
+    }
+    get jsSignature() {
+        return `${this.type.name}: ${this.type.kind}`;
+    }
+    get name() {
+        return this.type.name;
+    }
+    getCode(language) {
+        const name = escapeCppName(this.name);
+        switch (language) {
+            case 'c++':
+                let cppType = this.type.getCode('c++');
+                if (this.type.canBePassedByReference) {
+                    // T -> const T&
+                    cppType = toReferenceType(cppType);
+                }
+                return `${cppType} ${name}`;
+            case 'swift':
+                let flags = '';
+                if (this.type.kind === 'function') {
+                    flags = '@escaping ';
+                }
+                return `${name}: ${flags + this.type.getCode('swift')}`;
+            case 'kotlin':
+                return `${name}: ${this.type.getCode('kotlin')}`;
+            default:
+                throw new Error(`Language ${language} is not yet supported for parameters!`);
+        }
+    }
+    getExtraFiles() {
+        return this.type.getExtraFiles();
+    }
+    getRequiredImports(language) {
+        return this.type.getRequiredImports(language);
+    }
+}