package ezjs_min

You can search for identifiers within the package.

in-package search v0.2.0

package ezjs_min

ezjs_min
- Ezjs_min
  - AOpt
  - BigInt
    
    bigInt
  - Log
  - Promise
    
    promise
    
    promise0
  - Table
  - bigInt
  - date
  - date_constr
  - error
  - js_array
  - js_string
  - json
  - match_result
  - math
  - number
  - regExp
  - string_constr
ezjs_min.lwt
- Ezjs_min_lwt
  - Promise
    
    promise
    
    promise0
  - bigInt
  - date
  - date_constr
  - error
  - js_array
  - js_string
  - json
  - match_result
  - math
  - number
  - regExp
  - string_constr

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Ezjs_min end

module Ezjs_dom = Ezjs_min.Ezjs_dom

module Log = Ezjs_min.Log

include module type of struct include Js_of_ocaml.Js end

Dealing with `null` and `undefined` values.

type +'a opt = 'a Js_of_ocaml.Js.opt

Type of possibly null values.

type +'a optdef = 'a Js_of_ocaml.Js.optdef

Type of possibly undefined values.

val null : 'a opt

The null value.

val some : 'a -> 'a opt

Consider a value into a possibly null value.

val undefined : 'a optdef

The undefined value

val def : 'a -> 'a optdef

Consider a value into a possibly undefined value.

module type OPT = Ezjs_min.OPT

Signatures of a set of standard functions for manipulating optional values.

module Opt = Ezjs_min.Opt

Standard functions for manipulating possibly null values.

module Optdef = Ezjs_min.Optdef

Standard functions for manipulating possibly undefined values.

Types for specifying method and properties of Javascript objects

type +'a t = 'a Js_of_ocaml.Js.t

Type of Javascript objects. The type parameter is used to specify more precisely an object.

type +'a meth = 'a Js_of_ocaml.Js.meth

Type used to specify method types: a Javascript object <m : t1 -> t2 -> ... -> tn -> t Js.meth> Js.t has a Javascript method m expecting n arguments of types t1 to tn and returns a value of type t.

type +'a gen_prop = 'a Js_of_ocaml.Js.gen_prop

Type used to specify the properties of Javascript objects. In practice you should rarely need this type directly, but should rather use the type abbreviations below instead.

type 'a readonly_prop = < get : 'a > gen_prop

Type of read-only properties: a Javascript object <p : t Js.readonly_prop> Js.t has a read-only property p of type t.

type 'a writeonly_prop = < set : 'a -> unit > gen_prop

Type of write-only properties: a Javascript object <p : t Js.writeonly_prop> Js.t has a write-only property p of type t.

type 'a prop = < get : 'a ; set : 'a -> unit > gen_prop

Type of read/write properties: a Javascript object <p : t Js.writeonly_prop> Js.t has a read/write property p of type t.

type 'a optdef_prop = < get : 'a optdef ; set : 'a -> unit > gen_prop

Type of read/write properties that may be undefined: you can set them to a value of some type t, but if you read them, you will get a value of type t optdef (that may be undefined).

Object constructors

type +'a constr = 'a Js_of_ocaml.Js.constr

A value of type (t1 -> ... -> tn -> t Js.t) Js.constr is a Javascript constructor expecting n arguments of types t1 to tn and returning a Javascript object of type t Js.t. Use the syntax extension new%js c e1 ... en to build an object using constructor c and arguments e1 to en.

Callbacks to OCaml

type (-'a, +'b) meth_callback = ('a, 'b) Js_of_ocaml.Js.meth_callback

Type of callback functions. A function of type (u, t1 -> ... -> tn -> t) meth_callback can be called from Javascript with this bound to a value of type u and up to n arguments of types t1 to tn. The system takes care of currification, so less than n arguments can be provided. As a special case, a callback of type (t, unit -> t) meth_callback can be called from Javascript with no argument. It will behave as if it was called with a single argument of type unit.

type 'a callback = (unit, 'a) meth_callback

Type of callback functions intended to be called without a meaningful this implicit parameter.

val wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback

Wrap an OCaml function so that it can be invoked from Javascript.

val wrap_meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback

Wrap an OCaml function so that it can be invoked from Javascript. The first parameter of the function will be bound to the value of the this implicit parameter.

Javascript comparisons

val equals : _ t -> _ t -> bool

Javascript == equality operator.

