🥮 mooncakes.io

jmop

A safe JavaScript interop tool.

js
ffi
web
moon add Yoorkin/jmop@0.1.1
Download zip
Author
Version
0.1.1
License
Apache-2.0
Repository
Last updated
10 months ago
Downloads
46
README

#jmop

doc

Note: This module is experimental and its API may change in future releases.

jmop (JavaScript & MoonBit interoperation) is an FFI module for MoonBit's js backend that enables safe interaction with JavaScript objects and functions. It emphasizes null and undefined safety, helping you avoid common pitfalls when working with javascript.

#Features

  • Null and undefined safety: Prevents accidental access to missing values.
  • Fail-fast behavior: Errors are detected and reported immediately.
  • Traceable runtime errors: Clear error messages make debugging easier.

#Usage Examples

///|
typealias @jmop.(Object, Promise, Function)

///|
fn init {
  @jmop.global_this.set(
    "test",
    Object::new({
      "number1": 100,
      "number2": 50,
      "object": Object::new({
        "add": Function::new(fn(x : Int, y) { x + y }),
        "sub": Function::new(fn(x : Int, y) { x - y }),
      }),
    }),
  ) catch {
    e => println(e)
  }
}

///|
test "object and function" {
  let js_obj = @jmop.global_this.get_object("test")
  let n1 = js_obj.get_number("number1")
  let n2 = js_obj.get_number("number2")
  inspect(js_obj.get_object("object").call("add", [n1, n2]), content="150")
  inspect(js_obj.get_object("object").call("sub", [n1, n2]), content="50")
  inspect(js_obj.get_object("object").call("add", ["123", 1]), content="1231")
}

Try the following test by clicking the Test button:

///|
test "promise" {
  @jmop.try_launch(() => {
    let js_promise = Promise::new(1)
    let r = js_promise
      .map(x => x + 1)
      .bind(x => Promise::new(x.to_string()))
      .wait()
    println(r) // 2
  })
}

///|
test "fail-fast: get undefined field" {
  global_this.get_object("test").get("undefined_obj") |> ignore
}

///|
test "fail-fast: create nested promise" {
  @jmop.try_launch(() => Promise::new(Promise::new(1)).wait() |> ignore)
}

#
DynCast

source
pub(open) trait DynCast : IsValue {
  from_value(Value) -> Self raise
}

impl DynCast for Bool
impl DynCast for Int
impl DynCast for Double
impl DynCast for String
impl DynCast for Array[T]

#
IsAny

source
pub(open) trait IsAny {
  as_any(Self) -> Any = _
}

impl IsAny for Unit
impl IsAny for Bool
impl IsAny for Int
impl IsAny for Double
impl IsAny for String
impl IsAny for Array[T]

#
IsError

source
pub trait IsError : IsObject {
  as_error(Self) -> Error_
  get_name(Self) -> String
  get_message(Self) -> String
  get_cause(Self) -> Any
  get_source_loc(Self) -> SourceLoc?
  set_source_loc(Self, SourceLoc) -> Unit
}

#
IsObject

source
pub trait IsObject : IsValue {
}

#
IsString

source
pub trait IsString : IsValue {
}

impl IsString for String

#
IsStringOrFunctionOrObject

source
pub trait IsStringOrFunctionOrObject : IsValue {
}

Function | Object

#
IsStringOrSymbol

source
pub trait IsStringOrSymbol : IsString + IsSymbol {
}

String | Symbol

#
IsSymbol

source
pub(open) trait IsSymbol {
}

#
IsValue

source
pub(open) trait IsValue : IsAny {
  as_value(Self) -> Value = _
}

impl IsValue for Unit
impl IsValue for Bool
impl IsValue for Int
impl IsValue for Double
impl IsValue for String
impl IsValue for Array[T]

#
AggregateError

source
pub suberror AggregateError Error_

#
ArityMismatch

source
pub suberror ArityMismatch ArityMismatchInfo

#
DynCastFailed

source
type DynCastFailed

#
EvalError

source
pub suberror EvalError Error_

