nitrogen 0.2.23 → 0.29.4

package/lib/autolinking/ios/createHybridObjectInitializer.js

@@ -0,0 +1,97 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { createCppHybridObjectRegistration } from '../../syntax/c++/CppHybridObjectRegistration.js';
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js';
+import { createFileMetadataString } from '../../syntax/helpers.js';
+import { createSwiftHybridObjectRegistration } from '../../syntax/swift/SwiftHybridObjectRegistration.js';
+import { indent } from '../../utils.js';
+import { getUmbrellaHeaderName } from './createSwiftUmbrellaHeader.js';
+export function createHybridObjectIntializer() {
+    const autolinkingClassName = `${NitroConfig.current.getIosModuleName()}Autolinking`;
+    const umbrellaHeaderName = getUmbrellaHeaderName();
+    const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('swift');
+    const autolinkedHybridObjects = NitroConfig.current.getAutolinkedHybridObjects();
+    const swiftFunctions = [];
+    const cppRegistrations = [];
+    const cppImports = [];
+    let containsSwiftObjects = false;
+    for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
+        const config = autolinkedHybridObjects[hybridObjectName];
+        if (config?.cpp != null) {
+            // Autolink a C++ HybridObject!
+            const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+                hybridObjectName: hybridObjectName,
+                cppClassName: config.cpp,
+            });
+            cppImports.push(...requiredImports);
+            cppRegistrations.push(cppCode);
+        }
+        if (config?.swift != null) {
+            // Autolink a Swift HybridObject!
+            containsSwiftObjects = true;
+            const { cppCode, requiredImports, swiftFunction } = createSwiftHybridObjectRegistration({
+                hybridObjectName: hybridObjectName,
+                swiftClassName: config.swift,
+            });
+            cppImports.push(...requiredImports);
+            cppRegistrations.push(cppCode);
+            swiftFunctions.push(swiftFunction);
+        }
+    }
+    if (cppRegistrations.length === 0) {
+        // Nothing to autolink!
+        return [];
+    }
+    const umbrellaImport = containsSwiftObjects
+        ? `#import "${umbrellaHeaderName}"`
+        : '';
+    const imports = cppImports.map((i) => includeHeader(i, true)).join('\n');
+    const objcCode = `
+${createFileMetadataString(`${autolinkingClassName}.mm`)}
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+${umbrellaImport}
+#import <type_traits>
+
+${imports}
+
+@interface ${autolinkingClassName} : NSObject
+@end
+
+@implementation ${autolinkingClassName}
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace ${NitroConfig.current.getCxxNamespace('c++')};
+
+  ${indent(cppRegistrations.join('\n'), '  ')}
+}
+
+@end
+  `.trim();
+    const swiftCode = `
+${createFileMetadataString(`${autolinkingClassName}.swift`)}
+
+public final class ${autolinkingClassName} {
+  public typealias bridge = ${bridgeNamespace}
+
+  ${indent(swiftFunctions.join('\n\n'), '  ')}
+}
+  `.trim();
+    return [
+        {
+            content: objcCode,
+            language: 'objective-c++',
+            name: `${autolinkingClassName}.mm`,
+            platform: 'ios',
+            subdirectory: [],
+        },
+        {
+            content: swiftCode,
+            language: 'swift',
+            name: `${autolinkingClassName}.swift`,
+            platform: 'ios',
+            subdirectory: [],
+        },
+    ];
+}

package/lib/autolinking/ios/createPodspecRubyExtension.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface RubyFile extends Omit<SourceFile, 'language'> {
+    language: 'ruby';
+}
+export declare function createPodspecRubyExtension(): RubyFile;

package/lib/autolinking/ios/createPodspecRubyExtension.js

@@ -0,0 +1,69 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { createFileMetadataString } from '../../syntax/helpers.js';
+export function createPodspecRubyExtension() {
+    const name = NitroConfig.current.getIosModuleName();
+    const code = `
+${createFileMetadataString(`${name}+autolinking.rb`, '#')}
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# \`\`\`ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/${name}+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# \`\`\`
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 ${name} is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/${name}-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+  })
+end
+  `.trim();
+    return {
+        content: code,
+        language: 'ruby',
+        name: `${name}+autolinking.rb`,
+        platform: 'ios',
+        subdirectory: [],
+    };
+}

package/lib/autolinking/ios/createSwiftCxxBridge.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function createSwiftCxxBridge(): SourceFile[];

