nitrogen 0.2.23 → 0.29.4

package/lib/config/getConfig.js

@@ -0,0 +1,84 @@
+import { ZodError } from 'zod';
+import fs from 'fs';
+import { NitroUserConfigSchema, } from './NitroUserConfig.js';
+import chalk from 'chalk';
+function readFile(configPath) {
+    try {
+        return fs.readFileSync(configPath, 'utf8');
+    }
+    catch (error) {
+        if (typeof error === 'object' && error != null && 'code' in error) {
+            switch (error.code) {
+                case 'ENOENT':
+                case 'ENOTDIR':
+                    console.error(`❌  The path ${chalk.underline(configPath)} does not exist! Create a ${chalk.underline('nitro.json')} file and try again.`);
+                    process.exit(1);
+                    // @ts-expect-error
+                    break;
+                default:
+                    throw error;
+            }
+        }
+        else {
+            // different kind of error, throw it.
+            throw error;
+        }
+    }
+}
+function propPathToString(propPath) {
+    if (propPath.length === 0)
+        return '';
+    const prop = propPath.reduce((prev, curr) => {
+        if (typeof curr === 'string') {
+            return `${prev}.${curr}`;
+        }
+        else if (typeof curr === 'number') {
+            return `${prev}[${curr}]`;
+        }
+        else {
+            return prev;
+        }
+    }, '');
+    return prop.slice(1);
+}
+function parseConfig(json) {
+    let object;
+    try {
+        object = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse nitro.json config as JSON! Make sure it has a valid JSON syntax. JSON: ${json}`, {
+            cause: error,
+        });
+    }
+    try {
+        return NitroUserConfigSchema.parse(object);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            const issues = error.issues.map((i) => {
+                const prop = propPathToString(i.path);
+                switch (i.code) {
+                    case 'invalid_type':
+                        return `\`${prop}\` must be ${i.expected}, but is ${i.input}.`;
+                    case 'invalid_value':
+                    case 'invalid_union':
+                    case 'invalid_element':
+                        return `\`${prop}\` is not a valid & safe string. It must only contain alphanumeric characters and must not start with a number.`;
+                    default:
+                        return `\`${prop}\`: ${i.message} (${i.code})`;
+                }
+            });
+            console.error(`❌  Invalid nitro.json config file! ${issues.join(' - also, ')}`);
+            process.exit(1);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+export function readUserConfig(configPath) {
+    const json = readFile(configPath);
+    const config = parseConfig(json);
+    return config;
+}

package/lib/createGitAttributes.d.ts

@@ -0,0 +1 @@
+export declare function createGitAttributes(markAsGenerated: boolean, folder: string): Promise<string>;

package/lib/createGitAttributes.js

@@ -0,0 +1,11 @@
+import fs from 'fs/promises';
+import path from 'path';
+export async function createGitAttributes(markAsGenerated, folder) {
+    const file = path.join(folder, '.gitattributes');
+    // Marks all files in this current folder as "generated"
+    const content = `
+** linguist-generated=${markAsGenerated}
+  `.trim();
+    await fs.writeFile(file, content + '\n', 'utf-8');
+    return file;
+}

package/lib/createPlatformSpec.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-morph';
+import type { SourceFile } from './syntax/SourceFile.js';
+import { type Language } from './getPlatformSpecs.js';
+export declare function generatePlatformFiles(interfaceType: Type, language: Language): SourceFile[];

package/lib/createPlatformSpec.js

