🥮 mooncakes.io
    Sign in

    jmop

    A safe JavaScript interop tool.

    js
    ffi
    web
    Download zip
    Author
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    last year
    Downloads
    75

    No dependencies

    #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