package/lib/autolinking/ios/createSwiftCxxBridge.js

@@ -0,0 +1,117 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js';
+import { getAllKnownTypes } from '../../syntax/createType.js';
+import { createFileMetadataString, isNotDuplicate, } from '../../syntax/helpers.js';
+import { getReferencedTypes } from '../../syntax/getReferencedTypes.js';
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js';
+import { filterDuplicateHelperBridges, indent } from '../../utils.js';
+import { getTypeAs } from '../../syntax/types/getTypeAs.js';
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js';
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js';
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js';
+export function createSwiftCxxBridge() {
+    const bridgeName = NitroConfig.current.getSwiftBridgeHeaderName();
+    const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('c++');
+    const types = getAllKnownTypes('swift').map((t) => new SwiftCxxBridgedType(t));
+    const bridges = types
+        .flatMap((t) => {
+        const referenced = getReferencedTypes(t.type);
+        return referenced.map((r) => {
+            const bridge = new SwiftCxxBridgedType(r);
+            return bridge.getRequiredBridge();
+        });
+    })
+        .filter((b) => b != null)
+        .flatMap((b) => [b, ...b?.dependencies])
+        .filter(filterDuplicateHelperBridges);
+    const headerHelperFunctions = bridges
+        .map((b) => `// pragma MARK: ${b.cxxType}\n${b.cxxHeader.code}`)
+        .filter(isNotDuplicate)
+        .join('\n\n');
+    const implementationHelperFunctions = bridges
+        .map((b) => {
+        if (b.cxxImplementation == null)
+            return undefined;
+        else
+            return `// pragma MARK: ${b.cxxType}\n${b.cxxImplementation.code}`;
+    })
+        .filter((c) => c != null)
+        .filter(isNotDuplicate)
+        .join('\n\n');
+    const requiredImportsHeader = bridges.flatMap((b) => b.cxxHeader.requiredIncludes);
+    const includesHeader = requiredImportsHeader
+        .map((i) => includeHeader(i, true))
+        .filter(isNotDuplicate);
+    const forwardDeclarationsHeader = requiredImportsHeader
+        .map((i) => i.forwardDeclaration)
+        .filter((f) => f != null)
+        .filter(isNotDuplicate);
+    const includesImplementation = bridges
+        .flatMap((b) => b.cxxImplementation?.requiredIncludes)
+        .filter((i) => i != null)
+        .map((i) => includeHeader(i, true))
+        .filter(isNotDuplicate);
+    const forwardDeclaredSwiftTypes = types
+        .filter((t) => t.type.kind === 'hybrid-object')
+        .map((t) => {
+        const hybridObject = getTypeAs(t.type, HybridObjectType);
+        const hybridObjectModuleName = hybridObject.sourceConfig.getIosModuleName();
+        const { HybridTSpecCxx } = getHybridObjectName(hybridObject.hybridObjectName);
+        return getForwardDeclaration('class', HybridTSpecCxx, hybridObjectModuleName);
+    })
+        .filter(isNotDuplicate);
+    const header = `
+${createFileMetadataString(`${bridgeName}.hpp`)}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarationsHeader.sort().join('\n')}
+
+// Forward declarations of Swift defined types
+${forwardDeclaredSwiftTypes.sort().join('\n')}
+
+// Include C++ defined types
+${includesHeader.sort().join('\n')}
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace ${bridgeNamespace} {
+
+  ${indent(headerHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`;
+    const source = `
+${createFileMetadataString(`${bridgeName}.cpp`)}
+
+#include "${bridgeName}.hpp"
+
+// Include C++ implementation defined types
+${includesImplementation.sort().join('\n')}
+
+namespace ${bridgeNamespace} {
+
+  ${indent(implementationHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`;
+    const files = [];
+    files.push({
+        content: header,
+        language: 'c++',
+        name: `${bridgeName}.hpp`,
+        platform: 'ios',
+        subdirectory: [],
+    });
+    files.push({
+        content: source,
+        language: 'c++',
+        name: `${bridgeName}.cpp`,
+        platform: 'ios',
+        subdirectory: [],
+    });
+    return files;
+}

package/lib/autolinking/ios/createSwiftUmbrellaHeader.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function getUmbrellaHeaderName(): string;
+export declare function createSwiftUmbrellaHeader(): SourceFile;

package/lib/autolinking/ios/createSwiftUmbrellaHeader.js