@@ -0,0 +1,127 @@
+import { Node, Type } from 'ts-morph';
+import { createCppHybridObject } from './syntax/c++/CppHybridObject.js';
+import { extendsHybridObject, isHybridView, isAnyHybridSubclass, isDirectlyHybridObject, isHybridViewProps, isHybridViewMethods, } from './getPlatformSpecs.js';
+import { Property } from './syntax/Property.js';
+import { Method } from './syntax/Method.js';
+import { createSwiftHybridObject } from './syntax/swift/SwiftHybridObject.js';
+import { createKotlinHybridObject } from './syntax/kotlin/KotlinHybridObject.js';
+import { createType } from './syntax/createType.js';
+import { Parameter } from './syntax/Parameter.js';
+import { getBaseTypes, getHybridObjectNitroModuleConfig } from './utils.js';
+import { NitroConfig } from './config/NitroConfig.js';
+export function generatePlatformFiles(interfaceType, language) {
+    const spec = getHybridObjectSpec(interfaceType, language);
+    // TODO: We currently just call this so the HybridObject itself is a "known type".
+    // This causes the Swift Umbrella header to properly forward-declare it.
+    // Without this, only Hybrid Objects that are actually used in public APIs will be forward-declared.
+    createType(language, interfaceType, false);
+    switch (language) {
+        case 'c++':
+            return generateCppFiles(spec);
+        case 'swift':
+            return generateSwiftFiles(spec);
+        case 'kotlin':
+            return generateKotlinFiles(spec);
+        default:
+            throw new Error(`Language "${language}" is not supported!`);
+    }
+}
+function getHybridObjectSpec(type, language) {
+    const config = getHybridObjectNitroModuleConfig(type) ?? NitroConfig.current;
+    if (isHybridView(type)) {
+        const symbol = type.getAliasSymbolOrThrow();
+        const name = symbol.getEscapedName();
+        // It's a Hybrid View - the `Props & Methods` types are just intersected together.
+        const unions = type.getIntersectionTypes();
+        const props = unions.find((t) => isHybridViewProps(t));
+        const methods = unions.find((t) => isHybridViewMethods(t));
+        if (props == null)
+            throw new Error(`Props cannot be null! ${name}<...> (HybridView) requires type arguments.`);
+        const propsSpec = getHybridObjectSpec(props, language);
+        const methodsSpec = methods != null ? getHybridObjectSpec(methods, language) : undefined;
+        return {
+            baseTypes: [],
+            isHybridView: true,
+            language: language,
+            methods: methodsSpec?.methods ?? [],
+            properties: propsSpec.properties,
+            name: name,
+            config: config,
+        };
+    }
+    const symbol = type.getSymbolOrThrow();
+    const name = symbol.getEscapedName();
+    const properties = [];
+    const methods = [];
+    for (const prop of type.getProperties()) {
+        const declarations = prop.getDeclarations();
+        if (declarations.length > 1) {
+            throw new Error(`${name}: Function overloading is not supported! (In "${prop.getName()}")`);
+        }
+        let declaration = declarations[0];
+        if (declaration == null) {
+            throw new Error(`${name}: Property "${prop.getName()}" does not have a type declaration!`);
+        }
+        const parent = declaration.getParentOrThrow().getType();
+        if (parent === type) {
+            // it's an own property. declared literally here. fine.
+        }
+        else if (extendsHybridObject(parent, true) ||
+            isDirectlyHybridObject(parent)) {
+            // it's coming from a base class that is already a HybridObject. We can grab this via inheritance.
+            // don't generate this property natively.
+            continue;
+        }
+        else {
+            // it's coming from any TypeScript type that is not a HybridObject.
+            // Maybe just a literal interface, then we copy over the props.
+        }
+        if (Node.isPropertySignature(declaration)) {
+            const t = declaration.getType();
+            const propType = createType(language, t, prop.isOptional() || t.isNullable());
+            properties.push(new Property(prop.getName(), propType, declaration.isReadonly()));
+        }
+        else if (Node.isMethodSignature(declaration)) {
+            const returnType = declaration.getReturnType();
+            const methodReturnType = createType(language, returnType, returnType.isNullable());
+            const methodParameters = declaration
+                .getParameters()
+                .map((p) => new Parameter(p, language));
+            methods.push(new Method(prop.getName(), methodReturnType, methodParameters));
+        }
+        else {
+            throw new Error(`${name}: Property "${prop.getName()}" is neither a property, nor a method!`);
+        }
+    }
+    const bases = getBaseTypes(type)
+        .filter((t) => isAnyHybridSubclass(t))
+        .map((t) => getHybridObjectSpec(t, language));
+    const spec = {
+        language: language,
+        name: name,
+        properties: properties,
+        methods: methods,
+        baseTypes: bases,
+        isHybridView: isHybridView(type),
+        config: config,
+    };
+    return spec;
+}
+function generateCppFiles(spec) {
+    const cppFiles = createCppHybridObject(spec);
+    return cppFiles;
+}
+function generateSwiftFiles(spec) {
+    // 1. Always generate a C++ spec for the shared layer and type declarations (enums, interfaces, ...)
+    const cppFiles = generateCppFiles(spec);
+    // 2. Generate Swift specific files and potentially a C++ binding layer
+    const swiftFiles = createSwiftHybridObject(spec);
+    return [...cppFiles, ...swiftFiles];
+}
+function generateKotlinFiles(spec) {
+    // 1. Always generate a C++ spec for the shared layer and type declarations (enums, interfaces, ...)
+    const cppFiles = generateCppFiles(spec);
+    // 2. Generate Kotlin specific files and potentially a C++ binding layer
+    const kotlinFiles = createKotlinHybridObject(spec);
+    return [...cppFiles, ...kotlinFiles];
+}

