@tellahq/rescript 10.1.0-alpha.1

package/lib/ocaml/jsxEvent.ml

@@ -0,0 +1,358 @@
+(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a later version).
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+type 'a synthetic
+
+module MakeEventWithType (Type : sig
+  type t
+end) =
+struct
+  external bubbles : Type.t -> bool = "bubbles" [@@bs.get]
+  external cancelable : Type.t -> bool = "cancelable" [@@bs.get]
+  external currentTarget : Type.t -> < .. > = "currentTarget" [@@bs.get]
+
+  (* Should return Dom.eventTarget *)
+  external defaultPrevented : Type.t -> bool = "defaultPrevented" [@@bs.get]
+  external eventPhase : Type.t -> int = "eventPhase" [@@bs.get]
+  external isTrusted : Type.t -> bool = "isTrusted" [@@bs.get]
+  external nativeEvent : Type.t -> < .. > = "nativeEvent" [@@bs.get]
+
+  (* Should return Dom.event *)
+  external preventDefault : Type.t -> unit = "preventDefault" [@@bs.send]
+
+  external isDefaultPrevented : Type.t -> bool = "isDefaultPrevented"
+    [@@bs.send]
+
+  external stopPropagation : Type.t -> unit = "stopPropagation" [@@bs.send]
+
+  external isPropagationStopped : Type.t -> bool = "isPropagationStopped"
+    [@@bs.send]
+
+  external target : Type.t -> < .. > = "target" [@@bs.get]
+
+  (* Should return Dom.eventTarget *)
+  external timeStamp : Type.t -> float = "timeStamp" [@@bs.get]
+  external type_ : Type.t -> string = "type" [@@bs.get]
+  external persist : Type.t -> unit = "persist" [@@bs.send]
+end
+
+module Synthetic = struct
+  type tag
+  type t = tag synthetic
+
+  external bubbles : 'a synthetic -> bool = "bubbles" [@@bs.get]
+  external cancelable : 'a synthetic -> bool = "cancelable" [@@bs.get]
+  external currentTarget : 'a synthetic -> < .. > = "currentTarget" [@@bs.get]
+  (* Should return Dom.eventTarget *)
+
+  external defaultPrevented : 'a synthetic -> bool = "defaultPrevented"
+    [@@bs.get]
+
+  external eventPhase : 'a synthetic -> int = "eventPhase" [@@bs.get]
+  external isTrusted : 'a synthetic -> bool = "isTrusted" [@@bs.get]
+  external nativeEvent : 'a synthetic -> < .. > = "nativeEvent" [@@bs.get]
+
+  (* Should return Dom.event *)
+  external preventDefault : 'a synthetic -> unit = "preventDefault" [@@bs.send]
+
+  external isDefaultPrevented : 'a synthetic -> bool = "isDefaultPrevented"
+    [@@bs.send]
+
+  external stopPropagation : 'a synthetic -> unit = "stopPropagation"
+    [@@bs.send]
+
+  external isPropagationStopped : 'a synthetic -> bool = "isPropagationStopped"
+    [@@bs.send]
+
+  external target : 'a synthetic -> < .. > = "target" [@@bs.get]
+
+  (* Should return Dom.eventTarget *)
+  external timeStamp : 'a synthetic -> float = "timeStamp" [@@bs.get]
+  external type_ : 'a synthetic -> string = "type" [@@bs.get]
+  external persist : 'a synthetic -> unit = "persist" [@@bs.send]
+end
+
+(* Cast any event type to the general synthetic type. This is safe, since synthetic is more general *)
+external toSyntheticEvent : 'a synthetic -> Synthetic.t = "%identity"
+
+module Clipboard = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external clipboardData : t -> < .. > = "clipboardData" [@@bs.get]
+  (* Should return Dom.dataTransfer *)
+end
+
+module Composition = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external data : t -> string = "data" [@@bs.get]
+end
+
+module Keyboard = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external altKey : t -> bool = "altKey" [@@bs.get]
+  external charCode : t -> int = "charCode" [@@bs.get]
+  external ctrlKey : t -> bool = "ctrlKey" [@@bs.get]
+
+  external getModifierState : t -> string -> bool = "getModifierState"
+    [@@bs.send]
+
+  external key : t -> string = "key" [@@bs.get]
+  external keyCode : t -> int = "keyCode" [@@bs.get]
+  external locale : t -> string = "locale" [@@bs.get]
+  external location : t -> int = "location" [@@bs.get]
+  external metaKey : t -> bool = "metaKey" [@@bs.get]
+  external repeat : t -> bool = "repeat" [@@bs.get]
+  external shiftKey : t -> bool = "shiftKey" [@@bs.get]
+  external which : t -> int = "which" [@@bs.get]
+end
+
+module Focus = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external relatedTarget : t -> < .. > option = "relatedTarget"
+    [@@bs.get] [@@bs.return nullable]
+  (* Should return Dom.eventTarget *)
+end
+
+module Form = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+end
+
+module Mouse = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external altKey : t -> bool = "altKey" [@@bs.get]
+  external button : t -> int = "button" [@@bs.get]
+  external buttons : t -> int = "buttons" [@@bs.get]
+  external clientX : t -> int = "clientX" [@@bs.get]
+  external clientY : t -> int = "clientY" [@@bs.get]
+  external ctrlKey : t -> bool = "ctrlKey" [@@bs.get]
+
+  external getModifierState : (t -> string) -> bool = "getModifierState"
+    [@@bs.get]
+
+  external metaKey : t -> bool = "metaKey" [@@bs.get]
+  external movementX : t -> int = "movementX" [@@bs.get]
+  external movementY : t -> int = "movementY" [@@bs.get]
+  external pageX : t -> int = "pageX" [@@bs.get]
+  external pageY : t -> int = "pageY" [@@bs.get]
+
+  external relatedTarget : t -> < .. > option = "relatedTarget"
+    [@@bs.get] [@@bs.return nullable]
+
+  (* Should return Dom.eventTarget *)
+  external screenX : t -> int = "screenX" [@@bs.get]
+  external screenY : t -> int = "screenY" [@@bs.get]
+  external shiftKey : t -> bool = "shiftKey" [@@bs.get]
+end
+
+module Pointer = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  (* UIEvent *)
+  external detail : t -> int = "detail"
+    [@@bs.get]
+    (* external view : t -> Dom.window = "view" *)
+    (* Should return DOMAbstractView/WindowProxy *)
+    [@@bs.get]
+
+  (* MouseEvent *)
+  external screenX : t -> int = "screenX" [@@bs.get]
+  external screenY : t -> int = "screenY" [@@bs.get]
+  external clientX : t -> int = "clientX" [@@bs.get]
+  external clientY : t -> int = "clientY" [@@bs.get]
+  external pageX : t -> int = "pageX" [@@bs.get]
+  external pageY : t -> int = "pageY" [@@bs.get]
+  external movementX : t -> int = "movementX" [@@bs.get]
+  external movementY : t -> int = "movementY" [@@bs.get]
+  external ctrlKey : t -> bool = "ctrlKey" [@@bs.get]
+  external shiftKey : t -> bool = "shiftKey" [@@bs.get]
+  external altKey : t -> bool = "altKey" [@@bs.get]
+  external metaKey : t -> bool = "metaKey" [@@bs.get]
+
+  external getModifierState : (t -> string) -> bool = "getModifierState"
+    [@@bs.get]
+
+  external button : t -> int = "button" [@@bs.get]
+  external buttons : t -> int = "buttons" [@@bs.get]
+
+  external relatedTarget : t -> < .. > option = "relatedTarget"
+    [@@bs.get] [@@bs.return nullable]
+  (* Should return Dom.eventTarget *)
+
+  (* PointerEvent *)
+  (* external pointerId : t -> Dom.eventPointerId = "pointerId" [@@bs.get] *)
+  external width : t -> float = "width" [@@bs.get]
+  external height : t -> float = "height" [@@bs.get]
+  external pressure : t -> float = "pressure" [@@bs.get]
+  external tangentialPressure : t -> float = "tangentialPressure" [@@bs.get]
+  external tiltX : t -> int = "tiltX" [@@bs.get]
+  external tiltY : t -> int = "tiltY" [@@bs.get]
+  external twist : t -> int = "twist" [@@bs.get]
+  external pointerType : t -> string = "pointerType" [@@bs.get]
+  external isPrimary : t -> bool = "isPrimary" [@@bs.get]
+end
+
+module Selection = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+end
+
+module Touch = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external altKey : t -> bool = "altKey" [@@bs.get]
+  external changedTouches : t -> < .. > = "changedTouches" [@@bs.get]
+  (* Should return Dom.touchList *)
+
+  external ctrlKey : t -> bool = "ctrlKey" [@@bs.get]
+
+  external getModifierState : (t -> string) -> bool = "getModifierState"
+    [@@bs.send]
+
+  external metaKey : t -> bool = "metaKey" [@@bs.get]
+  external shiftKey : t -> bool = "shiftKey" [@@bs.get]
+  external targetTouches : t -> < .. > = "targetTouches" [@@bs.get]
+  (* Should return Dom.touchList *)
+
+  external touches : t -> < .. > = "touches" [@@bs.get]
+  (* Should return Dom.touchList *)
+end
+
+module UI = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external detail : t -> int = "detail" [@@bs.get]
+  (* external view : t -> Dom.window = "view" [@@bs.get] *)
+  (* Should return DOMAbstractView/WindowProxy *)
+end
+
+module Wheel = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external deltaMode : t -> int = "deltaMode" [@@bs.get]
+  external deltaX : t -> float = "deltaX" [@@bs.get]
+  external deltaY : t -> float = "deltaY" [@@bs.get]
+  external deltaZ : t -> float = "deltaZ" [@@bs.get]
+end
+
+module Media = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+end
+
+module Image = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+end
+
+module Animation = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external animationName : t -> string = "animationName" [@@bs.get]
+  external pseudoElement : t -> string = "pseudoElement" [@@bs.get]
+  external elapsedTime : t -> float = "elapsedTime" [@@bs.get]
+end
+
+module Transition = struct
+  type tag
+  type t = tag synthetic
+
+  include MakeEventWithType (struct
+    type nonrec t = t
+  end)
+
+  external propertyName : t -> string = "propertyName" [@@bs.get]
+  external pseudoElement : t -> string = "pseudoElement" [@@bs.get]
+  external elapsedTime : t -> float = "elapsedTime" [@@bs.get]
+end

