space.matterandvoid.subscriptions.impl.subs — space.matterandvoid/subscriptions 2022.12.03

args->inputs-fn clj/s

(args->inputs-fn get-input-db-signal subscribe err-header args)

args-merge-fn clj/s

cache-and-return! clj/s

(cache-and-return! get-subscription-cache
                   get-cache-key
                   app
                   query-v
                   reaction-or-cursor)

cache the reaction reaction-or-cursor

clear-subscription-cache! clj/s

(clear-subscription-cache! get-subscription-cache app)

calls on-dispose for each cached item, which will cause the value to be removed from the cache

deflayer2-sub clj/s macro

(deflayer2-sub meta-sub-kw get-input-db-signal def-sub-name ?path)

Only supports use cases where your datasource is a hashmap.

Takes a symbol for a subscription name and a way to derive a path in your datasource hashmap. Returns a function subscription which itself returns a Reagent RCursor. Supports a vector path, a single keyword, or a function which takes the RAtom datasource and the arguments map passed to subscribe and must return a path vector to use as an RCursor path.

Examples:

(deflayer2-sub my-subscription :a-path-in-your-db)

(deflayer2-sub my-subscription [:a-path-in-your-db])

(deflayer2-sub my-subscription (fn [db-atom sub-args-map] [:a-key (:some-val sub-args-map])))

defsubraw clj/s macro

(defsubraw meta-sub-kw get-input-db-signal sub-name args body)

Creates a subscription function that takes the datasource ratom and optionally an args map and returns a Reaction or RCursor type.

deref-input-signals clj/s

(deref-input-signals signals query-id)

lenient-call clj/s macro

(lenient-call f datasource args)

Deal with arity stricness on JVM

make-layer2-sub-fn clj/s

(make-layer2-sub-fn get-input-db-signal meta-sub-kw sub-name path)

make-layer2-sub-fn* clj/s

(make-layer2-sub-fn* get-input-db-signal sub-name path)

make-raw-sub clj/s

(make-raw-sub get-input-db-signal meta-sub-kw full-name sub-f)

make-sub-fn clj/s

(make-sub-fn get-input-db-signal meta-sub-kw subscribe query-id sub-args)

make-subs-handler-fn clj/s

(make-subs-handler-fn inputs-fn computation-fn query-id)

A subscription is just a function that returns a reagent.Reaction.

This is where the inputs-fn is executed and the computation is put inside a reaction - ie a callback for later invocation when subscribe is called and derefed.

map-signals clj/s

(map-signals f signals)

Runs f over signals. Signals may take several forms, this function handles all of them.

map-vals clj/s

(map-vals f m)

Returns a new version of 'm' in which 'f' has been applied to each value. (map-vals inc {:a 4, :b 2}) => {:a 5, :b 3}

memoize-fn clj/s

merge-update-args clj/s

(merge-update-args subs-vec args*)

parse-reg-sub-args clj/s

(parse-reg-sub-args get-input-db-signal subscribe err-header args)

reg-layer2-sub clj/s

(reg-layer2-sub get-input-db-signal register-handler! query-id path-vec-or-fn)

Registers a handler function that returns a Reagent RCursor instead of a Reagent Reaction. Accepts a single keyword, a vector path into or a function which takes your db atom and arguments map passed to subscribe and must return a vector path to be used for the cursor.

reg-sub clj/s

(reg-sub get-input-db-signal
         get-handler
         register-handler!
         get-subscription-cache
         cache-lookup
         get-cache-key
         query-id
         &
         args)

db, fully qualified keyword for the query id optional positional args.

reg-sub-raw clj/s

(reg-sub-raw register-handler! query-id handler-fn)

set-args-merge-fn! clj/s

(set-args-merge-fn! f)

set-memoize-fn! clj/s

(set-memoize-fn! f)

sub-fn clj/s

(sub-fn meta-sub-kw f)

Takes a function that returns either a Reaction or RCursor. Returns a function that when invoked delegates to f and derefs its output. The returned function can be used in subscriptions.

subscribe clj/s

(subscribe get-handler
           cache-lookup
           get-subscription-cache
           get-cache-key
           datasource
           query)

Takes a datasource and query and returns a Reaction.

valid-signals clj/s