val strict_equals : _ t -> _ t -> bool

Javascript === equality operator.

Javascript standard objects

val _true : bool t

Javascript true boolean.

val _false : bool t

Javascript false boolean.

type match_result_handle = Js_of_ocaml.Js.match_result_handle

A handle to a match result. Use function Js.match_result to get the corresponding MatchResult object. (This type is used to resolved the mutual dependency between string and array type definitions.)

type string_array = Js_of_ocaml.Js.string_array

Opaque type for string arrays. You can get the actual Array object using function Js.str_array. (This type is used to resolved the mutual dependency between string and array type definitions.)

type normalization = Js_of_ocaml.Js.normalization

Opaque type for Unicode normalization forms.

val nfd : normalization t

Canonical Decomposition

val nfc : normalization t

Canonical Decomposition, followed by Canonical Composition

val nfkd : normalization t

Compatibility Decomposition

val nfkc : normalization t

Compatibility Decomposition, followed by Canonical Composition

Specification of Javascript number objects.

type number_t = float

class type number = object ... end

class type js_string = object ... end

Specification of Javascript string objects.

class type regExp = object ... end

Specification of Javascript regular expression objects.

class type string_constr = object ... end

Specification of the string constructor, considered as an object.

val string_constr : string_constr t

The string constructor, as an object.

val regExp : (js_string t -> regExp t) constr

Constructor of RegExp objects. The expression new%js regExp s builds the regular expression specified by string s.

val regExp_withFlags : (js_string t -> js_string t -> regExp t) constr

Constructor of RegExp objects. The expression new%js regExp s f builds the regular expression specified by string s using flags f.

val regExp_copy : (regExp t -> regExp t) constr

Constructor of RegExp objects. The expression new%js regExp r builds a copy of regular expression r.

class type 'a js_array = object ... end

Specification of Javascript regular arrays. Use Js.array_get and Js.array_set to access and set array elements.

val object_keys : 'a t -> js_string t js_array t

Returns jsarray containing keys of the object as Object.keys does.

val array_empty : 'a js_array t constr

Constructor of Array objects. The expression new%js array_empty returns an empty array.

