{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE UnboxedTuples #-}
-----------------------------------------------------------------------------
--
-- Module      :  Language.Javascript.JSaddle.Native
-- Copyright   :  (c) Hamish Mackenzie
-- License     :  MIT
--
-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>
--
-- |
--
-----------------------------------------------------------------------------

module Language.Javascript.JSaddle.Native.Internal (
    wrapJSVal
  , wrapJSString
  , withJSVal
  , withJSVals
  , withObject
  , withJSString
  , setPropertyByName
  , setPropertyAtIndex
  , stringToValue
  , numberToValue
  , jsonValueToValue
  , getPropertyByName
  , getPropertyAtIndex
  , callAsFunction
  , callAsConstructor
  , newEmptyObject
  , newAsyncCallback
  , newSyncCallback
  , newArray
  , evaluateScript
  , deRefVal
  , valueToBool
  , valueToNumber
  , valueToString
  , valueToJSON
  , valueToJSONValue
  , isNull
  , isUndefined
  , strictEqual
  , instanceOf
  , propertyNames
) where

import Control.Monad.IO.Class (MonadIO(..))

import Data.Aeson (Value)

import Language.Javascript.JSaddle.Types
       (AsyncCommand(..), JSM(..), JSString(..), addCallback,
        Object(..), JSVal(..), JSValueForSend(..), JSCallAsFunction,
        JSStringReceived(..), JSStringForSend(..), JSObjectForSend(..))
import Language.Javascript.JSaddle.Monad (askJSM)
import Language.Javascript.JSaddle.Run
       (Command(..), Result(..), sendCommand,
        sendAsyncCommand, sendLazyCommand, wrapJSVal)
import GHC.IORef (IORef(..), readIORef)
import GHC.STRef (STRef(..))
import GHC.IO (IO(..))
import GHC.Base (touch#)

wrapJSString :: MonadIO m => JSStringReceived -> m JSString
wrapJSString :: forall (m :: * -> *). MonadIO m => JSStringReceived -> m JSString
wrapJSString (JSStringReceived Text
ref) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> JSString
JSString Text
ref

touchIORef :: IORef a -> IO ()
touchIORef :: forall a. IORef a -> IO ()
touchIORef (IORef (STRef MutVar# RealWorld a
r#)) = forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case touch# :: forall a. a -> State# RealWorld -> State# RealWorld
touch# MutVar# RealWorld a
r# State# RealWorld
s of State# RealWorld
s' -> (# State# RealWorld
s', () #)

withJSVal :: MonadIO m => JSVal -> (JSValueForSend -> m a) -> m a
withJSVal :: forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal (JSVal IORef JSValueRef
ref) JSValueForSend -> m a
f = do
    a
result <- (JSValueForSend -> m a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSValueRef -> JSValueForSend
JSValueForSend) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. IORef a -> IO a
readIORef IORef JSValueRef
ref)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. IORef a -> IO ()
touchIORef IORef JSValueRef
ref
    forall (m :: * -> *) a. Monad m => a -> m a
return a
result

withJSVals :: MonadIO m => [JSVal] -> ([JSValueForSend] -> m a) -> m a
withJSVals :: forall (m :: * -> *) a.
MonadIO m =>
[JSVal] -> ([JSValueForSend] -> m a) -> m a
withJSVals [JSVal]
v [JSValueForSend] -> m a
f =
 do a
result <- [JSValueForSend] -> m a
f forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(JSVal IORef JSValueRef
ref) -> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ JSValueRef -> JSValueForSend
JSValueForSend forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IORef a -> IO a
readIORef IORef JSValueRef
ref) [JSVal]
v
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(JSVal IORef JSValueRef
ref) -> forall a. IORef a -> IO ()
touchIORef IORef JSValueRef
ref) [JSVal]
v
    forall (m :: * -> *) a. Monad m => a -> m a
return a
result

withObject :: MonadIO m => Object -> (JSObjectForSend -> m a) -> m a
withObject :: forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject (Object JSVal
o) JSObjectForSend -> m a
f = forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
o (JSObjectForSend -> m a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSValueForSend -> JSObjectForSend
JSObjectForSend)

withJSString :: MonadIO m => JSString -> (JSStringForSend -> m a) -> m a
withJSString :: forall (m :: * -> *) a.
MonadIO m =>
JSString -> (JSStringForSend -> m a) -> m a
withJSString (JSString Text
ref) JSStringForSend -> m a
f = JSStringForSend -> m a
f (Text -> JSStringForSend
JSStringForSend Text
ref)

setPropertyByName :: JSString -> JSVal -> Object -> JSM ()
setPropertyByName :: JSString -> JSVal -> Object -> JSM ()
setPropertyByName JSString
name JSVal
val Object
this =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis ->
        forall (m :: * -> *) a.
MonadIO m =>
JSString -> (JSStringForSend -> m a) -> m a
withJSString JSString
name forall a b. (a -> b) -> a -> b
$ \JSStringForSend
rname ->
            forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
val forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval ->
                AsyncCommand -> JSM ()
sendAsyncCommand forall a b. (a -> b) -> a -> b
$ JSObjectForSend
-> JSStringForSend -> JSValueForSend -> AsyncCommand
SetPropertyByName JSObjectForSend
rthis JSStringForSend
rname JSValueForSend
rval
{-# INLINE setPropertyByName #-}

setPropertyAtIndex :: Int -> JSVal -> Object -> JSM ()
setPropertyAtIndex :: Int -> JSVal -> Object -> JSM ()
setPropertyAtIndex Int
index JSVal
val Object
this =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis ->
        forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
val forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval ->
            AsyncCommand -> JSM ()
sendAsyncCommand forall a b. (a -> b) -> a -> b
$ JSObjectForSend -> Int -> JSValueForSend -> AsyncCommand
SetPropertyAtIndex JSObjectForSend
rthis Int
index JSValueForSend
rval
{-# INLINE setPropertyAtIndex #-}

stringToValue :: JSString -> JSM JSVal
stringToValue :: JSString -> JSM JSVal
stringToValue JSString
s = forall (m :: * -> *) a.
MonadIO m =>
JSString -> (JSStringForSend -> m a) -> m a
withJSString JSString
s forall a b. (a -> b) -> a -> b
$ (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSStringForSend -> JSValueForSend -> AsyncCommand
StringToValue
{-# INLINE stringToValue #-}

numberToValue :: Double -> JSM JSVal
numberToValue :: Double -> JSM JSVal
numberToValue = (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> JSValueForSend -> AsyncCommand
NumberToValue
{-# INLINE numberToValue #-}

jsonValueToValue :: Value -> JSM JSVal
jsonValueToValue :: Value -> JSM JSVal
jsonValueToValue = (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> JSValueForSend -> AsyncCommand
JSONValueToValue
{-# INLINE jsonValueToValue #-}

getPropertyByName :: JSString -> Object -> JSM JSVal
getPropertyByName :: JSString -> Object -> JSM JSVal
getPropertyByName JSString
name Object
this =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis ->
        forall (m :: * -> *) a.
MonadIO m =>
JSString -> (JSStringForSend -> m a) -> m a
withJSString JSString
name forall a b. (a -> b) -> a -> b
$ (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSObjectForSend
-> JSStringForSend -> JSValueForSend -> AsyncCommand
GetPropertyByName JSObjectForSend
rthis
{-# INLINE getPropertyByName #-}

getPropertyAtIndex :: Int -> Object -> JSM JSVal
getPropertyAtIndex :: Int -> Object -> JSM JSVal
getPropertyAtIndex Int
index Object
this =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis -> (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall a b. (a -> b) -> a -> b
$ JSObjectForSend -> Int -> JSValueForSend -> AsyncCommand
GetPropertyAtIndex JSObjectForSend
rthis Int
index
{-# INLINE getPropertyAtIndex #-}

callAsFunction :: Object -> Object -> [JSVal] -> JSM JSVal
callAsFunction :: Object -> Object -> [JSVal] -> JSM JSVal
callAsFunction Object
f Object
this [JSVal]
args =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
f forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rfunction ->
        forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis ->
            forall (m :: * -> *) a.
MonadIO m =>
[JSVal] -> ([JSValueForSend] -> m a) -> m a
withJSVals [JSVal]
args forall a b. (a -> b) -> a -> b
$ (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSObjectForSend
-> JSObjectForSend
-> [JSValueForSend]
-> JSValueForSend
-> AsyncCommand
CallAsFunction JSObjectForSend
rfunction JSObjectForSend
rthis
{-# INLINE callAsFunction #-}

callAsConstructor :: Object -> [JSVal] -> JSM JSVal
callAsConstructor :: Object -> [JSVal] -> JSM JSVal
callAsConstructor Object
f [JSVal]
args =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
f forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rfunction ->
        forall (m :: * -> *) a.
MonadIO m =>
[JSVal] -> ([JSValueForSend] -> m a) -> m a
withJSVals [JSVal]
args forall a b. (a -> b) -> a -> b
$ (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSObjectForSend
-> [JSValueForSend] -> JSValueForSend -> AsyncCommand
CallAsConstructor JSObjectForSend
rfunction
{-# INLINE callAsConstructor #-}

newEmptyObject :: JSM Object
newEmptyObject :: JSM Object
newEmptyObject = JSVal -> Object
Object forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand JSValueForSend -> AsyncCommand
NewEmptyObject
{-# INLINE newEmptyObject #-}

newAsyncCallback :: JSCallAsFunction -> JSM Object
newAsyncCallback :: JSCallAsFunction -> JSM Object
newAsyncCallback JSCallAsFunction
f = do
    Object
object <- JSVal -> Object
Object forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand JSValueForSend -> AsyncCommand
NewAsyncCallback
    Object -> JSCallAsFunction -> IO ()
add <- JSContextRef -> Object -> JSCallAsFunction -> IO ()
addCallback forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadJSM m => m JSContextRef
askJSM
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Object -> JSCallAsFunction -> IO ()
add Object
object JSCallAsFunction
f
    forall (m :: * -> *) a. Monad m => a -> m a
return Object
object
{-# INLINE newAsyncCallback #-}

newSyncCallback :: JSCallAsFunction -> JSM Object
newSyncCallback :: JSCallAsFunction -> JSM Object
newSyncCallback JSCallAsFunction
f = do
    Object
object <- JSVal -> Object
Object forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand JSValueForSend -> AsyncCommand
NewSyncCallback
    Object -> JSCallAsFunction -> IO ()
add <- JSContextRef -> Object -> JSCallAsFunction -> IO ()
addCallback forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadJSM m => m JSContextRef
askJSM
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Object -> JSCallAsFunction -> IO ()
add Object
object JSCallAsFunction
f
    forall (m :: * -> *) a. Monad m => a -> m a
return Object
object
{-# INLINE newSyncCallback #-}

newArray :: [JSVal] -> JSM JSVal
newArray :: [JSVal] -> JSM JSVal
newArray [JSVal]
xs = forall (m :: * -> *) a.
MonadIO m =>
[JSVal] -> ([JSValueForSend] -> m a) -> m a
withJSVals [JSVal]
xs forall a b. (a -> b) -> a -> b
$ \[JSValueForSend]
xs' -> (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand ([JSValueForSend] -> JSValueForSend -> AsyncCommand
NewArray [JSValueForSend]
xs')
{-# INLINE newArray #-}

evaluateScript :: JSString -> JSM JSVal
evaluateScript :: JSString -> JSM JSVal
evaluateScript JSString
script = forall (m :: * -> *) a.
MonadIO m =>
JSString -> (JSStringForSend -> m a) -> m a
withJSString JSString
script forall a b. (a -> b) -> a -> b
$ (JSValueForSend -> AsyncCommand) -> JSM JSVal
sendLazyCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSStringForSend -> JSValueForSend -> AsyncCommand
EvaluateScript
{-# INLINE evaluateScript #-}

deRefVal :: JSVal -> JSM Result
deRefVal :: JSVal -> JSM Result
deRefVal JSVal
value = forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ Command -> JSM Result
sendCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSValueForSend -> Command
DeRefVal
{-# INLINE deRefVal #-}

valueToBool :: JSVal -> JSM Bool
valueToBool :: JSVal -> JSM Bool
valueToBool v :: JSVal
v@(JSVal IORef JSValueRef
ref) = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. IORef a -> IO a
readIORef IORef JSValueRef
ref) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    JSValueRef
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- null
    JSValueRef
1 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- undefined
    JSValueRef
2 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- false
    JSValueRef
3 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True  -- true
    JSValueRef
_ -> forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
v forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
        (ValueToBoolResult Bool
result) <- Command -> JSM Result
sendCommand (JSValueForSend -> Command
ValueToBool JSValueForSend
rval)
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result
{-# INLINE valueToBool #-}

valueToNumber :: JSVal -> JSM Double
valueToNumber :: JSVal -> JSM Double
valueToNumber JSVal
value =
    forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
        (ValueToNumberResult Double
result) <- Command -> JSM Result
sendCommand (JSValueForSend -> Command
ValueToNumber JSValueForSend
rval)
        forall (m :: * -> *) a. Monad m => a -> m a
return Double
result
{-# INLINE valueToNumber #-}

valueToString :: JSVal -> JSM JSString
valueToString :: JSVal -> JSM JSString
valueToString JSVal
value = forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
    (ValueToStringResult JSStringReceived
result) <- Command -> JSM Result
sendCommand (JSValueForSend -> Command
ValueToString JSValueForSend
rval)
    forall (m :: * -> *). MonadIO m => JSStringReceived -> m JSString
wrapJSString JSStringReceived
result
{-# INLINE valueToString #-}

valueToJSON :: JSVal -> JSM JSString
valueToJSON :: JSVal -> JSM JSString
valueToJSON JSVal
value = forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
    (ValueToJSONResult JSStringReceived
result) <- Command -> JSM Result
sendCommand (JSValueForSend -> Command
ValueToJSON JSValueForSend
rval)
    forall (m :: * -> *). MonadIO m => JSStringReceived -> m JSString
wrapJSString JSStringReceived
result
{-# INLINE valueToJSON #-}

valueToJSONValue :: JSVal -> JSM Value
valueToJSONValue :: JSVal -> JSM Value
valueToJSONValue JSVal
value = forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
    (ValueToJSONValueResult Value
result) <- Command -> JSM Result
sendCommand (JSValueForSend -> Command
ValueToJSONValue JSValueForSend
rval)
    forall (m :: * -> *) a. Monad m => a -> m a
return Value
result
{-# INLINE valueToJSONValue #-}

isNull :: JSVal -> JSM Bool
isNull :: JSVal -> JSM Bool
isNull v :: JSVal
v@(JSVal IORef JSValueRef
ref) = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. IORef a -> IO a
readIORef IORef JSValueRef
ref) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    JSValueRef
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True  -- null
    JSValueRef
1 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- undefined
    JSValueRef
2 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- false
    JSValueRef
3 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- true
    JSValueRef
_ -> forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
v forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
        (IsNullResult Bool
result) <- Command -> JSM Result
sendCommand forall a b. (a -> b) -> a -> b
$ JSValueForSend -> Command
IsNull JSValueForSend
rval
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result
{-# INLINE isNull #-}

isUndefined :: JSVal -> JSM Bool
isUndefined :: JSVal -> JSM Bool
isUndefined v :: JSVal
v@(JSVal IORef JSValueRef
ref) = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a. IORef a -> IO a
readIORef IORef JSValueRef
ref) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    JSValueRef
0 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- null
    JSValueRef
1 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True  -- undefined
    JSValueRef
2 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- false
    JSValueRef
3 -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False -- true
    JSValueRef
_ -> forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
v forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval -> do
        (IsUndefinedResult Bool
result) <- Command -> JSM Result
sendCommand forall a b. (a -> b) -> a -> b
$ JSValueForSend -> Command
IsUndefined JSValueForSend
rval
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result
{-# INLINE isUndefined #-}

strictEqual :: JSVal -> JSVal -> JSM Bool
strictEqual :: JSVal -> JSVal -> JSM Bool
strictEqual JSVal
a JSVal
b =
    forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
a forall a b. (a -> b) -> a -> b
$ \JSValueForSend
aref ->
        forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
b forall a b. (a -> b) -> a -> b
$ \JSValueForSend
bref -> do
            (StrictEqualResult Bool
result) <- Command -> JSM Result
sendCommand forall a b. (a -> b) -> a -> b
$ JSValueForSend -> JSValueForSend -> Command
StrictEqual JSValueForSend
aref JSValueForSend
bref
            forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result
{-# INLINE strictEqual #-}

instanceOf :: JSVal -> Object -> JSM Bool
instanceOf :: JSVal -> Object -> JSM Bool
instanceOf JSVal
value Object
constructor =
    forall (m :: * -> *) a.
MonadIO m =>
JSVal -> (JSValueForSend -> m a) -> m a
withJSVal JSVal
value forall a b. (a -> b) -> a -> b
$ \JSValueForSend
rval ->
        forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
constructor forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
c' -> do
            (InstanceOfResult Bool
result) <- Command -> JSM Result
sendCommand forall a b. (a -> b) -> a -> b
$ JSValueForSend -> JSObjectForSend -> Command
InstanceOf JSValueForSend
rval JSObjectForSend
c'
            forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result
{-# INLINE instanceOf #-}

propertyNames :: Object -> JSM [JSString]
propertyNames :: Object -> JSM [JSString]
propertyNames Object
this =
    forall (m :: * -> *) a.
MonadIO m =>
Object -> (JSObjectForSend -> m a) -> m a
withObject Object
this forall a b. (a -> b) -> a -> b
$ \JSObjectForSend
rthis -> do
        (PropertyNamesResult [JSStringReceived]
result) <- Command -> JSM Result
sendCommand forall a b. (a -> b) -> a -> b
$ JSObjectForSend -> Command
PropertyNames JSObjectForSend
rthis
        forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). MonadIO m => JSStringReceived -> m JSString
wrapJSString [JSStringReceived]
result
{-# INLINE propertyNames #-}