nitrogen 0.2.24 → 0.29.5

package/src/getPlatformSpecs.ts

@@ -0,0 +1,202 @@
+import type { PlatformSpec } from 'react-native-nitro-modules'
+import type { InterfaceDeclaration, Type, TypeAliasDeclaration } from 'ts-morph'
+import { Node, Symbol } from 'ts-morph'
+import { getBaseTypes } from './utils.js'
+
+export type Platform = keyof Required<PlatformSpec>
+export type Language = Required<PlatformSpec>[keyof PlatformSpec]
+
+const platformLanguages: { [K in Platform]: Language[] } = {
+  ios: ['swift', 'c++'],
+  android: ['kotlin', 'c++'],
+}
+const allPlatforms = Object.keys(platformLanguages) as Platform[]
+const allLanguages = Object.values(platformLanguages).flatMap((l) => l)
+
+function isValidLanguage(language: string | undefined): language is Language {
+  if (language == null) {
+    return false
+  }
+  return allLanguages.includes(language as Language)
+}
+
+function isValidPlatform(platform: string): platform is Platform {
+  return allPlatforms.includes(platform as Platform)
+}
+
+function getLiteralValue(symbol: Symbol): string | undefined {
+  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: Language,
+  platform: Platform
+): language is Required<PlatformSpec>[typeof platform] {
+  return platformLanguages[platform].includes(language)
+}
+
+function getPlatformSpec(typeName: string, platformSpecs: Type): PlatformSpec {
+  const result: PlatformSpec = {}
+
+  // 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: Type, name: string): boolean {
+  const symbol = type.getSymbol() ?? type.getAliasSymbol()
+  if (symbol?.getName() === name) {
+    return true
+  }
+  return false
+}
+
+function extendsType(type: Type, name: string, recursive: boolean): boolean {
+  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: Type): boolean {
+  return isDirectlyType(type, 'HybridObject')
+}
+
+export function extendsHybridObject(type: Type, recursive: boolean): boolean {
+  return extendsType(type, 'HybridObject', recursive)
+}
+
+export function isHybridViewProps(type: Type): boolean {
+  return extendsType(type, 'HybridViewProps', true)
+}
+export function isHybridViewMethods(type: Type): boolean {
+  return extendsType(type, 'HybridViewMethods', true)
+}
+
+export function isHybridView(type: Type): boolean {
+  // 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: Type): boolean {
+  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: InterfaceDeclaration | TypeAliasDeclaration
+): PlatformSpec | undefined {
+  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: InterfaceDeclaration | TypeAliasDeclaration
+): PlatformSpec | undefined {
+  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/src/index.ts

@@ -0,0 +1,146 @@
+#!/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: string,
+  outputDirectory: string
+): Promise<void> {
+  // 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/src/init.ts

@@ -0,0 +1,186 @@
+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: string,
+  moduleName: string,
+  ref: string = 'main'
+): Promise<void> {
+  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(): Promise<boolean> {
+  try {
+    execSync('git --version')
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+async function downloadGitHubFolder(
+  owner: string,
+  repo: string,
+  branch: string,
+  folder: string,
+  outputPath: string
+): Promise<string> {
+  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: string, dest: string) {
+  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: string,
+  templateName: string,
+  replacementValue: string
+): Promise<void> {
+  const replaceInFile = async (filePath: string) => {
+    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: string) => {
+    return name.replaceAll(`$$${templateName}$$`, replacementValue)
+  }
+
+  const processDirectory = async (currentDir: string) => {
+    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)
+}