package/lib/getFiles.d.ts

@@ -0,0 +1 @@
+export declare function getFiles(directory: string): Promise<string[]>;

package/lib/getFiles.js

@@ -0,0 +1,28 @@
+import { Dirent, promises as fs } from 'fs';
+import path from 'path';
+function getFilePath(file, rootDir) {
+    const dir = file.parentPath ?? file.path ?? rootDir;
+    return path.join(dir, file.name);
+}
+export async function getFiles(directory) {
+    try {
+        const files = await fs.readdir(directory, {
+            recursive: true,
+            withFileTypes: true,
+        });
+        return files.filter((f) => f.isFile()).map((f) => getFilePath(f, directory));
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error != null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            // directory does not exist
+            return [];
+        }
+        else {
+            // different error
+            throw error;
+        }
+    }
+}

package/lib/getPlatformSpecs.d.ts

@@ -0,0 +1,17 @@
+import type { PlatformSpec } from 'react-native-nitro-modules';
+import type { InterfaceDeclaration, Type, TypeAliasDeclaration } from 'ts-morph';
+export type Platform = keyof Required<PlatformSpec>;
+export type Language = Required<PlatformSpec>[keyof PlatformSpec];
+export declare function isDirectlyHybridObject(type: Type): boolean;
+export declare function extendsHybridObject(type: Type, recursive: boolean): boolean;
+export declare function isHybridViewProps(type: Type): boolean;
+export declare function isHybridViewMethods(type: Type): boolean;
+export declare function isHybridView(type: Type): boolean;
+export declare function isAnyHybridSubclass(type: Type): boolean;
+/**
+ * If the given interface ({@linkcode declaration}) extends `HybridObject`,
+ * this method returns the platforms it exists on.
+ * If it doesn't extend `HybridObject`, this returns `undefined`.
+ */
+export declare function getHybridObjectPlatforms(declaration: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;
+export declare function getHybridViewPlatforms(view: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;

package/lib/getPlatformSpecs.js

@@ -0,0 +1,153 @@
+import { Node, Symbol } from 'ts-morph';
+import { getBaseTypes } from './utils.js';
+const platformLanguages = {
+    ios: ['swift', 'c++'],
+    android: ['kotlin', 'c++'],
+};
+const allPlatforms = Object.keys(platformLanguages);
+const allLanguages = Object.values(platformLanguages).flatMap((l) => l);
+function isValidLanguage(language) {
+    if (language == null) {
+        return false;
+    }
+    return allLanguages.includes(language);
+}
+function isValidPlatform(platform) {
+    return allPlatforms.includes(platform);
+}
+function getLiteralValue(symbol) {
+    const value = symbol.getValueDeclaration();
+    if (value == null) {
+        return undefined;
+    }
+    const type = value.getType();
+    const literal = type.getLiteralValue();
+    if (typeof literal === 'string') {
+        return literal;
+    }
+    return undefined;
+}
+// TODO: The type casting result here doesn't really work in TS.
+function isValidLanguageForPlatform(language, platform) {
+    return platformLanguages[platform].includes(language);
+}
+function getPlatformSpec(typeName, platformSpecs) {
+    const result = {};
+    // Properties (ios, android)
+    const properties = platformSpecs.getProperties();
+    for (const property of properties) {
+        // Property name (ios, android)
+        const platform = property.getName();
+        if (!isValidPlatform(platform)) {
+            console.warn(`    ⚠️   ${typeName} does not properly extend HybridObject<T> - "${platform}" is not a valid Platform! ` +
+                `Valid platforms are: [${allPlatforms.join(', ')}]`);
+            continue;
+        }
+        // Value (swift, kotlin, c++)
+        const language = getLiteralValue(property);
+        if (!isValidLanguage(language)) {
+            console.warn(`    ⚠️   ${typeName}: Language ${language} is not a valid language for ${platform}! ` +
+                `Valid languages are: [${platformLanguages[platform].join(', ')}]`);
+            continue;
+        }
+        // Double-check that language works on this platform (android: kotlin/c++, ios: swift/c++)
+        if (!isValidLanguageForPlatform(language, platform)) {
+            console.warn(`    ⚠️   ${typeName}: Language ${language} is not a valid language for ${platform}! ` +
+                `Valid languages are: [${platformLanguages[platform].join(', ')}]`);
+            continue;
+        }
+        // @ts-expect-error because TypeScript isn't smart enough yet to correctly cast after the `isValidLanguageForPlatform` check.
+        result[platform] = language;
+    }
+    return result;
+}
+function isDirectlyType(type, name) {
+    const symbol = type.getSymbol() ?? type.getAliasSymbol();
+    if (symbol?.getName() === name) {
+        return true;
+    }
+    return false;
+}
+function extendsType(type, name, recursive) {
+    for (const base of getBaseTypes(type)) {
+        const isHybrid = isDirectlyType(base, name);
+        if (isHybrid) {
+            return true;
+        }
+        if (recursive) {
+            const baseExtends = extendsType(base, name, recursive);
+            if (baseExtends) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function isDirectlyHybridObject(type) {
+    return isDirectlyType(type, 'HybridObject');
+}
+export function extendsHybridObject(type, recursive) {
+    return extendsType(type, 'HybridObject', recursive);
+}
+export function isHybridViewProps(type) {
+    return extendsType(type, 'HybridViewProps', true);
+}
+export function isHybridViewMethods(type) {
+    return extendsType(type, 'HybridViewMethods', true);
+}
+export function isHybridView(type) {
+    // HybridViews are type aliases for `HybridView`, and `Props & Methods` are just intersected together.
+    const unionTypes = type.getIntersectionTypes();
+    for (const union of unionTypes) {
+        const symbol = union.getSymbol();
+        if (symbol == null)
+            return false;
+        return symbol.getName() === 'HybridViewTag';
+    }
+    return false;
+}
+export function isAnyHybridSubclass(type) {
+    if (isDirectlyHybridObject(type))
+        return false;
+    if (isHybridView(type))
+        return true;
+    if (extendsHybridObject(type, true))
+        return true;
+    return false;
+}
+/**
+ * If the given interface ({@linkcode declaration}) extends `HybridObject`,
+ * this method returns the platforms it exists on.
+ * If it doesn't extend `HybridObject`, this returns `undefined`.
+ */
+export function getHybridObjectPlatforms(declaration) {
+    const base = getBaseTypes(declaration.getType()).find((t) => isDirectlyHybridObject(t));
+    if (base == null) {
+        // this type does not extend `HybridObject`.
+        throw new Error(`Couldn't find HybridObject<..> base for ${declaration.getName()}! (${declaration.getText()})`);
+    }
+    const genericArguments = base.getTypeArguments();
+    const platformSpecsArgument = genericArguments[0];
+    if (platformSpecsArgument == null) {
+        // it uses `HybridObject` without generic arguments. This defaults to C++
+        return { android: 'c++', ios: 'c++' };
+    }
+    return getPlatformSpec(declaration.getName(), platformSpecsArgument);
+}
+export function getHybridViewPlatforms(view) {
+    if (Node.isTypeAliasDeclaration(view)) {
+        const hybridViewTypeNode = view.getTypeNode();
+        const isHybridViewType = Node.isTypeReference(hybridViewTypeNode) &&
+            hybridViewTypeNode.getTypeName().getText() === 'HybridView';
+        if (!isHybridViewType) {
+            return;
+        }
+        const genericArguments = hybridViewTypeNode.getTypeArguments();
+        const platformSpecArg = genericArguments[2];
+        if (platformSpecArg != null) {
+            return getPlatformSpec(view.getName(), platformSpecArg.getType());
+        }
+    }
+    // it uses `HybridObject` without generic arguments. This defaults to platform native languages
+    return { ios: 'swift', android: 'kotlin' };
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/index.js

@@ -1,10 +1,113 @@
-exports.ApiKey         = require('./apiKey');
-exports.Blob           = require('./blob');
-exports.CommandManager = require('./commandManager');
-exports.Device         = require('./device');
-exports.Message        = require('./message');
-exports.Permission     = require('./permission');
-exports.Principal      = require('./principal');
-exports.Service        = require('./service');
-exports.Session        = require('./session');
-exports.User           = require('./user');
+#!/usr/bin/env node
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import chalk from 'chalk';
+import { prettifyDirectory } from './prettifyDirectory.js';
+import { getFiles } from './getFiles.js';
+import { runNitrogen } from './nitrogen.js';
+import { promises as fs } from 'fs';
+import { isValidLogLevel, setLogLevel } from './Logger.js';
+import { initNewNitroModule } from './init.js';
+import { NITROGEN_VERSION } from './utils.js';
+const commandName = 'nitrogen';
+// Maximum of 100 col width
+const cliWidth = Math.min(process.stdout.columns * 0.9, 100);
+// Set up yargs CLI app
+await yargs(hideBin(process.argv))
+    .option('log-level', {
+    type: 'string',
+    description: 'Configures the log-level of nitrogen.',
+    default: 'info',
+    choices: ['debug', 'info', 'warning', 'error'],
+})
+    .middleware((args) => {
+    if (!isValidLogLevel(args.logLevel)) {
+        throw new Error(`Invalid log-level ("${args.logLevel}")!`);
+    }
+    setLogLevel(args.logLevel);
+})
+    // 🔥 nitrogen [path]
+    .command('$0 [basePath]', `Usage: ${chalk.bold(`${commandName} <basePath> [options]`)}\n` +
+    `Run the nitro code-generator on all ${chalk.underline('**/*.nitro.ts')} files found ` +
+    `in the current directory and generate C++, Swift or Kotlin outputs in ${chalk.underline('./nitrogen/generated')}.`, (y) => y
+    .positional('basePath', {
+    type: 'string',
+    description: `The base path of where Nitrogen will start looking for ${chalk.underline('**/*.nitro.ts')} specs.`,
+    default: process.cwd(),
+})
+    .option('out', {
+    type: 'string',
+    description: 'Configures the output path of the generated C++, Swift or Kotlin files.',
+    default: './nitrogen/generated',
+})
+    .option('config', {
+    type: 'string',
+    description: `A custom path to a ${chalk.underline('nitro.json')} config file.`,
+    default: './nitro.json',
+}), async (argv) => {
+    const basePath = argv.basePath;
+    const outputDirectory = argv.out;
+    await runNitrogenCommand(basePath, outputDirectory);
+})
+    // 🔥 nitrogen init <moduleName>
+    .command('init <moduleName>', `Usage: ${chalk.bold(`${commandName} init <moduleName> [options]`)}\n` +
+    `Create a new Nitro Module.`, (y) => y
+    .positional('moduleName', {
+    type: 'string',
+    description: 'The name of the Nitro Module that will be created.',
+    demandOption: true,
+})
+    .option('path', {
+    type: 'string',
+    description: `A custom path to create the new Nitro Module in - instead of the current working directory.`,
+    default: process.cwd(),
+}), async (argv) => {
+    await initNewNitroModule(argv.path, argv.moduleName);
+})
+    .usage(`Usage: ${chalk.bold('$0 [options]')}\n` +
+    `$0 is a code-generater for Nitro Modules (${chalk.underline('https://github.com/mrousavy/nitro')})\n` +
+    `It converts all TypeScript specs found in ${chalk.underline('**/*.nitro.ts')} to C++, Swift or Kotlin specs.\n` +
+    `Each library/module must have a ${chalk.underline('nitro.json')} configuration file in it's root directory.\n` +
+    `$Nitrogen Version: ${chalk.bold(NITROGEN_VERSION)}`)
+    .help()
+    .strict()
+    .wrap(cliWidth).argv;
+async function runNitrogenCommand(baseDirectory, outputDirectory) {
+    // 1. Prepare output folders
+    const filesBefore = await getFiles(outputDirectory);
+    const start = performance.now();
+    // 2. Run Nitrogen
+    const { generatedFiles, generatedSpecsCount, targetSpecsCount } = await runNitrogen({
+        baseDirectory: baseDirectory,
+        outputDirectory: outputDirectory,
+    });
+    const end = performance.now();
+    const timeS = ((end - start) / 1000).toFixed(1);
+    console.log(`🎉  Generated ${generatedSpecsCount}/${targetSpecsCount} HybridObject${generatedSpecsCount === 1 ? '' : 's'} in ${timeS}s!`);
+    console.log(`💡  Your code is in ${chalk.underline(prettifyDirectory(outputDirectory))}`);
+    // 3. Delete all old dangling files
+    const addedFiles = generatedFiles.filter((f) => !filesBefore.includes(f));
+    const removedFiles = filesBefore.filter((f) => !generatedFiles.includes(f));
+    if (addedFiles.length > 0 || removedFiles.length > 0) {
+        let text = '';
+        const as = addedFiles.length > 1 ? 's' : '';
+        const rs = removedFiles.length > 1 ? 's' : '';
+        if (addedFiles.length > 0 && removedFiles.length === 0) {
+            text = `Added ${addedFiles.length} file${as}`;
+        }
+        else if (addedFiles.length === 0 && removedFiles.length > 0) {
+            text = `Removed ${removedFiles.length} file${rs}`;
+        }
+        else {
+            text = `Added ${addedFiles.length} file${as} and removed ${removedFiles.length} file${rs}`;
+        }
+        console.log(`‼️   ${text} - ${chalk.bold('you need to run `pod install`/sync gradle to update files!')}`);
+    }
+    const promises = removedFiles.map(async (file) => {
+        const stat = await fs.stat(file);
+        if (stat.isFile()) {
+            await fs.rm(file);
+        }
+    });
+    await Promise.all(promises);
+}

package/lib/init.d.ts

@@ -0,0 +1 @@
+export declare function initNewNitroModule(baseDirectory: string, moduleName: string, ref?: string): Promise<void>;