Initial work on a more complete library

Author: garyb

bower.json

@@ -18,5 +18,12 @@
     "bower.json",
     "gulpfile.js",
     "package.json"
-  ]
+  ],
+  "dependencies": {
+    "purescript-unsafe-coerce": "^0.1.0",
+    "purescript-enums": "^0.7.0",
+    "purescript-foreign": "^0.7.0",
+    "purescript-exceptions": "~0.3.0",
+    "purescript-nullable": "~0.2.1"
+  }
 }

docs/DOM.md

@@ -29,20 +29,21 @@ gulp.task("make", function() {
   return purescript.psc({ src: sources, ffi: foreigns });
 });
 
-gulp.task("docs", ["clean-docs"], function () {
-  return purescript.pscDocs({
-      src: sources,
-      docgen: {
-        "DOM": "docs/DOM.md",
-        "DOM.File": "docs/DOM/File.md",
-        "DOM.XHR": "docs/DOM/XHR.md"
-      }
-    });
-});
+// gulp.task("docs", ["clean-docs"], function () {
+//   return purescript.pscDocs({
+//       src: sources,
+//       docgen: {
+//         "DOM": "docs/DOM.md",
+//         "DOM.File": "docs/DOM/File.md",
+//         "DOM.XHR": "docs/DOM/XHR.md"
+//       }
+//     });
+// });
 
 gulp.task("dotpsci", function () {
   return purescript.psci({ src: sources, ffi: foreigns })
     .pipe(gulp.dest("."));
 });
 
-gulp.task("default", ["make", "docs", "dotpsci"]);
+gulp.task("default", ["make", "dotpsci"]);
+// gulp.task("default", ["make", "docs", "dotpsci"]);

docs/DOM/File.md

@@ -1,13 +1,5 @@
 module DOM where
 
--- | Effect type for DOM maniupulation
+-- | Effect type for when the DOM is being manipulated or mutable values are
+-- | being read from the DOM.
 foreign import data DOM :: !
-
--- | General type for DOM documents.
-foreign import data Document :: *
-
--- | General type for DOM nodes.
-foreign import data Node :: *
-
--- | General type for DOM node lists.
-foreign import data NodeList :: *

docs/DOM/XHR.md

@@ -0,0 +1,54 @@
+/* global exports */
+"use strict";
+
+// module DOM.Event.Event
+
+exports.bubbles = function (e) {
+  return e.bubbles;
+};
+
+exports.cancelable = function (e) {
+  return e.cancelable;
+};
+
+exports.currentTarget = function (e) {
+  return e.currentTarget;
+};
+
+exports.defaultPrevented = function (e) {
+  return e.defaultPrevented;
+};
+
+exports.eventPhaseIndex = function (e) {
+  return e.eventPhase;
+};
+
+exports.target = function (e) {
+  return e.target;
+};
+
+exports.timeStamp = function (e) {
+  return e.timeStamp;
+};
+
+exports.type_ = function (e) {
+  return e.type;
+};
+
+exports.preventDefault = function (e) {
+  return function () {
+    return e.preventDefault();
+  };
+};
+
+exports.stopImmediatePropagation = function (e) {
+  return function () {
+    return e.stopImmediatePropagation();
+  };
+};
+
+exports.stopPropagation = function (e) {
+  return function () {
+    return e.stopPropagation();
+  };
+};

gulpfile.js

