模块 API 参考

Constant("PI") {
  Double.pi
}

Constant("PI") {
  Math.PI
}

// 从字典创建
Constants([
  "PI": Double.pi
])

// 或由闭包返回
Constants {
  return [
    "PI": Double.pi
  ]
}

// 作为参数传入
Constants(
  "PI" to kotlin.math.PI
)

// 或由闭包返回
Constants {
  return@Constants mapOf(
    "PI" to kotlin.math.PI
  )
}

Function("mySyncFunction") { (message: String) in
  return message
}

Function("mySyncFunction") { message: String ->
  return@Function message
}

AsyncFunction("myAsyncFunction") { (message: String) in
  return message
}

// 或

AsyncFunction("myAsyncFunction") { (message: String, promise: Promise) in
  promise.resolve(message)
}

AsyncFunction("myAsyncFunction") { message: String ->
  return@AsyncFunction message
}

// 或

// 确保从 `expo.modules.kotlin` 导入 `Promise` 类，而不是 `expo.modules.core`。
AsyncFunction("myAsyncFunction") { message: String, promise: Promise ->
  promise.resolve(message)
}

AsyncFunction("myAsyncFunction") { (message: String) in
  return message
}.runOnQueue(.main)

AsyncFunction("myAsyncFunction") { message: String ->
  return@AsyncFunction message
}.runOnQueue(Queues.MAIN)

Property("foo") {
  return "bar"
}

Property("foo") {
  return@Property "bar"
}

Property("foo")
  .get { return "bar" }
  .set { (newValue: String) in
    // 使用新值做一些事情
  }

Property("foo")
  .get { return@get "bar" }
  .set { newValue: String ->
    // 使用新值做一些事情
  }

View(UITextView.self) {
  Prop("text") { %%placeholder-start%%... %%placeholder-end%% }

  AsyncFunction("focus") { (view: UITextView) in
    view.becomeFirstResponder()
  }
}

View(TextView::class) {
  Prop("text") { %%placeholder-start%%... %%placeholder-end%% }

  AsyncFunction("focus") { view: TextView ->
    view.requestFocus()
  }
}

Prop("background") { (view: UIView, color: UIColor) in
  view.backgroundColor = color
}

Prop("background") { view: View, @ColorInt color: Int ->
  view.setBackgroundColor(color)
}

Prop("background", UIColor.black) { (view: UIView, color: UIColor) in
  view.backgroundColor = color
}

Prop("background", Color.BLACK) { view: View, @ColorInt color: Int ->
  view.setBackgroundColor(color)
}

View(MyView.self) {
  AsyncFunction("myAsyncFunction") { (view: MyView, message: String) in
    view.displayMessage(message)
  }
}

View(MyView::class) {
  AsyncFunction("myAsyncFunction") { view: MyView, message: String ->
    view.displayMessage(message);
  }
}

struct FileReadOptions: Record {
  @Field
  var encoding: String = "utf8"

  @Field
  var position: Int = 0

  @Field
  var length: Int?
}

// 现在这个 record 可以作为函数或视图 prop setter 的参数使用。
Function("readFile") { (path: String, options: FileReadOptions) -> String in
  // 使用给定的 `options` 读取文件
}

class FileReadOptions : Record {
  @Field
  val encoding: String = "utf8"

  @Field
  val position: Int = 0

  @Field
  val length: Int? = null
}

// 现在这个 record 可以作为函数或视图 prop setter 的参数使用。
Function("readFile") { path: String, options: FileReadOptions ->
  // 使用给定的 `options` 读取文件
}

struct UserInfo: Record {
  @Field var id: Int = 0
  @Field var email: String = ""
  @Field var password: String = ""
}

Function("getUser") {
  let user = UserInfo(id: 1, email: "[email protected]", password: "secret123")

  // 返回不暴露密码的用户
  return user.format { formatter in
    formatter.property("password", keyPath: \.password).skip()
  }
}

class UserInfo(
  @Field val id: Int = 0,
  @Field val email: String = "",
  @Field val password: String = ""
) : Record

Function("getUser") {
  val user = UserInfo(id = 1, email = "[email protected]", password = "secret123")

  // 返回不暴露密码的用户
  formatter {
    property(UserInfo::password).skip()
  }.format(user)
}

struct Product: Record {
  @Field var name: String = ""
  @Field var price: Double = 0.0
}

Function("getProduct") {
  let product = Product(name: "Widget", price: 19.99)

  return product.format { formatter in
    // 将价格转换为带货币符号的字符串
    formatter.property("price", keyPath: \.price).map { value in
      "$\(String(format: "%.2f", value))"
    }
  }
}

class Product(
  @Field val name: String = "",
  @Field val price: Double = 0.0
) : Record

Function("getProduct") {
  val product = Product(name = "Widget", price = 19.99)

  formatter {
    // 将价格转换为带货币符号的字符串
    property(Product::price).map { value ->
      "${"$"}${String.format("%.2f", value)}"
    }
  }.format(product)
}

struct Settings: Record {
  @Field var theme: String = "light"
  @Field var debugMode: Bool = false
  @Field var apiKey: String? = nil
}

Function("getSettings") {
  let settings = Settings(theme: "dark", debugMode: true, apiKey: "secret")

  return settings.format { formatter in
    // 如果 apiKey 为 nil 则跳过
    formatter.property("apiKey", keyPath: \.apiKey).skip { value in
      value == nil
    }
  }
}

class Settings(
  @Field val theme: String = "light",
  @Field val debugMode: Boolean = false,
  @Field val apiKey: String? = null
) : Record

Function("getSettings") {
  val settings = Settings(theme = "dark", debugMode = true, apiKey = "secret")

  formatter {
    // 如果 apiKey 为 null 则跳过
    property(Settings::apiKey).skip { value ->
      value == null
    }
  }.format(settings)
}

struct Data: Record {
  @Field var value: Int? = nil
}

Function("getData") {
  let data = Data(value: nil)

  return data.format { formatter in
    formatter.property("value", keyPath: \.value)
      .map { $0 ?? 0 }  // 如果为 nil，则默认为 0
      .map { $0 * 2 }   // 将值翻倍
  }
}

class Data(
  @Field val value: Int? = null
) : Record

Function("getData") {
  val data = Data(value = null)

  formatter {
    property(Data::value)
      .map { it ?: 0 }  // 如果为 null，则默认为 0
      .map { it * 2 }   // 将值翻倍
  }.format(data)
}