@@ -0,0 +1,74 @@
+import { NitroConfig } from '../../config/NitroConfig.js';
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js';
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js';
+import { getAllKnownTypes } from '../../syntax/createType.js';
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js';
+import { createFileMetadataString, isNotDuplicate, } from '../../syntax/helpers.js';
+import { getTypeAs } from '../../syntax/types/getTypeAs.js';
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js';
+export function getUmbrellaHeaderName() {
+    const moduleName = NitroConfig.current.getIosModuleName();
+    return `${moduleName}-Swift-Cxx-Umbrella.hpp`;
+}
+export function createSwiftUmbrellaHeader() {
+    const moduleName = NitroConfig.current.getIosModuleName();
+    const filename = getUmbrellaHeaderName();
+    const types = getAllKnownTypes('swift');
+    const swiftForwardDeclares = types
+        .filter((t) => t.kind === 'hybrid-object')
+        .map((t) => {
+        const hybridObjectType = getTypeAs(t, HybridObjectType);
+        const hybridObjectModuleName = hybridObjectType.sourceConfig.getIosModuleName();
+        const name = getHybridObjectName(hybridObjectType.hybridObjectName);
+        return getForwardDeclaration('class', name.HybridTSpecCxx, hybridObjectModuleName);
+    })
+        .filter(isNotDuplicate);
+    const imports = types.flatMap((t) => t.getRequiredImports('c++'));
+    const forwardDeclarations = imports
+        .map((i) => i.forwardDeclaration)
+        .filter((f) => f != null)
+        .filter(isNotDuplicate);
+    const includes = imports.map((i) => includeHeader(i)).filter(isNotDuplicate);
+    const code = `
+${createFileMetadataString(filename, '///')}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarations.sort().join('\n')}
+
+// Include C++ defined types
+${includes.sort().join('\n')}
+
+// C++ helpers for Swift
+#include "${moduleName}-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+${swiftForwardDeclares.sort().join('\n')}
+
+// Include Swift defined types
+#if __has_include("${moduleName}-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "${moduleName}".
+#include "${moduleName}-Swift.h"
+// Same as above, but used when building with frameworks (\`use_frameworks\`)
+#elif __has_include(<${moduleName}/${moduleName}-Swift.h>)
+#include <${moduleName}/${moduleName}-Swift.h>
+#else
+#error ${moduleName}'s autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "${moduleName}", and try building the app first.
+#endif
+`;
+    return {
+        content: code,
+        language: 'c++',
+        name: filename,
+        platform: 'ios',
+        subdirectory: [],
+    };
+}

package/lib/config/NitroConfig.d.ts

@@ -0,0 +1,52 @@
+import type { NitroUserConfig } from './NitroUserConfig.js';
+/**
+ * Represents the properly parsed `nitro.json` config of the current executing directory.
+ */
+export declare class NitroConfig {
+    private readonly config;
+    private static singleton;
+    constructor(config: NitroUserConfig);
+    static get current(): NitroConfig;
+    /**
+     * Returns the name of the Android C++ library (aka name in CMakeLists.txt `add_library(..)`).
+     * This will be loaded via `System.loadLibrary(...)`.
+     * @example `NitroTest`
+     */
+    getAndroidCxxLibName(): string;
+    /**
+     * Returns the iOS module name (aka Pod name) of the module that will be generated.
+     * @example `NitroTest`
+     */
+    getIosModuleName(): string;
+    /**
+     * Represents the C++ namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `margelo::nitro`.
+     * @example `['image']` -> `margelo::nitro::image`
+     */
+    getCxxNamespace(language: 'c++' | 'swift', ...subDefinitionName: string[]): string;
+    /**
+     * Represents the Android namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `com.margelo.nitro`.
+     * @example `['image']` -> `com.margelo.nitro.image`
+     */
+    getAndroidPackage(language: 'java/kotlin' | 'c++/jni', ...subPackage: string[]): string;
+    /**
+     * Return the directory of the android package, and a given sub-package.
+     * This will be used on android to put files from a package in their respective package folder.
+     */
+    getAndroidPackageDirectory(...subPackage: string[]): string[];
+    /**
+     * Get the autolinking configuration of all HybridObjects.
+     * Those will be generated and default-constructed.
+     */
+    getAutolinkedHybridObjects(): NitroUserConfig['autolinking'];
+    /**
+     * Get the paths that will be ignored when loading the TypeScript project.
+     * In most cases, this just contains `node_modules/`.
+     */
+    getIgnorePaths(): string[];
+    getGitAttributesGeneratedFlag(): boolean;
+    get isExternalConfig(): boolean;
+    getSwiftBridgeHeaderName(): string;
+    getSwiftBridgeNamespace(language: 'c++' | 'swift'): string;
+}