impl IsAny for EvalError
impl Show for EvalError

#
InternalError

source
pub suberror InternalError Error_

#
InvalidCast

source
pub(all) suberror InvalidCast (SourceLoc, Value, String?)

impl Show for InvalidCast

#
InvalidField

source
pub(all) suberror InvalidField (SourceLoc, Value, String)

#
InvalidNestedPromise

source
pub suberror InvalidNestedPromise SourceLoc

#
RangeError

source
pub suberror RangeError Error_

impl IsAny for RangeError
impl Show for RangeError

#
ReferenceError

source
pub suberror ReferenceError Error_

#
RuntimeError

source
pub suberror RuntimeError Value

#
SyntaxError

source
pub suberror SyntaxError Error_

impl Show for SyntaxError

#
TypeError

source
pub suberror TypeError Error_

impl IsAny for TypeError
impl Show for TypeError

#
URIError

source
pub suberror URIError Error_

impl IsAny for URIError
impl IsError for URIError
impl IsValue for URIError
impl Show for URIError

#
UnwrapNull

source
pub suberror UnwrapNull SourceLoc

#
UnwrapUndefined

source
pub suberror UnwrapUndefined SourceLoc

#
Any

source
type Any

Represent any value in js, including the null and undefined.
impl IsAny for Any
impl Show for Any

#
Any::from

source
fn[T] Any::from(x : T) -> Any

#
Any::to_option

source
fn[T : DynCast + IsValue + IsAny] Any::to_option(self : Any) -> T?

#
Any::unwrap

source
#callsite(autofill(loc))
fn Any::unwrap(x : Any, loc~ : SourceLoc) -> Value raise

Checks if the value is neither null nor undefined and returns it. Otherwise, raises an UnwrapUndefined or UnwrapNull error.

#
ArityMismatchInfo

source
pub struct ArityMismatchInfo {
  function : Function
  expected : Int
  provided : Int
}

#
Bigint

source
type Bigint

impl IsAny for Bigint
impl IsValue for Bigint

#
Error_

source
type Error_

Represents a JavaScript Error object.
impl DynCast for Error_
impl IsAny for Error_
impl IsError for Error_
impl IsObject for Error_
impl IsValue for Error_
impl Show for Error_

#
Error_::new

source
fn Error_::new(message : String, cause? : Any) -> Error_

#
Error_::new_with_loc

source
fn Error_::new_with_loc(message : String, loc : SourceLoc) -> Error_

#
Function

source
type Function

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function
impl IsAny for Function
impl IsValue for Function
impl Show for Function

#
Function::apply

source
fn Function::apply(f : Function, this : Value, args : Array[IsAny]) -> Any

#
Function::bind

source
fn Function::bind(f : Function, this : Value) -> Function

#
Function::call

source
fn Function::call(f : Function, args : Array[IsValue]) -> Value

#
Function::from_code

source
fn Function::from_code(args : Array[String], functionbody : String) -> Function

#
Function::get_length

source
fn Function::get_length(f : Function) -> Int

#
Function::get_name

source
fn Function::get_name(f : Function) -> String

#
Function::new

source
#callsite(autofill(loc))
fn[F] Function::new(f : F, loc~ : SourceLoc) -> Function raise

#
JsTypeError

source
pub type JsTypeError

#
Nullable

source
type Nullable[T]

A Value can be null.

This value is not boxed, which means Nullable::some(Nullable::null()) is the same as Nullable::null().

#
Nullable::from

source
fn[T] Nullable::from(x : T) -> Nullable[T]

#
Nullable::null

source
fn[T] Nullable::null() -> Nullable[T]
fnalias Nullable::null

#
Nullable::to_option

source
fn[T] Nullable::to_option(self : Nullable[T]) -> T?

Convert Nullable to a boxed Option

#
Nullable::unwrap

source
#callsite(autofill(loc))
fn[T] Nullable::unwrap(self : Nullable[T], loc~ : SourceLoc) -> T raise UnwrapNull

#
Nullable::unwrap_value