val array_length : (int -> 'a js_array t) constr

Constructor of Array objects. The expression new%js array_length l returns an array of length l.

val array_get : 'a js_array t -> int -> 'a optdef

Array access: array_get a i returns the element at index i of array a. Returns undefined if there is no element at this index.

val array_set : 'a js_array t -> int -> 'a -> unit

Array update: array_set a i v puts v at index i in array a.

val array_map : ('a -> 'b) -> 'a js_array t -> 'b js_array t

Array map: array_map f a is a##map(wrap_callback (fun elt idx arr -> f elt)).

val array_mapi : (int -> 'a -> 'b) -> 'a js_array t -> 'b js_array t

Array mapi: array_mapi f a is a##map(wrap_callback (fun elt idx arr -> f idx elt)).

class type match_result = object ... end

Specification of match result objects

val str_array : string_array t -> js_string t js_array t

Convert an opaque string_array t object into an array of string. (Used to resolved the mutual dependency between string and array type definitions.)

val match_result : match_result_handle t -> match_result t

Convert a match result handle into a MatchResult object. (Used to resolved the mutual dependency between string and array type definitions.)

class type date = object ... end

Specification of Javascript date objects.

val date_now : date t constr

Constructor of Date objects: new%js date_now returns a Date object initialized with the current date.

val date_fromTimeValue : (number_t -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue t returns a Date object initialized with the time value t.

val date_month : (int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m returns a Date object corresponding to year y and month m.

val date_day : (int -> int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m d returns a Date object corresponding to year y, month m and day d.

val date_hour : (int -> int -> int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m d h returns a Date object corresponding to year y to hour h.

val date_min : (int -> int -> int -> int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m d h m' returns a Date object corresponding to year y to minute m'.

val date_sec : (int -> int -> int -> int -> int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m d h m' s returns a Date object corresponding to year y to second s.

val date_ms : (int -> int -> int -> int -> int -> int -> int -> date t) constr

Constructor of Date objects: new%js date_fromTimeValue y m d h m' s ms returns a Date object corresponding to year y to millisecond ms.

class type date_constr = object ... end

Specification of the date constructor, considered as an object.

val date : date_constr t

The date constructor, as an object.

class type math = object ... end

Specification of Javascript math object.

val math : math t

The Math object

class type error = object ... end

Specification of Javascript error object.

val error_constr : (js_string t -> error t) constr

Constructor of Error objects: new%js error_constr msg returns an Error object with the message msg.

module Js_error = Ezjs_min.Js_error

class type json = object ... end

Specification of Javascript JSON object.

val _JSON : json t

JSON object

Standard Javascript functions

val decodeURI : js_string t -> js_string t

Decode a URI: replace by the corresponding byte all escape sequences but the ones corresponding to a URI reserved character and convert the string from UTF-8 to UTF-16.

val decodeURIComponent : js_string t -> js_string t

Decode a URIComponent: replace all escape sequences by the corresponding byte and convert the string from UTF-8 to UTF-16.

val encodeURI : js_string t -> js_string t

Encode a URI: convert the string to UTF-8 and replace all unsafe bytes by the corresponding escape sequence.

val encodeURIComponent : js_string t -> js_string t

Same as encodeURI, but also encode URI reserved characters.

val escape : js_string t -> js_string t

Escape a string: unsafe UTF-16 code points are replaced by 2-digit and 4-digit escape sequences.

val unescape : js_string t -> js_string t

Unescape a string: 2-digit and 4-digit escape sequences are replaced by the corresponding UTF-16 code point.

val isNaN : 'a -> bool

val parseInt : js_string t -> int

val parseFloat : js_string t -> number_t

Conversion functions between Javascript and OCaml types

val bool : bool -> bool t

Conversion of booleans from OCaml to Javascript.

val to_bool : bool t -> bool

Conversion of booleans from Javascript to OCaml.

val string : string -> js_string t

Conversion of strings from OCaml to Javascript. (The OCaml string is considered to be encoded in UTF-8 and is converted to UTF-16.)

val to_string : js_string t -> string

Conversion of strings from Javascript to OCaml.

val array : 'a array -> 'a js_array t

Conversion of arrays from OCaml to Javascript.

val to_array : 'a js_array t -> 'a array

Conversion of arrays from Javascript to OCaml.

val bytestring : string -> js_string t

Conversion of strings of bytes from OCaml to Javascript. (Each byte will be converted in an UTF-16 code point.)

val to_bytestring : js_string t -> string

Conversion of strings of bytes from Javascript to OCaml. (The Javascript string should only contain UTF-16 code points below 255.)

val float : float -> number_t

Conversion of OCaml floats to Javascript numbers.

val to_float : number_t -> float

Conversion of Javascript numbers to OCaml floats.

val number_of_float : float -> number t

Conversion of OCaml floats to Javascript number objects.

val float_of_number : number t -> float

Conversion of Javascript number objects to OCaml floats.

val int32 : int32 -> number_t

Conversion of OCaml floats to Javascript numbers.

val to_int32 : number_t -> int32

Conversion of Javascript numbers to OCaml 32-bits. The given floating-point number is truncated to an integer.

val nativeint : nativeint -> number_t

Conversion of OCaml 32-bits integers to Javascript numbers.

val to_nativeint : number_t -> nativeint

Conversion of Javascript numbers to OCaml native integers. The given floating-point number is truncated to an integer.

Convenience coercion functions

val coerce : 'a -> ('a -> 'b Opt.t) -> ('a -> 'b) -> 'b

Apply a possibly failing coercion function. coerce v c f attempts to apply coercion c to value v. If the coercion returns null, function f is called.

val coerce_opt : 'a Opt.t -> ('a -> 'b Opt.t) -> ('a -> 'b) -> 'b

Apply a possibly failing coercion function. coerce_opt v c f attempts to apply coercion c to value v. If v is null or the coercion returns null, function f is called. Typical usage is the following:

Js.coerce_opt (Dom_html.document##getElementById id)
Dom_html.CoerceTo.div (fun _ -> assert false)

Type checking operators.

val typeof : _ t -> js_string t

Returns the type of a Javascript object.

val instanceof : _ t -> _ constr -> bool

Tests whether a Javascript object is an instance of a given class.

Debugging operations.

val debugger : unit -> unit

Invokes any available debugging functionality. If no debugging functionality is available, it has no effect. In practice, it will insert a "debugger;" statement in the generated javascript.

Export functionality.

Export values to module.exports if it exists or to the global object otherwise.

val export : string -> 'a -> unit

export name value export name

val export_all : 'a t -> unit

export_all obj export every key of obj object.

export_all
  object%js
    method add x y = x +. y
    method abs x = abs_float x
    val zero = 0.
  end

Unsafe operations.

module Unsafe = Ezjs_min.Unsafe

Unsafe Javascript operations

Deprecated functions and types.

val string_of_error : error t -> string

deprecated [since 4.0] Use [Js_error.to_string] instead.

val raise_js_error : error t -> 'a

deprecated [since 4.0] Use [Js_error.raise_] instead.

val exn_with_js_backtrace : exn -> force:bool -> exn

Attach a JavasScript error to an OCaml exception. if force = false and a JavasScript error is already attached, it will do nothing. This function is useful to store and retrieve information about JavaScript stack traces.

Attaching JavasScript errors will happen automatically when compiling with --enable with-js-error.

deprecated [since 4.0] Use [Js_error.raise_] instead.

val js_error_of_exn : exn -> error t opt

Extract a JavaScript error attached to an OCaml exception, if any. This is useful to inspect an eventual stack strace, especially when sourcemap is enabled.

deprecated [since 4.0] Use [Js_error.of_exn] instead.

exception Error of error t

The Error exception wrap javascript exceptions when caught by OCaml code. In case the javascript exception is not an instance of javascript Error, it will be serialized and wrapped into a Failure exception.

deprecated [since 4.0] Use [Js_error.Exn] instead.

type float_prop = number_t prop

deprecated [since 2.0].

Type of float properties.

module Url = Ezjs_min.Url

module Dom_html = Ezjs_min.Dom_html

module Firebug = Ezjs_min.Firebug

module File = Ezjs_min.File

module Dom = Ezjs_min.Dom

module Typed_array = Ezjs_min.Typed_array

module Regexp = Ezjs_min.Regexp

type ('a, 'b) result = ('a, 'b) result =

| Ok of 'a
| Error of 'b

type window = Dom_html.window

val to_arrayf : ('a -> 'b) -> 'a js_array t -> 'b array

val of_arrayf : ('a -> 'b) -> 'a array -> 'b js_array t

val to_list : 'a js_array t -> 'a list

val of_list : 'a list -> 'a js_array t

val to_listf : ('a -> 'b) -> 'a js_array t -> 'b list

val of_listf : ('a -> 'b) -> 'a list -> 'b js_array t

val optdef : ('a -> 'b) -> 'a option -> 'b optdef

val to_optdef : ('a -> 'b) -> 'a Optdef.t -> 'b option

val unoptdef_f : 'a -> ('b -> 'a) -> 'b Optdef.t -> 'a

val unoptdef : 'a -> 'a Optdef.t -> 'a

val convdef : ('a -> 'b) -> 'a Optdef.t -> 'b optdef

val to_opt : ('a -> 'b) -> 'a Opt.t -> 'b option

val opt : ('a -> 'b) -> 'a option -> 'b opt

val convopt : ('a -> 'b) -> 'a Opt.t -> 'b opt

val js_log : 't0 -> unit

val log_str : string -> unit

val log : ('a, Format.formatter, unit, unit) format4 -> 'a

val error_of_string : string -> error Js_of_ocaml.Js.t

val catch_exn : (Js_error.error_t -> 'a) -> exn -> 'a

module AOpt = Ezjs_min.AOpt

type 'a aopt = 'a AOpt.t

type 'a case_prop = < get : 'a optdef > gen_prop

val choose_case_opt : 'a Optdef.t list -> 'a optdef

val choose_case : 'a list -> 'a optdef

val object_cs : 'res

val assign : 'a t -> 'b t -> 'c Js_of_ocaml__Js.t

val assign_list : Unsafe.any list -> 'a Js_of_ocaml__Js.t

val remove_undefined : 'a t -> unit

module Table = Ezjs_min.Table

module BigInt = Ezjs_min.BigInt

class type bigInt = BigInt.bigInt

module Promise : sig ... end

package ezjs_min

Dealing with null and undefined values.

Types for specifying method and properties of Javascript objects

Object constructors

Callbacks to OCaml

Javascript comparisons

Javascript standard objects

Standard Javascript functions

Conversion functions between Javascript and OCaml types

Convenience coercion functions

Type checking operators.

Debugging operations.

Export functionality.

Unsafe operations.

Deprecated functions and types.

Dealing with `null` and `undefined` values.