@@ -0,0 +1,67 @@
+module DOM.Event.Event
+  ( bubbles
+  , cancelable
+  , currentTarget
+  , defaultPrevented
+  , eventPhase
+  , eventPhaseIndex
+  , target
+  , timeStamp
+  , type_
+  , preventDefault
+  , stopImmediatePropagation
+  , stopPropagation
+  ) where
+
+import Prelude
+
+import Control.Monad.Eff (Eff())
+
+import Data.Enum (toEnum)
+import qualified Data.Maybe.Unsafe as U
+
+import DOM
+import DOM.Event.EventPhase
+import DOM.Event.Types
+import DOM.Node.Types
+
+-- | The event type.
+foreign import type_ :: Event -> EventType
+
+-- | The element that was the source of the event.
+foreign import target :: Event -> Node
+
+-- | The element that the event listener was added to.
+foreign import currentTarget :: Event -> Node
+
+-- | Indicates which phase of the event flow that is currently being processed
+-- | for the event.
+eventPhase :: Event -> EventPhase
+eventPhase = U.fromJust <<< toEnum <<< eventPhaseIndex
+
+-- | The integer value for the current event phase.
+foreign import eventPhaseIndex :: Event -> Int
+
+-- | Prevents the event from bubbling up to futher event listeners. Other event
+-- | listeners on the current target will still fire.
+foreign import stopPropagation :: Event -> Eff (dom :: DOM) Unit
+
+-- | Prevents all other listeners for the event from being called. This includes
+-- | event listeners added to the current target after the current listener.
+foreign import stopImmediatePropagation :: Event -> Eff (dom :: DOM) Unit
+
+-- | Indicates whether the event will bubble up through the DOM or not.
+foreign import bubbles :: Event -> Boolean
+
+-- | Indicates whether the event can be cancelled.
+foreign import cancelable :: Event -> Boolean
+
+-- | Cancels the event if it can be cancelled.
+foreign import preventDefault :: Event -> Eff (dom :: DOM) Unit
+
+-- | Indicates whether `preventDefault` was called on the event.
+foreign import defaultPrevented :: Event -> Boolean
+
+-- | The time in milliseconds between 01/01/1970 and when the event was
+-- | dispatched.
+foreign import timeStamp :: Event -> Number

src/DOM.purs

@@ -0,0 +1,48 @@
+module DOM.Event.EventPhase (EventPhase(..)) where
+
+import Prelude
+
+import Data.Enum (Enum, Cardinality(..), defaultSucc, defaultPred, toEnum, fromEnum)
+import Data.Maybe (Maybe(..))
+
+data EventPhase
+  = None
+  | Capturing
+  | AtTarget
+  | Bubbling
+
+instance eqEventPhase :: Eq EventPhase where
+  eq None None = true
+  eq Capturing Capturing = true
+  eq AtTarget AtTarget = true
+  eq Bubbling Bubbling = true
+  eq _ _ = false
+
+instance ordEventPhase :: Ord EventPhase where
+  compare x y = compare (fromEnumEventPhase x) (fromEnumEventPhase y)
+
+instance boundedEventPhase :: Bounded EventPhase where
+  bottom = None
+  top = Bubbling
+
+instance boundedOrdEventPhase :: BoundedOrd EventPhase
+
+instance enumEventPhase :: Enum EventPhase where
+  cardinality = Cardinality 4
+  succ = defaultSucc toEnumEventPhase fromEnumEventPhase
+  pred = defaultPred toEnumEventPhase fromEnumEventPhase
+  toEnum = toEnumEventPhase
+  fromEnum = fromEnumEventPhase
+
+toEnumEventPhase :: Int -> Maybe EventPhase
+toEnumEventPhase 0 = Just None
+toEnumEventPhase 1 = Just Capturing
+toEnumEventPhase 2 = Just AtTarget
+toEnumEventPhase 3 = Just Bubbling
+toEnumEventPhase _ = Nothing
+
+fromEnumEventPhase :: EventPhase -> Int
+fromEnumEventPhase None = 0
+fromEnumEventPhase Capturing = 1
+fromEnumEventPhase AtTarget = 2
+fromEnumEventPhase Bubbling = 3

src/DOM/Event/Event.js

@@ -0,0 +1,44 @@
+/* global exports */
+"use strict";
+
+// module DOM.Event.EventTarget
+
+exports.eventListener = function (fn) {
+  return function (event) {
+    return fn(event)();
+  };
+};
+
+exports.addEventListener = function (type) {
+  return function (listener) {
+    return function (useCapture) {
+      return function (target) {
+        return function () {
+          target.addEventListener(type, listener, useCapture);
+          return {};
+        };
+      };
+    };
+  };
+};
+
+exports.removeEventListener = function (type) {
+  return function (listener) {
+    return function (useCapture) {
+      return function (target) {
+        return function () {
+          target.removeEventListener(type, listener, useCapture);
+          return {};
+        };
+      };
+    };
+  };
+};
+
+exports.dispatchEvent = function (event) {
+  return function (target) {
+    return function () {
+      return target.dispatchEvent(event);
+    };
+  };
+};