package/lib/config/NitroConfig.js

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import { readUserConfig } from './getConfig.js';
+const CXX_BASE_NAMESPACE = ['margelo', 'nitro'];
+const ANDROID_BASE_NAMESPACE = ['com', 'margelo', 'nitro'];
+/**
+ * Represents the properly parsed `nitro.json` config of the current executing directory.
+ */
+export class NitroConfig {
+    config;
+    static singleton;
+    constructor(config) {
+        this.config = config;
+    }
+    static get current() {
+        if (this.singleton == null) {
+            console.log(chalk.reset(`🔧  Loading ${chalk.underline('nitro.json')} config...`));
+            const defaultConfigPath = './nitro.json';
+            const config = readUserConfig(defaultConfigPath);
+            this.singleton = new NitroConfig(config);
+        }
+        return this.singleton;
+    }
+    /**
+     * Returns the name of the Android C++ library (aka name in CMakeLists.txt `add_library(..)`).
+     * This will be loaded via `System.loadLibrary(...)`.
+     * @example `NitroTest`
+     */
+    getAndroidCxxLibName() {
+        return this.config.android.androidCxxLibName;
+    }
+    /**
+     * Returns the iOS module name (aka Pod name) of the module that will be generated.
+     * @example `NitroTest`
+     */
+    getIosModuleName() {
+        return this.config.ios.iosModuleName;
+    }
+    /**
+     * Represents the C++ namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `margelo::nitro`.
+     * @example `['image']` -> `margelo::nitro::image`
+     */
+    getCxxNamespace(language, ...subDefinitionName) {
+        const userNamespace = this.config.cxxNamespace;
+        const namespace = [
+            ...CXX_BASE_NAMESPACE,
+            ...userNamespace,
+            ...subDefinitionName,
+        ];
+        switch (language) {
+            case 'c++':
+                return namespace.join('::');
+            case 'swift':
+                return namespace.join('.');
+            default:
+                throw new Error(`Invalid language for getCxxNamespace: ${language}`);
+        }
+    }
+    /**
+     * Represents the Android namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `com.margelo.nitro`.
+     * @example `['image']` -> `com.margelo.nitro.image`
+     */
+    getAndroidPackage(language, ...subPackage) {
+        const userPackage = this.config.android.androidNamespace;
+        const namespace = [...ANDROID_BASE_NAMESPACE, ...userPackage, ...subPackage];
+        switch (language) {
+            case 'java/kotlin':
+                return namespace.join('.');
+            case 'c++/jni':
+                return namespace.join('/');
+            default:
+                throw new Error(`Invalid language for getAndroidPackage: ${language}`);
+        }
+    }
+    /**
+     * Return the directory of the android package, and a given sub-package.
+     * This will be used on android to put files from a package in their respective package folder.
+     */
+    getAndroidPackageDirectory(...subPackage) {
+        const userPackage = this.config.android.androidNamespace;
+        return [...ANDROID_BASE_NAMESPACE, ...userPackage, ...subPackage];
+    }
+    /**
+     * Get the autolinking configuration of all HybridObjects.
+     * Those will be generated and default-constructed.
+     */
+    getAutolinkedHybridObjects() {
+        return this.config.autolinking;
+    }
+    /**
+     * Get the paths that will be ignored when loading the TypeScript project.
+     * In most cases, this just contains `node_modules/`.
+     */
+    getIgnorePaths() {
+        return this.config.ignorePaths ?? [];
+    }
+    getGitAttributesGeneratedFlag() {
+        return this.config.gitAttributesGeneratedFlag ?? false;
+    }
+    get isExternalConfig() {
+        // If the C++ namespaces are NOT equal, we are an external config.
+        return (this.getCxxNamespace('c++') !== NitroConfig.current.getCxxNamespace('c++'));
+    }
+    getSwiftBridgeHeaderName() {
+        const moduleName = this.getIosModuleName();
+        return `${moduleName}-Swift-Cxx-Bridge`;
+    }
+    getSwiftBridgeNamespace(language) {
+        return this.getCxxNamespace(language, 'bridge', 'swift');
+    }
+}

