nitrogen 0.2.24 → 0.29.5

package/src/syntax/swift/SwiftEnum.ts

@@ -0,0 +1,65 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent, toLowerCamelCase } from '../../utils.js'
+import { createFileMetadataString } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import type { EnumType } from '../types/EnumType.js'
+
+export function createSwiftEnumBridge(enumType: EnumType): SourceFile {
+  const fullName = NitroConfig.current.getCxxNamespace(
+    'swift',
+    enumType.enumName
+  )
+
+  const initializeCases = enumType.enumMembers.map((m) =>
+    `
+case "${m.stringValue}":
+  self = .${toLowerCamelCase(m.name)}
+    `.trim()
+  )
+  const toStringCases = enumType.enumMembers.map((m) =>
+    `
+case .${toLowerCamelCase(m.name)}:
+  return "${m.stringValue}"
+`.trim()
+  )
+
+  const code = `
+${createFileMetadataString(`${enumType.enumName}.swift`)}
+
+/**
+ * Represents the JS ${enumType.jsType} \`${enumType.enumName}\`, backed by a C++ enum.
+ */
+public typealias ${enumType.enumName} = ${fullName}
+
+public extension ${enumType.enumName} {
+  /**
+   * Get a ${enumType.enumName} for the given String value, or
+   * return \`nil\` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      ${indent(initializeCases.join('\n'), '      ')}
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ${enumType.enumName} represents.
+   */
+  var stringValue: String {
+    switch self {
+      ${indent(toStringCases.join('\n'), '      ')}
+    }
+  }
+}
+  `.trim()
+
+  return {
+    content: code,
+    language: 'swift',
+    name: `${enumType.enumName}.swift`,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/syntax/swift/SwiftFunction.ts

@@ -0,0 +1,91 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { indent } from '../../utils.js'
+import { createFileMetadataString } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import type { FunctionType } from '../types/FunctionType.js'
+import { SwiftCxxBridgedType } from './SwiftCxxBridgedType.js'
+
+export function createSwiftFunctionBridge(
+  functionType: FunctionType
+): SourceFile {
+  const swiftClassName = functionType.specializationName
+  const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('swift')
+  const argsTypes = functionType.parameters.map((p) => {
+    const bridged = new SwiftCxxBridgedType(p)
+    return `${p.escapedName}: ${bridged.getTypeCode('swift')}`
+  })
+  const returnType = new SwiftCxxBridgedType(functionType.returnType)
+  const argsForward = functionType.parameters.map((p) => {
+    const bridged = new SwiftCxxBridgedType(p)
+    return bridged.parseFromCppToSwift(p.escapedName, 'swift')
+  })
+
+  let body: string
+  if (functionType.returnType.kind === 'void') {
+    body = `
+self.closure(${argsForward.join(', ')})
+    `.trim()
+  } else {
+    body = `
+let __result: ${functionType.returnType.getCode('swift')} = self.closure(${argsForward.join(', ')})
+return ${returnType.parseFromSwiftToCpp('__result', 'swift')}
+    `.trim()
+  }
+
+  const extraImports = functionType
+    .getRequiredImports('swift')
+    .map((i) => `import ${i.name}`)
+
+  const code = `
+${createFileMetadataString(`${swiftClassName}.swift`)}
+
+import NitroModules
+${extraImports.join('\n')}
+
+/**
+ * Wraps a Swift \`${functionType.getCode('swift')}\` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a \`std::function\`.
+ */
+public final class ${swiftClassName} {
+  public typealias bridge = ${bridgeNamespace}
+
+  private let closure: ${functionType.getCode('swift')}
+
+  public init(_ closure: @escaping ${functionType.getCode('swift')}) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(${argsTypes.join(', ')}) -> ${returnType.getTypeCode('swift')} {
+    ${indent(body, '    ')}
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a \`${swiftClassName}\`.
+   * The pointer has to be a retained opaque \`Unmanaged<${swiftClassName}>\`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> ${swiftClassName} {
+    return Unmanaged<${swiftClassName}>.fromOpaque(pointer).takeRetainedValue()
+  }
+}
+  `.trim()
+
+  return {
+    content: code,
+    language: 'swift',
+    name: `${swiftClassName}.swift`,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/syntax/swift/SwiftHybridObject.ts

@@ -0,0 +1,121 @@
+import { indent } from '../../utils.js'
+import { createSwiftHybridViewManager } from '../../views/swift/SwiftHybridViewManager.js'
+import { getHybridObjectName } from '../getHybridObjectName.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { HybridObjectSpec } from '../HybridObjectSpec.js'
+import type { SourceFile } from '../SourceFile.js'
+import { HybridObjectType } from '../types/HybridObjectType.js'
+import { createSwiftHybridObjectCxxBridge } from './SwiftHybridObjectBridge.js'
+
+export function createSwiftHybridObject(spec: HybridObjectSpec): SourceFile[] {
+  const name = getHybridObjectName(spec.name)
+  const protocolName = name.HybridTSpec
+  const properties = spec.properties.map((p) => p.getCode('swift')).join('\n')
+  const methods = spec.methods.map((p) => p.getCode('swift')).join('\n')
+  const extraImports = [
+    ...spec.properties.flatMap((p) => p.getRequiredImports('swift')),
+    ...spec.methods.flatMap((m) => m.getRequiredImports('swift')),
+    ...spec.baseTypes.flatMap((b) =>
+      new HybridObjectType(b).getRequiredImports('swift')
+    ),
+  ]
+
+  const protocolBaseClasses = ['HybridObject']
+  const classBaseClasses: string[] = []
+  if (spec.baseTypes.length > 0) {
+    if (spec.baseTypes.length > 1) {
+      throw new Error(
+        `${name.T}: Inheriting from multiple HybridObject bases is not yet supported in Swift!`
+      )
+    }
+    const base = spec.baseTypes[0]!
+    const baseName = getHybridObjectName(base.name)
+    protocolBaseClasses.push(`${baseName.HybridTSpec}_protocol`)
+    classBaseClasses.push(`${baseName.HybridTSpec}_base`)
+  }
+  if (spec.isHybridView) {
+    protocolBaseClasses.push('HybridView')
+  }
+
+  const hasBaseClass = classBaseClasses.length > 0
+  const baseMembers: string[] = []
+  baseMembers.push(`private weak var cxxWrapper: ${name.HybridTSpecCxx}? = nil`)
+  if (hasBaseClass) {
+    baseMembers.push(`public override init() { super.init() }`)
+  } else {
+    baseMembers.push(`public init() { }`)
+  }
+  baseMembers.push(
+    `
+public ${hasBaseClass ? 'override func' : 'func'} getCxxWrapper() -> ${name.HybridTSpecCxx} {
+#if DEBUG
+  guard self is ${name.HybridTSpec} else {
+    fatalError("\`self\` is not a \`${name.HybridTSpec}\`! Did you accidentally inherit from \`${name.HybridTSpec}_base\` instead of \`${name.HybridTSpec}\`?")
+  }
+#endif
+  if let cxxWrapper = self.cxxWrapper {
+    return cxxWrapper
+  } else {
+    let cxxWrapper = ${name.HybridTSpecCxx}(self as! ${name.HybridTSpec})
+    self.cxxWrapper = cxxWrapper
+    return cxxWrapper
+  }
+}`.trim()
+  )
+
+  const imports = ['import NitroModules']
+  imports.push(
+    ...extraImports.map((i) => `import ${i.name}`).filter(isNotDuplicate)
+  )
+
+  const protocolCode = `
+${createFileMetadataString(`${protocolName}.swift`)}
+
+import Foundation
+${imports.join('\n')}
+
+/// See \`\`${protocolName}\`\`
+public protocol ${protocolName}_protocol: ${protocolBaseClasses.join(', ')} {
+  // Properties
+  ${indent(properties, '  ')}
+
+  // Methods
+  ${indent(methods, '  ')}
+}
+
+/// See \`\`${protocolName}\`\`
+open class ${protocolName}_base${classBaseClasses.length > 0 ? `: ${classBaseClasses.join(',')}` : ''} {
+  ${indent(baseMembers.join('\n'), '  ')}
+}
+
+/**
+ * A Swift base-protocol representing the ${spec.name} HybridObject.
+ * Implement this protocol to create Swift-based instances of ${spec.name}.
+ * \`\`\`swift
+ * class ${name.HybridT} : ${protocolName} {
+ *   // ...
+ * }
+ * \`\`\`
+ */
+public typealias ${protocolName} = ${protocolName}_protocol & ${protocolName}_base
+  `
+
+  const swiftBridge = createSwiftHybridObjectCxxBridge(spec)
+
+  const files: SourceFile[] = []
+  files.push({
+    content: protocolCode,
+    language: 'swift',
+    name: `${protocolName}.swift`,
+    subdirectory: [],
+    platform: 'ios',
+  })
+  files.push(...swiftBridge)
+
+  if (spec.isHybridView) {
+    const viewFiles = createSwiftHybridViewManager(spec)
+    files.push(...viewFiles)
+  }
+
+  return files
+}