figwheel.repl — com.bhauman/figwheel-repl 0.1.7

*connections* clj

*server* clj

abstract-websocket-connection clj

(abstract-websocket-connection connections)

add-cache-buster cljs

(add-cache-buster url)

add-listener clj

(add-listener f)

(add-listener k f)

after-reloads cljs

(after-reloads f)

asyc-http-polling-middleware clj

(asyc-http-polling-middleware handler path connections)

available-names clj

(available-names connections)

bootstrap-goog-base cljs

(bootstrap-goog-base)

Reusable browser REPL bootstrapping. Patches the essential functions in goog.base to support re-loading of namespaces after page load.

bootstrapped-cljs cljs

broadcast-for-response clj

(broadcast-for-response connections msg)

clear-listeners clj

(clear-listeners)

client-log-level cljs

connect cljs

(connect & [connect-url'])

connect* cljs

(connect* connect-url')

connect-url cljs

connected cljs

connection-closed! cljs

(connection-closed! url)

connection-established! cljs

(connection-established! url)

connection-send clj

(connection-send {:keys [send-fn] :as conn} data)

connections-available clj

(connections-available repl-env)

conns clj/s macro

(conns)

conns* clj

(conns*)

console-logging cljs

(console-logging)

create-connection! clj

(create-connection! ring-request options)

create-node-script-import-fn cljs

(create-node-script-import-fn)

debug cljs

(debug msg)

default-port clj/s

dynload clj

(dynload ns-sym-str)

ensure-websocket cljs

(ensure-websocket thunk)

err-print cljs multimethod

eval-connections clj

(eval-connections {:keys [focus-session-name] :as repl-env})

eval-javascript** cljs

(eval-javascript** code)

evaluate clj

(evaluate {:keys [focus-session-name repl-eval-timeout broadcast] :as repl-env}
          js)

exponential-backoff cljs

(exponential-backoff attempt)

figwheel-require cljs

(figwheel-require src reload)

fill-server-url-template clj

(fill-server-url-template url-str {:keys [host port]})

fill-url-template cljs

(fill-url-template connect-url')

focus clj/s macro

(focus session-name)

focus* clj

(focus* session-name)

get-state cljs

(get-state k)

get-websocket-class cljs

(get-websocket-class)

gloader cljs

hook-repl-printing-output! cljs

(hook-repl-printing-output! respond-msg)

host-env cljs

http-connect cljs

(http-connect & [connect-url'])

http-connect* cljs

(http-connect* attempt connect-url')

http-get cljs

http-long-polling-connect clj

(http-long-polling-connect ring-request respond raise)

http-long-polling-endpoint clj

(http-long-polling-endpoint ring-request send raise)

http-polling-connect clj

(http-polling-connect ring-request)

http-polling-endpoint clj

(http-polling-endpoint ring-request)

http-polling-middleware clj

(http-polling-middleware handler path connections)

http-polling-send clj

(http-polling-send conn data)

http-post cljs

init-log-level! cljs

(init-log-level!)

json-response clj

(json-response json-body)

launch-node clj

(launch-node opts repl-env input-path & [output-log-file])

list-connections clj

(list-connections)

log clj

(log & args)

log-console cljs

log-levels cljs

logger cljs

long-poll cljs

(long-poll msg-fn connect-url')

long-poll-capture-respond clj

(long-poll-capture-respond comm-atom respond)

long-poll-send clj

(long-poll-send comm-atom msg)

make-url cljs

(make-url connect-url')

message cljs multimethod

name-list clj

naming-response clj

(naming-response {:keys [session-name session-id type] :as conn})

negotiate-id clj

(negotiate-id ring-request connections)

no-connection-result clj

open-connections clj

(open-connections)

out-print cljs multimethod

parse-query-string clj

(parse-query-string qs)

patch-goog-base cljs

(patch-goog-base)

ping clj

(ping conn)

ping-thread clj

(ping-thread connections
             fwsid
             {:keys [interval ping-timeout]
              :or {interval 15000 ping-timeout 2000}})

poll cljs

(poll msg-fn connect-url')

print-output cljs

print-receivers cljs

(print-receivers outputs)

print-to-stream clj

(print-to-stream stream args)

queued-file-reload cljs

(queued-file-reload url)

(queued-file-reload url opt-source-text)

receive-message! clj

(receive-message! data)

reload-file cljs

(reload-file {:keys [request-url] :as file-msg} callback)

reload-file* cljs

reload-file-in-html-env cljs

(reload-file-in-html-env request-url callback)

reload-promise-chain cljs

remove-connection! clj

(remove-connection! {:keys [session-id] :as conn})

remove-listener clj

(remove-listener k)

repl-env* clj

(repl-env* {:keys [port open-url connection-filter]
            :or {connection-filter identity
                 open-url "http://[[server-hostname]]:[[server-port]]"
                 port default-port}
            :as opts})

repl-env-print clj

(repl-env-print repl-env stream args)

require-resolve clj

(require-resolve symbol-str)

respond-to cljs

(respond-to {:keys [websocket http-url] :as old-msg} response-body)

respond-to-connection cljs

(respond-to-connection response-body)

response-for cljs

(response-for {:keys [uuid]} response-body)

run-default-server clj

(run-default-server options connections)

run-default-server* clj

(run-default-server* options connections)

scratch clj

send-for-eval clj

(send-for-eval {:keys [focus-session-name broadcast] :as repl-env}
               connections
               js)

send-for-response clj

(send-for-response connections msg)

send-for-response* clj

(send-for-response* prom conn msg)

session-id cljs

(session-id)

session-name cljs

(session-name)

set-log-level cljs

(set-log-level logger' level)

set-state cljs

(set-state k v)

setup clj

(setup repl-env opts)

setup-printing! cljs

(setup-printing!)

state cljs

storage cljs

switch-to-http? cljs

(switch-to-http? url)

taken-names clj

(taken-names connections)

tear-down-everything-but-server clj

(tear-down-everything-but-server {:keys [printing-listener node-proc]})

tear-down-server clj

(tear-down-server {:keys [server]})

trim-last-newline clj

(trim-last-newline args)

try-port clj

(try-port port server-fn)

Try running a server under one port or a list of ports. If a list of ports is supplied, try each port until it succeeds or runs out of ports.

unprovide! cljs

(unprovide! ns)

wait-for-connection clj

(wait-for-connection repl-env)

will-eval-on clj

(will-eval-on)

worker-import-script cljs

(worker-import-script request-url callback)

write-script-tag-import cljs

ws-connect cljs

(ws-connect & [websocket-url'])