Safe Haskell | None |
---|---|
Language | Haskell98 |
- serve :: Config -> (Window -> IO ()) -> IO ()
- defaultConfig :: Config
- data Config
- data Server
- type MimeType = String
- type URI = String
- loadFile :: Server -> MimeType -> FilePath -> IO String
- loadDirectory :: Server -> FilePath -> IO String
- data Window
- getServer :: Window -> Server
- root :: Window -> RemotePtr ()
- class ToJS a where
- class FromJS a
- data JSFunction a
- type JSObject = RemotePtr JSPtr
- data JavaScriptException
- class FFI a
- ffi :: FFI a => String -> a
- runFunction :: Window -> JSFunction () -> IO ()
- callFunction :: Window -> JSFunction a -> IO a
- data NewJSObject
- unsafeCreateJSObject :: Window -> JSFunction NewJSObject -> IO JSObject
- data CallBufferMode
- setCallBufferMode :: Window -> CallBufferMode -> IO ()
- flushCallBuffer :: Window -> IO ()
- class IsHandler a
- exportHandler :: IsHandler a => Window -> a -> IO JSObject
- onDisconnect :: Window -> IO () -> IO ()
- debug :: Window -> String -> IO ()
- timestamp :: Window -> IO ()
Synopsis
A JavaScript foreign function interface (FFI).
This module implements a web server that communicates with a web browser and allows you to execute arbitrary JavaScript code on it.
NOTE: This module is used internally by the Graphics.UI.Threepenny library, but the types are not compatible. Use Foreign.JavaScript only if you want to roll your own interface to the web browser.
Server
:: Config | Configuration options. |
-> (Window -> IO ()) | Initialization whenever a client connects. |
-> IO () |
Run a Foreign.JavaScript server.
defaultConfig :: Config Source #
Default configuration.
Port from environment variable or 8023
, listening on localhost
,
do reload on disconnect,
no custom HTML, no static directory,
logging to stderr.
Static configuration for a Foreign.JavaScript server.
This is a record type which has the following fields:
jsPort :: Maybe Int
Port number.
Nothing
means that the port number is read from the environment variablePORT
. Alternatively, port8023
is used if this variable is not set.jsAddr :: Maybe ByteString
Bind address.
Nothing
means that the bind address is read from the environment variableADDR
. Alternatively, address127.0.0.1
is used if this variable is not set.jsWindowReloadOnDisconnect :: Bool
Reload the browser window if the connection to the server was dropped accidentally, for instance because the computer was put to sleep and awoken again.
jsCustomHTML :: Maybe FilePath
Custom HTML file to replace the default one.
jsStatic :: Maybe FilePath
Directory that is served under
/static
.jsLog :: ByteString -> IO ()
Function to print a single log message.
(For reasons of forward compatibility, the constructor is not exported.)
Representation of a Foreign.JavaScript server.
Can be used for dynamic configuration, e.g. serving additional files.
URI type.
FIXME: Use the correct type from Network.URI
loadFile :: Server -> MimeType -> FilePath -> IO String Source #
Begin to serve a local file with a given MimeType
under a URI.
loadDirectory :: Server -> FilePath -> IO String Source #
Begin to serve a local directory under a URI.
JavaScript FFI
Helper class for rendering Haskell values as JavaScript expressions.
Helper class for converting JavaScript values to Haskell values.
fromJS
data JSFunction a Source #
A JavaScript function with a given output type a
.
Functor JSFunction Source # | Change the output type of a |
FromJS b => FFI (JSFunction b) Source # | |
data JavaScriptException Source #
Helper class for making ffi
a variable argument function.
fancy
ffi :: FFI a => String -> a Source #
Simple JavaScript FFI with string substitution.
Inspired by the Fay language. https://github.com/faylang/fay/wiki
example :: String -> Int -> JSFunction String example = ffi "$(%1).prop('checked',%2)"
The ffi
function takes a string argument representing the JavaScript
code to be executed on the client.
Occurrences of the substrings %1
to %9
will be replaced by
subequent arguments.
The substring %%
in the original will be replaced by %
(character escape).
Note: Always specify a type signature! The types automate
how values are marshalled between Haskell and JavaScript.
The class instances for the FFI
class show which conversions are supported.
runFunction :: Window -> JSFunction () -> IO () Source #
Run a JavaScript function, but do not wait for a result.
NOTE: The JavaScript function need not be executed immediately,
it can be buffered and sent to the browser window at a later time.
See setCallBufferMode
and flushCallBuffer
for more.
callFunction :: Window -> JSFunction a -> IO a Source #
Call a JavaScript function and wait for the result.
data NewJSObject Source #
A mutable JavaScript object that has just been created. This a dummy type used for additional type safety.
unsafeCreateJSObject :: Window -> JSFunction NewJSObject -> IO JSObject Source #
Run a JavaScript function that creates a new object.
Return a corresponding JSObject
without waiting for the browser
to send a result.
WARNING: This function assumes that the supplied JavaScript code does, in fact, create an object that is new.
data CallBufferMode Source #
Specification of how JavaScript functions should be called.
The default mode for a new browser window is NoBuffering
.
Use setCallBufferMode
to change the mode at any time.
NoBuffering | When |
BufferRun | When |
setCallBufferMode :: Window -> CallBufferMode -> IO () Source #
Set the call buffering mode for the given browser window.
flushCallBuffer :: Window -> IO () Source #
Flush the call buffer, i.e. send all outstanding JavaScript to the client in one single message.
Helper class for exporting Haskell functions to JavaScript as event handlers.
convertArgs, handle
exportHandler :: IsHandler a => Window -> a -> IO JSObject Source #
Export a Haskell function as an event handler.
The result is a JavaScript Function
object that can be called
from JavaScript like a regular function. However,
the corresponding Haskell function will not be run immediately,
rather it will be added to the event queue and processed
like an event. In other words, this the Haskell code is only called
asynchronously.
WARNING: The event handler will be garbage collected unless you keep a reference to it on the Haskell side! Registering it with a JavaScript function will generally not keep it alive.