package/lib/config/NitroUserConfig.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const NitroUserConfigSchema: z.ZodObject<{
+    cxxNamespace: z.ZodArray<z.ZodString>;
+    ios: z.ZodObject<{
+        iosModuleName: z.ZodString;
+    }, z.core.$strip>;
+    android: z.ZodObject<{
+        androidNamespace: z.ZodArray<z.ZodString>;
+        androidCxxLibName: z.ZodString;
+    }, z.core.$strip>;
+    autolinking: z.ZodRecord<z.ZodString, z.ZodObject<{
+        cpp: z.ZodOptional<z.ZodString>;
+        swift: z.ZodOptional<z.ZodString>;
+        kotlin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gitAttributesGeneratedFlag: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * Represents the structure of a `nitro.json` config file.
+ */
+export type NitroUserConfig = z.infer<typeof NitroUserConfigSchema>;

package/lib/config/NitroUserConfig.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+// Namespaces and package names in C++/Java will be matched with a regex.
+const safeNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const isNotReservedKeyword = (val) => !['core', 'nitro', 'NitroModules'].includes(val);
+const isReservedKeywordError = {
+    message: `This value is reserved and cannot be used!`,
+};
+export const NitroUserConfigSchema = z.object({
+    /**
+     * Represents the C++ namespace of the module that will be generated.
+     *
+     * This can have multiple sub-namespaces, and is always relative to `margelo::nitro`.
+     * @example `['image']` -> `margelo::nitro::image`
+     */
+    cxxNamespace: z
+        .array(z
+        .string()
+        .regex(safeNamePattern)
+        .refine(isNotReservedKeyword, isReservedKeywordError))
+        .min(1),
+    /**
+     * iOS specific options.
+     */
+    ios: z.object({
+        /**
+         * Represents the iOS module name of the module that will be generated.
+         *
+         * This will be used to generate Swift bridges, as those are always namespaced within the clang module.
+         *
+         * If you are using CocoaPods, this should be the Pod name defined in the `.podspec`.
+         * @example `NitroTest`
+         */
+        iosModuleName: z
+            .string()
+            .regex(safeNamePattern)
+            .refine(isNotReservedKeyword, isReservedKeywordError),
+    }),
+    /**
+     * Android specific options.
+     */
+    android: z.object({
+        /**
+         * Represents the Android namespace ("package") of the module that will be generated.
+         *
+         * This can have multiple sub-namespaces, and is always relative to `com.margelo.nitro`.
+         * @example `['image']` -> `com.margelo.nitro.image`
+         */
+        androidNamespace: z
+            .array(z
+            .string()
+            .regex(safeNamePattern)
+            .refine(isNotReservedKeyword, isReservedKeywordError))
+            .min(1),
+        /**
+         * Represents the name of the Android C++ library (aka name in CMakeLists.txt `add_library(..)`).
+         * This will be loaded via `System.loadLibrary(...)`.
+         * @example `NitroTest`
+         */
+        androidCxxLibName: z
+            .string()
+            .regex(safeNamePattern)
+            .refine(isNotReservedKeyword, isReservedKeywordError),
+    }),
+    /**
+     * Configures the code that gets generated for autolinking (registering)
+     * Hybrid Object constructors.
+     *
+     * Each class listed here needs to have a default constructor/initializer that takes
+     * zero arguments.
+     */
+    autolinking: z.record(z.string(), z.object({
+        cpp: z.string().optional(),
+        swift: z.string().optional(),
+        kotlin: z.string().optional(),
+    })),
+    /**
+     * A list of paths relative to the project directory that should be ignored by nitrogen.
+     * Nitrogen will not look for `.nitro.ts` files in these directories.
+     */
+    ignorePaths: z.array(z.string()).optional(),
+    /**
+     * Configures whether all nitro-generated files are marked as
+     * [`linguist-generated`](https://docs.github.com/en/repositories/working-with-files/managing-files/customizing-how-changed-files-appear-on-github)
+     * for GitHub. This disables diffing for generated content and excludes them from language statistics.
+     * This is controlled via `nitrogen/generated/.gitattributes`.
+     */
+    gitAttributesGeneratedFlag: z.boolean().optional().default(true),
+});

package/lib/config/getConfig.d.ts

@@ -0,0 +1,2 @@
+import { type NitroUserConfig } from './NitroUserConfig.js';
+export declare function readUserConfig(configPath: string): NitroUserConfig;