nitrogen 0.2.24 → 0.29.4

package/src/syntax/types/StructType.ts

@@ -0,0 +1,83 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import type { Language } from '../../getPlatformSpecs.js'
+import { createCppStruct } from '../c++/CppStruct.js'
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
+import {
+  type FileWithReferencedTypes,
+  type SourceFile,
+  type SourceImport,
+} from '../SourceFile.js'
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js'
+
+export class StructType implements Type {
+  readonly structName: string
+  readonly properties: NamedType[]
+  readonly declarationFile: FileWithReferencedTypes
+
+  constructor(structName: string, properties: NamedType[]) {
+    this.structName = structName
+    this.properties = properties
+    this.declarationFile = createCppStruct(structName, properties)
+
+    if (this.structName.startsWith('__')) {
+      throw new Error(
+        `Struct name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${this.structName})`
+      )
+    }
+    if (this.properties.length === 0) {
+      throw new Error(
+        `Empty structs are not supported in Nitrogen! Add at least one property to ${this.structName}.`
+      )
+    }
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a struct, heavy to copy.
+    return true
+  }
+  get kind(): TypeKind {
+    return 'struct'
+  }
+
+  getCode(language: Language, { fullyQualified }: GetCodeOptions = {}): string {
+    switch (language) {
+      case 'c++':
+        if (fullyQualified) {
+          return NitroConfig.current.getCxxNamespace('c++', this.structName)
+        } else {
+          return this.structName
+        }
+      case 'swift':
+        return this.structName
+      case 'kotlin':
+        return this.structName
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for StructType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    const referencedTypes = this.declarationFile.referencedTypes.flatMap((r) =>
+      r.getExtraFiles()
+    )
+    return [this.declarationFile, ...referencedTypes]
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    if (language === 'c++') {
+      const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+      imports.push({
+        name: this.declarationFile.name,
+        language: this.declarationFile.language,
+        forwardDeclaration: getForwardDeclaration(
+          'struct',
+          this.structName,
+          cxxNamespace
+        ),
+        space: 'user',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/TupleType.ts

@@ -0,0 +1,53 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import type { GetCodeOptions, Type, TypeKind } from './Type.js'
+
+export class TupleType implements Type {
+  readonly itemTypes: Type[]
+
+  constructor(itemTypes: Type[]) {
+    this.itemTypes = itemTypes
+  }
+
+  get canBePassedByReference(): boolean {
+    // It's a tuple<..> - heavy to copy
+    return true
+  }
+
+  get kind(): TypeKind {
+    return 'tuple'
+  }
+
+  getCode(language: Language, options?: GetCodeOptions): string {
+    const types = this.itemTypes.map((t) => t.getCode(language, options))
+
+    switch (language) {
+      case 'c++':
+        return `std::tuple<${types.join(', ')}>`
+      case 'swift':
+        throw new Error(
+          `Tuple (${types.join(', ')}) is not yet supported in Swift due to a Swift bug! See https://github.com/swiftlang/swift/issues/75865`
+        )
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for TupleType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return this.itemTypes.flatMap((t) => t.getExtraFiles())
+  }
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports = this.itemTypes.flatMap((t) =>
+      t.getRequiredImports(language)
+    )
+    if (language === 'c++') {
+      imports.push({
+        language: 'c++',
+        name: 'tuple',
+        space: 'system',
+      })
+    }
+    return imports
+  }
+}

package/src/syntax/types/Type.ts

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

package/src/syntax/types/VariantType.ts

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

package/src/syntax/types/VoidType.ts

@@ -0,0 +1,34 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class VoidType implements Type {
+  get canBePassedByReference(): boolean {
+    // It's void.
+    return false
+  }
+  get kind(): TypeKind {
+    return 'void'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'void'
+      case 'swift':
+        return 'Void'
+      case 'kotlin':
+        return 'Unit'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for VoidType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(): SourceImport[] {
+    return []
+  }
+}

package/src/syntax/types/getTypeAs.ts

@@ -0,0 +1,15 @@
+import { NamedWrappingType } from './NamedWrappingType.js'
+import type { Type } from './Type.js'
+
+export function getTypeAs<T>(
+  type: Type,
+  classReference: new (...args: any[]) => T
+): T {
+  if (type instanceof classReference) {
+    return type as unknown as T
+  } else if (type instanceof NamedWrappingType) {
+    return getTypeAs(type.type, classReference)
+  } else {
+    throw new Error(`Type of kind "${type.kind}" is not a ${classReference}!`)
+  }
+}

package/src/utils.ts

@@ -0,0 +1,162 @@
+import type { SourceFile } from './syntax/SourceFile.js'
+import path from 'path'
+import fs from 'fs'
+import type { SwiftCxxHelper } from './syntax/swift/SwiftCxxTypeHelper.js'
+import type { Type } from 'ts-morph'
+import { isNotDuplicate } from './syntax/helpers.js'
+import { readUserConfig } from './config/getConfig.js'
+import { NitroConfig } from './config/NitroConfig.js'
+
+export const NITROGEN_VERSION = process.env.npm_package_version ?? '?.?.?'
+
+export function capitalizeName(name: string): string {
+  if (name.length === 0) return name
+  return name.charAt(0).toUpperCase() + name.slice(1)
+}
+
+export function createIndentation(spacesCount: number): string {
+  return Array.from(Array(spacesCount)).fill(' ').join('')
+}
+
+export function indent(string: string, spacesCount: number): string
+export function indent(string: string, indentation: string): string
+export function indent(string: string, indentation: string | number): string {
+  let spaces: string
+  if (typeof indentation === 'number') {
+    spaces = createIndentation(indentation)
+  } else {
+    spaces = indentation
+  }
+  return string.replaceAll('\n', `\n${spaces}`)
+}
+
+export function errorToString(error: unknown): string {
+  if (error == null) {
+    return `null`
+  }
+  if (typeof error !== 'object') {
+    return `${error}`
+  }
+  if (error instanceof Error) {
+    let message = `${error.name}: ${error.message}`
+    if (error.cause != null) {
+      message += ` (cause: ${JSON.stringify(error.cause)})`
+    }
+    return message
+  }
+  if ('toString' in error) {
+    return error.toString()
+  }
+  return JSON.stringify(error)
+}
+
+export function escapeComments(string: string): string {
+  return string
+    .replace(/\/\*/g, '/ *') // Escape start of comment
+    .replace(/\*\//g, '* /') // Escape end of comment
+    .replace(/\/\//g, '/ /') // Escape single-line comment
+}
+
+const HAS_UNIX_PATHS = path.join('a', 'b').includes('/')
+export function toUnixPath(p: string): string {
+  if (HAS_UNIX_PATHS) return p
+  return p.replaceAll('\\', '/')
+}
+
+const sep = path.sep
+export function unsafeFastJoin(...segments: string[]): string {
+  // this function should really not take any unsafe strings like `/` or `\`.
+  return segments.join(sep)
+}
+
+function getFullPath(file: SourceFile): string {
+  return unsafeFastJoin(
+    file.platform,
+    file.language,
+    ...file.subdirectory,
+    file.name
+  )
+}
+
+/**
+ * Deduplicates all files via their full path.
+ * If content differs, you are f*cked.
+ */
+export function deduplicateFiles(files: SourceFile[]): SourceFile[] {
+  const map = new Map<string, SourceFile>()
+  for (const file of files) {
+    const filePath = getFullPath(file)
+
+    if (!map.has(filePath)) {
+      map.set(filePath, file)
+    }
+  }
+  return [...map.values()]
+}
+
+export function filterDuplicateHelperBridges(
+  bridge: SwiftCxxHelper,
+  i: number,
+  array: SwiftCxxHelper[]
+): boolean {
+  const otherIndex = array.findIndex(
+    (f2) => bridge.specializationName === f2.specializationName
+  )
+  return otherIndex === i
+}
+
+export function toLowerCamelCase(string: string): string {
+  const parts = string.split('_').filter((part) => part !== '')
+
+  if (parts.length === 0) return ''
+
+  const camelCaseString = parts[0]!.toLowerCase()
+
+  const camelCased = parts
+    .slice(1)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+
+  return camelCaseString + camelCased.join('')
+}
+
+export function getBaseTypes(type: Type): Type[] {
+  const baseTypes = type.getBaseTypes()
+  const symbol = type.getSymbol()
+  if (symbol != null) {
+    baseTypes.push(...symbol.getDeclaredType().getBaseTypes())
+  }
+  const recursive = baseTypes.flatMap((b) => [b, ...getBaseTypes(b)])
+  return recursive.filter(isNotDuplicate)
+}
+
+export function getHybridObjectNitroModuleConfig(
+  type: Type
+): NitroConfig | undefined {
+  const symbol = type.getSymbol() ?? type.getAliasSymbol()
+  if (!symbol) return undefined
+
+  const declarations =
+    symbol.getValueDeclaration() || symbol.getDeclarations()[0]
+  if (!declarations) return undefined
+
+  const sourceFile = declarations.getSourceFile()
+  let filePath: string = sourceFile.getFilePath()
+
+  while (true) {
+    // go up one dir
+    const newFilePath = path.resolve(path.join(filePath, '..'))
+    if (filePath === newFilePath) {
+      // going 'cd ..' in that path didn't change a thing - so we
+      // reached the root directory. we didn't find a nitro.json anywhere.
+      return undefined
+    }
+    filePath = newFilePath
+
+    const nitroJsonPath = path.join(filePath, 'nitro.json')
+    const hasNitroJson = fs.existsSync(nitroJsonPath)
+    if (hasNitroJson) {
+      const config = readUserConfig(nitroJsonPath)
+      return new NitroConfig(config)
+    }
+  }
+}