source
#callsite(autofill(loc))
fn Nullable::unwrap_value(self : Nullable[Optional[Value]], loc~ : SourceLoc) -> Value raise

#
Object

source
pub type Object

Object represents a non-null JavaScript object.

Hint: if you are looking for object with null, use Nullable[Object].
impl IsAny for Object
impl IsValue for Object

#
Object::assign

source
fn Object::assign(self : Object, sources : Array[IsObject]) -> Unit

#
Object::call

source
#callsite(autofill(loc))
fn Object::call(self : Object, method_ : IsStringOrSymbol, args : Array[IsAny], loc~ : SourceLoc) -> Any raise

#
Object::empty

source
fn Object::empty() -> Object

#
Object::freeze

source
fn Object::freeze(self : Object) -> Unit

#
Object::get

source
#callsite(autofill(loc))
fn Object::get(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Value raise

#
Object::get_array

source
#callsite(autofill(loc))
fn[T : DynCast + IsValue + IsAny] Object::get_array(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Array[T] raise

#
Object::get_bigint

source
#callsite(autofill(loc))
fn Object::get_bigint(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Bigint raise

#
Object::get_boolean

source
#callsite(autofill(loc))
fn Object::get_boolean(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Bool raise

#
Object::get_function

source
#callsite(autofill(loc))
fn Object::get_function(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Function raise

#
Object::get_method

source
#callsite(autofill(loc))
fn Object::get_method(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Function raise

#
Object::get_number

source
#callsite(autofill(loc))
fn Object::get_number(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Double raise

#
Object::get_object

source
#callsite(autofill(loc))
fn Object::get_object(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Object raise

#
Object::get_string

source
#callsite(autofill(loc))
fn Object::get_string(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> String raise

#
Object::get_symbol

source
#callsite(autofill(loc))
fn Object::get_symbol(self : Object, prop : IsStringOrSymbol, loc~ : SourceLoc) -> Symbol raise

#
Object::has_own

source
fn Object::has_own(self : Object, prop : IsStringOrSymbol) -> Bool

#
Object::instance_of

source
fn Object::instance_of(self : Object, ctor : IsStringOrFunctionOrObject) -> Bool

#
Object::new

source
#callsite(autofill(loc))
fn Object::new(pairs : Map[String, IsValue], loc~ : SourceLoc) -> Object raise

#
Object::seal

source
fn Object::seal(self : Object) -> Unit

#
Object::self

source
fn Object::self(self : Object) -> Object

#
Object::set

source
#callsite(autofill(loc))
fn Object::set(self : Object, k : IsStringOrSymbol, v : IsValue, loc~ : SourceLoc) -> Unit raise

#
Optional

source
type Optional[T]

A Value can be undefined.

This value is not boxed, which means Optional::some(Optional::undefined()) is the same as Optional::undefined().
impl IsAny for Optional[T]

#
Optional::from

source
fn[T] Optional::from(x : T) -> Optional[T]

#
Optional::from_option

source
fn[T] Optional::from_option(opt : T?) -> Optional[T]

#
Optional::to_option

source
fn[T] Optional::to_option(self : Optional[T]) -> T?

#
Optional::undefined

source
fn[T] Optional::undefined() -> Optional[T]
fnalias Optional::undefined

#
Optional::unwrap

source
#callsite(autofill(loc))
fn[T] Optional::unwrap(self : Optional[T], loc~ : SourceLoc) -> T raise UnwrapUndefined

#
Optional::unwrap_value

source
#callsite(autofill(loc))
fn Optional::unwrap_value(self : Optional[Nullable[Value]], loc~ : SourceLoc) -> Value raise

#
Promise

source
type Promise[T]

impl IsAny for Promise[T]
impl IsValue for Promise[T]

#
Promise::bind

source
fn[A, B] Promise::bind(x : Promise[A], resolve : (A) -> Promise[B] raise, reject? : (Error) -> Promise[B]) -> Promise[B]

#
Promise::catch_

source
fn[A, B] Promise::catch_(x : Promise[A], f : (Error) -> Promise[B]) -> Promise[B]

#
Promise::map

source
#callsite(autofill(loc))
fn[A, B] Promise::map(x : Promise[A], resolve : (A) -> B raise, loc~ : SourceLoc) -> Promise[B]

#
Promise::new

source
#callsite(autofill(loc))
fn[A] Promise::new(x : A, loc~ : SourceLoc) -> Promise[A]

#
Promise::reject

source
fn[A] Promise::reject(error : Error) -> Promise[A]

#
Promise::resolve

source
fn[A] Promise::resolve(x : A) -> Promise[A]

#
Promise::then

source
fn[A, B] Promise::then(x : Promise[A], resolve : (A) -> Promise[B] raise, reject? : (Error) -> Promise[B]) -> Promise[B]

#
Promise::wait

source
async fn[A] Promise::wait(x : Promise[A]) -> A

#
Symbol

source
type Symbol

impl IsAny for Symbol
impl IsSymbol for Symbol
impl IsValue for Symbol

#
Value

source
pub type Value

A value that is neither null nor undefined
impl DynCast for Value
impl IsAny for Value
impl IsValue for Value
impl Show for Value

#
Value::as_any

source
fn Value::as_any(self : Value) -> Any

#
Value::as_value

source
fn Value::as_value(self : Value) -> Value

#
Value::get_type

source
fn Value::get_type(self : Value) -> String

#
Value::instance_of

source
fn Value::instance_of(self : Value, ctor : IsStringOrFunctionOrObject) -> Bool

#
Value::to_array

source
#callsite(autofill(loc))
fn[T : DynCast + IsValue + IsAny] Value::to_array(self : Value, loc~ : SourceLoc) -> Array[T] raise

#
Value::to_bigint

source
#callsite(autofill(loc))
fn Value::to_bigint(self : Value, loc~ : SourceLoc) -> Bigint raise InvalidCast

#
Value::to_boolean

source
#callsite(autofill(loc))
fn Value::to_boolean(self : Value, loc~ : SourceLoc) -> Bool raise InvalidCast

#
Value::to_error

source
#callsite(autofill(loc))
fn Value::to_error(self : Value, loc~ : SourceLoc) -> Error_ raise InvalidCast

#
Value::to_function

source
#callsite(autofill(loc))
fn Value::to_function(self : Value, loc~ : SourceLoc) -> Function raise InvalidCast

#
Value::to_number

source
#callsite(autofill(loc))
fn Value::to_number(self : Value, loc~ : SourceLoc) -> Double raise InvalidCast

#
Value::to_object

source
#callsite(autofill(loc))
fn Value::to_object(self : Value, loc~ : SourceLoc) -> Object raise InvalidCast

#
Value::to_string

source
#callsite(autofill(loc))
fn Value::to_string(self : Value, loc~ : SourceLoc) -> String raise InvalidCast

#
Value::to_symbol

source
#callsite(autofill(loc))
fn Value::to_symbol(self : Value, loc~ : SourceLoc) -> Symbol raise InvalidCast

#
catch_error

source
fn[T] catch_error(f : () -> T, on_error : (Error_) -> T raise?) -> T raise?

#
convert_error

source
fn[T] convert_error(loc : SourceLoc, f : () -> T) -> T raise

for internal use only

#
dyn_cast

source
#callsite(autofill(loc))
fn[T : DynCast + IsValue + IsAny] dyn_cast(x : IsValue, loc~ : SourceLoc) -> T raise

#
fail_cast

source
fn[T] fail_cast(target? : String) -> T raise DynCastFailed

#
global_this

source
let global_this : Object

#
launch

source
fn launch(f : async () -> Unit noraise) -> Unit

#
new

source
fn new(ctor : Function, args : Array[IsAny]) -> Object raise

#
no_raise

source
fn[T] no_raise(f : () -> T raise) -> T

#
nullable

source
fn[T] nullable(x : T) -> Nullable[T]

#
optional

source
fn[T] optional(x : T) -> Optional[T]

#
try_launch

source
fn try_launch(f : async () -> Unit) -> Unit

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io