package/lib/ocaml/lazy.ml

@@ -0,0 +1,70 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 OCaml                                  *)
+(*                                                                        *)
+(*             Damien Doligez, projet Para, INRIA Rocquencourt            *)
+(*                                                                        *)
+(*   Copyright 1997 Institut National de Recherche en Informatique et     *)
+(*     en Automatique.                                                    *)
+(*                                                                        *)
+(*   All rights reserved.  This file is distributed under the terms of    *)
+(*   the GNU Lesser General Public License version 2.1, with the          *)
+(*   special exception on linking described in the file LICENSE.          *)
+(*                                                                        *)
+(**************************************************************************)
+
+(* Module [Lazy]: deferred computations *)
+
+
+(*
+   WARNING: some purple magic is going on here.  Do not take this file
+   as an example of how to program in OCaml.
+*)
+
+
+(* We make use of two special tags provided by the runtime:
+   [lazy_tag] and [forward_tag].
+
+   A value of type ['a Lazy.t] can be one of three things:
+   1. A block of size 1 with tag [lazy_tag].  Its field is a closure of
+      type [unit -> 'a] that computes the value.
+   2. A block of size 1 with tag [forward_tag].  Its field is the value
+      of type ['a] that was computed.
+   3. Anything else except a float.  This has type ['a] and is the value
+      that was computed.
+   Exceptions are stored in format (1).
+   The GC will magically change things from (2) to (3) according to its
+   fancy.
+
+   If OCaml was configured with the -flat-float-array option (which is
+   currently the default), the following is also true:
+   We cannot use representation (3) for a [float Lazy.t] because
+   [caml_make_array] assumes that only a [float] value can have tag
+   [Double_tag].
+
+   We have to use the built-in type constructor [lazy_t] to
+   let the compiler implement the special typing and compilation
+   rules for the [lazy] keyword.
+*)
+
+type 'a t = 'a lazy_t
+
+exception Undefined = CamlinternalLazy.Undefined
+
+external force : 'a t -> 'a = "%lazy_force"
+
+(* let force = force *)
+
+let force_val = CamlinternalLazy.force_val
+
+let from_fun f = lazy (f ())
+
+let from_val v = lazy v 
+
+let is_val = CamlinternalLazy.is_val
+
+let lazy_from_fun = from_fun
+
+let lazy_from_val = from_val
+
+let lazy_is_val = is_val

package/lib/ocaml/lazy.mli

@@ -0,0 +1,95 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 OCaml                                  *)
+(*                                                                        *)
+(*             Damien Doligez, projet Para, INRIA Rocquencourt            *)
+(*                                                                        *)
+(*   Copyright 1997 Institut National de Recherche en Informatique et     *)
+(*     en Automatique.                                                    *)
+(*                                                                        *)
+(*   All rights reserved.  This file is distributed under the terms of    *)
+(*   the GNU Lesser General Public License version 2.1, with the          *)
+(*   special exception on linking described in the file LICENSE.          *)
+(*                                                                        *)
+(**************************************************************************)
+
+(** Deferred computations. *)
+
+type 'a t = 'a lazy_t
+(** A value of type ['a Lazy.t] is a deferred computation, called
+   a suspension, that has a result of type ['a].  The special
+   expression syntax [lazy (expr)] makes a suspension of the
+   computation of [expr], without computing [expr] itself yet.
+   "Forcing" the suspension will then compute [expr] and return its
+   result.
+
+   Note: [lazy_t] is the built-in type constructor used by the compiler
+   for the [lazy] keyword.  You should not use it directly.  Always use
+   [Lazy.t] instead.
+
+   Note: [Lazy.force] is not thread-safe.  If you use this module in
+   a multi-threaded program, you will need to add some locks.
+
+   Note: if the program is compiled with the [-rectypes] option,
+   ill-founded recursive definitions of the form [let rec x = lazy x]
+   or [let rec x = lazy(lazy(...(lazy x)))] are accepted by the type-checker
+   and lead, when forced, to ill-formed values that trigger infinite
+   loops in the garbage collector and other parts of the run-time system.
+   Without the [-rectypes] option, such ill-founded recursive definitions
+   are rejected by the type-checker.
+*)
+
+
+exception Undefined
+
+(* val force : 'a t -> 'a  *)
+external force : 'a t -> 'a = "%lazy_force"
+(** [force x] forces the suspension [x] and returns its result.
+   If [x] has already been forced, [Lazy.force x] returns the
+   same value again without recomputing it.  If it raised an exception,
+   the same exception is raised again.
+   Raise {!Undefined} if the forcing of [x] tries to force [x] itself
+   recursively.
+*)
+
+val force_val : 'a t -> 'a
+(** [force_val x] forces the suspension [x] and returns its
+    result.  If [x] has already been forced, [force_val x]
+    returns the same value again without recomputing it.
+    Raise {!Undefined} if the forcing of [x] tries to force [x] itself
+    recursively.
+    If the computation of [x] raises an exception, it is unspecified
+    whether [force_val x] raises the same exception or {!Undefined}.
+*)
+
+val from_fun : (unit -> 'a) -> 'a t
+(** [from_fun f] is the same as [lazy (f ())] but slightly more efficient.
+
+    [from_fun] should only be used if the function [f] is already defined.
+    In particular it is always less efficient to write
+    [from_fun (fun () -> expr)] than [lazy expr].
+
+    @since 4.00.0 *)
+
+val from_val : 'a -> 'a t
+(** [from_val v] returns an already-forced suspension of [v].
+    This is for special purposes only and should not be confused with
+    [lazy (v)].
+    @since 4.00.0 *)
+
+val is_val : 'a t -> bool
+(** [is_val x] returns [true] if [x] has already been forced and
+    did not raise an exception.
+    @since 4.00.0 *)
+
+val lazy_from_fun : (unit -> 'a) -> 'a t
+  [@@ocaml.deprecated "Use Lazy.from_fun instead."]
+(** @deprecated synonym for [from_fun]. *)
+
+val lazy_from_val : 'a -> 'a t
+  [@@ocaml.deprecated "Use Lazy.from_val instead."]
+(** @deprecated synonym for [from_val]. *)
+
+val lazy_is_val : 'a t -> bool
+  [@@ocaml.deprecated "Use Lazy.is_val instead."]
+(** @deprecated synonym for [is_val]. *)