Roam Research Docs · Developer documentation

Roam Clojurescript API

• Clojure Core Namespaces
  • clojure.core
    • everything in clojure.core
  • clojure.pprint
    • everything in cljs.pprint
  • cljs.pprint
    • everything in cljs.pprint
• Roam Namespaces
  • In general these namespaces match the Roam Alpha API exactly, except they accept a clojure map with keywords
    • There are some differences, such as roam.datascript.reactive for re-rendering reagent components, or roam.katex for rendering katex reagent components
  • roam.datascript
    • q
      • Description::
        • Calls datascript.core/q passing current graph's db automatically
          • > Executes a datalog query
        • Resources::
          • datascript.core/q docs
          • For a deeper dive into queries, see datomic docs on query.
      • arguments:: [query & inputs]
        • query
          • datalog query
        • inputs
          • any inputs to the query (except the db, which is passed automatically)
          • Note: If you have inputs, the :in clause is compulsory (for eg :in $ input1 input2)
      • Usage::
        • Roam render component that shows the parent page's title for a block
          • block passed as input is the block at the top of this page:
            Equivalent to roam/js but language of choice is clojurescript
          • {{roam/render:

            (ns developer-doc.rd.q
              (:require 
               [roam.datascript :as rd]))
            
            (defn main []
              [:div  
                (str
                 (rd/q 
                  '[:find ?parent-page-title .
                    :in $ ?block-uid
                    :where
                    [?block :block/uid  ?block-uid]
                    [?block :block/page ?page]
                    [?page  :node/title ?parent-page-title]] 
                  "TpIGtsnL7"))])

            }}

            • (ns developer-doc.rd.q
                (:require 
                 [roam.datascript :as rd]))
              
              (defn main []
                [:div  
                  (str
                   (rd/q 
                    '[:find ?parent-page-title .
                      :in $ ?block-uid
                      :where
                      [?block :block/uid  ?block-uid]
                      [?block :block/page ?page]
                      [?page  :node/title ?parent-page-title]] 
                    "TpIGtsnL7"))])

    • pull
      • Description::
        • Calls datascript.core/pull passing current graph's db automatically
          • > Fetches data from database using recursive declarative description.
        • Resources::
          • datascript.core/pull docs
          • For a deeper dive, see datomic docs on pull api
      • arguments:: [pattern eid]
        • pattern
          • aka selector
        • eid
      • Usage::
        • Roam render component that displays the following information for a page: uid, title, all direct children (with their own uid and :block/string)
          • {{roam/render:

            (ns developer-doc.rd.pull
              (:require 
               [roam.datascript :as rd]))
            
            (defn main []
              [:div  
                (str
                 (rd/pull 
                  '[:block/uid 
                    :node/title 
                    {:block/children [:block/uid :block/string]}] 
                  '[:block/uid "11-20-2021"]))])

            }}

            • (ns developer-doc.rd.pull
                (:require 
                 [roam.datascript :as rd]))
              
              (defn main []
                [:div  
                  (str
                   (rd/pull 
                    '[:block/uid 
                      :node/title 
                      {:block/children [:block/uid :block/string]}] 
                    '[:block/uid "11-20-2021"]))])

    • entity
      • Description::
        • Calls datascript.core/entity passing current graph's db automatically
          • > Retrieves an entity by its id from database. Entities are lazy map-like structures to navigate DataScript database content.
        • Resources::
          • datascript.core/entity docs
      • arguments::
        • eid
          • entity id
          • can directly pass entity id or can use lookup attr
            • therefore, both of the following are valid
              • 7161
              • '[:block/uid "11-27-2021"]
      • Usage::
        • a roam render component that displays the title of a page and the top bullets in order
          • {{roam/render:

            (ns developer-doc.rd.entity
              (:require 
               [roam.datascript :as rd]))
            
            (defn main []
              (let [page-ent (rd/entity '[:block/uid "11-27-2021"])
                    title    (:node/title page-ent)
                    children (->> (:block/children page-ent)
                                  (sort :block/order))]
                [:div 
                 [:h1 title]
                 [:ul
                  (for [child children]
                    [:li (:block/string child)])]]))

            }}

            • (ns developer-doc.rd.entity
                (:require 
                 [roam.datascript :as rd]))
              
              (defn main []
                (let [page-ent (rd/entity '[:block/uid "11-27-2021"])
                      title    (:node/title page-ent)
                      children (->> (:block/children page-ent)
                                    (sort :block/order))]
                  [:div 
                   [:h1 title]
                   [:ul
                    (for [child children]
                      [:li (:block/string child)])]]))

    • datoms
      • Description::
        • Calls datascript.core/datoms passing current graph's db automatically
          • > Index lookup. Returns a sequence of datoms (lazy iterator over actual DB index) which components (e, a, v) match passed arguments.
        • Resources::
          • datascript.core/datoms docs
      • arguments:: [index & args]
        • index
          • the database index to be looked up
          • Possible values
            • :eavt 
            • :aevt
            • :avet
          • Note::
            • :eavt  and :aevt contain all datoms.
            • :avet only contains datoms for references, :db/unique and :db/index attributes.
              • in the case of Roam's graphs, these would be
                • :node/title
                • :window/id
                • :user/email
              • However, all of the above are :db/unique properties, so you may be better off doing a direct entity lookup
        • args
          • the passed args match against components (e, a, v) of the datoms
            • depending on the index obviously
      • Usage::
        • a roam render component that displays the name of the pages which are publicly shared
          • {{roam/render:

            (ns developer-doc.rd.datoms
              (:require 
               [roam.datascript :as rd]))
            
            (defn main []
              (let [page-ents (map (comp rd/entity :e) (rd/datoms :aevt :page/permissions))]
                [:div
                 [:h2 "Shared pages"]
                 [:ol
                   (for [page-ent page-ents]
                     [:li (str (:node/title page-ent) ": " (:page/permissions page-ent))])]]))

            }}

            • (ns developer-doc.rd.datoms
                (:require 
                 [roam.datascript :as rd]))
              
              (defn main []
                (let [page-ents (map (comp rd/entity :e) (rd/datoms :aevt :page/permissions))]
                  [:div
                   [:h2 "Shared pages"]
                   [:ol
                     (for [page-ent page-ents]
                       [:li (str (:node/title page-ent) ": " (:page/permissions page-ent))])]]))

  • roam.datascript.reactive
    • q
      • same as roam.datascript/q but returns a reagent reaction with the result of the query.
        • The value of the reaction will be automatically updated whenever a change is detected
    • pull
      • same as roam.datascript/pull but but returns a reagent reaction which will be updated every time that the value of conn changes
    • f-entity
      • Description::
        • Returns a reagent reaction which holds the result of (apply f (rd/entity eid) args)
      • arguments:: [f eid & args]
        • f
        • eid
        • args
      • Usage::
        • a roam render component that displays the text of a block reactively (reactively - updates automatically when block updates)
          • {{roam/render:

            (ns developer-doc.rdr.f-entity.2
              (:require 
               [roam.datascript.reactive :as rdr]))
            
            (defn main []
              (let [block-uid      "pXh1FJfIX"
                    block-str-atom (rdr/f-entity
                                    :block/string ;;f
                                    [:block/uid block-uid] ;;eid
                                   )]
                [:div 
                 [:h3 
                  (str "Reactive display of block with :block/uid: " block-uid)]
                 [:ul
                  [:li @block-str-atom]]]))

            }}

            • (ns developer-doc.rdr.f-entity.2
                (:require 
                 [roam.datascript.reactive :as rdr]))
              
              (defn main []
                (let [block-uid      "pXh1FJfIX"
                      block-str-atom (rdr/f-entity
                                      :block/string ;;f
                                      [:block/uid block-uid] ;;eid
                                     )]
                  [:div 
                   [:h3 
                    (str "Reactive display of block with :block/uid: " block-uid)]
                   [:ul
                    [:li @block-str-atom]]]))

        • a roam render component that displays back refs of a block (reactively - updates automatically when block updates)
          • {{roam/render:

            (ns developer-doc.rdr.f-entity.2
              (:require 
               [roam.datascript.reactive :as rdr]))
            
            (defn get-backref-page-string [ent]
              (mapv (juxt (comp :node/title :block/page) :block/string) (:block/_refs ent)))
            
            (defn main []
              (let [block-uid      "11-26-2021"
                    backrefs-atom  (rdr/f-entity
                                    get-backref-page-string ;;f
                                    [:block/uid block-uid] ;;eid
                                   )]
                [:div 
                 [:h3 
                  (str "Reactive display of back refs of block with :block/uid: " block-uid)]
                 [:ul
                  (for [[page-title block-string] @backrefs-atom]
                    [:li (str page-title ": " block-string)])
                  ]]))

            }}

            • (ns developer-doc.rdr.f-entity.2
                (:require 
                 [roam.datascript.reactive :as rdr]))
              
              (defn get-backref-page-string [ent]
                (mapv (juxt (comp :node/title :block/page) :block/string) (:block/_refs ent)))
              
              (defn main []
                (let [block-uid      "11-26-2021"
                      backrefs-atom  (rdr/f-entity
                                      get-backref-page-string ;;f
                                      [:block/uid block-uid] ;;eid
                                     )]
                  [:div 
                   [:h3 
                    (str "Reactive display of back refs of block with :block/uid: " block-uid)]
                   [:ul
                    (for [[page-title block-string] @backrefs-atom]
                      [:li (str page-title ": " block-string)])
                    ]]))

    • datoms
      • same as roam.datascript/datoms but returns a reagent reaction with the result.
        • The value of the reaction will be automatically updated whenever a change is detected
  • roam.util
    • Aside from parse these are equivalent to those in roamAlphaAPI.util
    • generate-uid
      • Example::

        • (roam.util/generate-uid)

    • page-title->date
      • Example::

        • (roam.util/page-title->date "August 1st, 2022")

    • date->page-title
      • Example::

        • (roam.util/date->page-title (new js/Date))

    • date->page-uid
      • Example::

        • (roam.util/date->page-uid (new js/Date))

    • parse
      • Description::
        • Takes a Roam markdown style string as input and returns a reagent component of how it would look like when in a block
      • arguments:: [s]
        • s
          • markdown string
      • Example::
        • Displaying strings with Roam's markdown parser
          • Code::

            • (ns dev-docs.parse-example
                (:require [roam.util :refer [parse]]))
              
              (defn main []
                [parse "**apple** __banana__ [[test-parse]]"])

          • Output::
            • {{[[roam/render]]: ((uUxqZ4Bwb))}}
            • {{roam/render:

              (ns dev-docs.parse-example
                (:require [roam.util :refer [parse]]))
              
              (defn main []
                [parse "**apple** __banana__ [[test-parse]]"])

              }}
      • useful in roam/render
  • roam.ui.main-window
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.mainWindow
    • open-page
      • Example::

        • (main-window/open-page {:page {:uid "ljs1l3kj4"}})

    • open-block
      • Example::

        • (main-window/open-block {:page {:uid "ljs1l3kj4"}})

    • open-daily-notes
      • Example::

        • (main-window/open-daily-notes)

    • get-open-page-or-block-uid
      • Example::

        • (main-window/get-open-page-or-block-uid)

    • focus-first-block
      • Example::

        • (main-window/focus-first-block)

  • roam.ui.left-sidebar
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.leftSidebar
    • open
      • Example::

        • (left-sidebar/open)

    • close
      • Example::

        • (left-sidebar/close)

  • roam.ui.right-sidebar
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.rightSidebar
    • open
      • Example::

        • (right-sidebar/open)

    • close
      • Example::

        • (right-sidebar/close)

    • get-windows
      • Example::

        • (right-sidebar/get-windows)

    • add-window
      • Example::

        • (right-sidebar/add-window
            {:window {:type "block" :block-uid "1fasdfef"}})

    • remove-window
      • Example::

        • (right-sidebar/remove-window
            {:window {:type "block" :block-uid "1fasdfef"}})

    • expand-window
      • Example::

        • (right-sidebar/expand-window
            {:window {:type "block" :block-uid "1fasdfef"}})

    • collapse-window
      • Example::

        • (right-sidebar/collapse-window
            {:window {:type "block" :block-uid "1fasdfef"}})

    • pin-window
      • Example::

        • (right-sidebar/pin-window
            {:window {:type "block" :block-uid "1fasdfef"}})

    • unpin-window
      • Example::

        • (right-sidebar/unpin-window
            {:window {:type "block" :block-uid "1fasdfef"}})

  • roam.ui.filters
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.filters
    • add-global-filter
      • Example::

        • (filters/add-global-filter
            {:title "test"
             :type "includes"})

    • remove-global-filter
      • Example::

        • (filters/remove-global-filter
            {:title "test"
             :type "includes"})

    • get-global-filters
      • Example::

        • (filters/get-global-filters)

    • get-page-filters
      • Example::

        • (filters/get-page-filters
            {:page {:title "test"}})

    • get-page-linked-refs-filter
      • Example::

        • (filters/get-pagelinked-refs-filters
            {:page {:title "test"}})

    • get-sidebar-window-filters
      • Example::

        • (filters/get-sidebar-window-filters
            {:window {:block-uid "sdl3kefj"
                      :type "outline"}})

    • set-page-filters
      • Example::

        • (filters/set-page-filters
            {:page {:title "test"}
             :filters {:includes ["March 11th, 2022"]}})
          
          ;; clears filters
          (filters/set-page-filters
            {:page {:title "test"}
             :filters {}})

    • set-page-linked-refs-filters
      • Example::

        • (filters/set-page-linked-refs-filters
            {:page {:title "test"}
             :filters {:includes ["March 11th, 2022"]}})
          
          ;; clears filters
          (filters/set-page-linked-refs-filters
            {:page {:title "test"}
             :filters {}})

    • set-sidebar-window-filters
      • Example::

        • (filters/set-sidebar-window-filters
            {:window {:block-uid "sdl3kefj"
                      :type "outline"}
             :filters {:includes ["March 11th, 2022"]}})
          
          ;; clears filters
          (filters/set-sidebar-window-filters
            {:window {:block-uid "sdl3kefj"
                      :type "outline"}
             :filters {}})

  • roam.ui.block-context-menu
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.blockContextMenu
    • add-command
      • Example::

        • (block-context-menu/add-command
            {:label "test"
             :callback (fn []
                         (prn "hey!"))})

    • remove-command
      • Example::

        • (block-context-menu/remove-command
            {:label "test"})

  • roam.ui.individual-multiselect
    • Functions in this namespace are equivalent to those in roamAlpahAPI.ui.individualMultiselect
    • get-selected-uids
      • Example::

        • (get-selected-uids)

  • roam.ui.ms-context-menu
    • Functions in this namespace are equivalent to those in roamAlpahAPI.ui.msContextMenu
    • add-command
      • Example::

        • (add-command
            {:label "test"
             :callback (fn []
                         (prn "hey!"))})

    • remove-command
      • Example::

        • (remove-command
            {:label "test"})

  • roam.ui.command-palette
    • Functions in this namespace are equivalent to those in roamAlphaAPI.ui.commandPalette
    • add-command
      • Example::

        • (add-command
            {:label "test"
             :callback (fn []
                         (prn "hello world!"))})

    • remove-command
      • Example::

        • (remove-command
            {:label "test"})

  • roam.graph
    • name #def
      • The name of the current graph
    • type #def
      • "hosted" or "offline"
    • is-encrypted? #def
      • Whether the graph is encrypted or not
  • roam.platform
    • is-desktop? #def
      • true if client is Roam Desktop App
    • is-mobile-app? #def
      • true if client is Roam Mobile App
    • is-mobile? #def
      • Note that this is only a check on the screen size
        • just uses a media query max-width: 450px
    • is-ios? #def
      • true if client is iphone, ipad or ipod
    • is-pc? #def
      • true if client is a PC
      • useful if you want to have different shortcuts on PC vs Mac
    • is-touch-device #def
      • true if client is a touch device
  • roam.katex
    • inline
      • Description::
        • Takes a string and renders it with katex as an inline level element
      • Example::

        • [katex/inline "1 + 2"]

    • block
      • Description::
        • Takes a string and renders it with katex as a block level element
      • Example::

        • [katex/block "1 + 2"]

  • roam.user
    • Functions in this namespace are equivalent to those in roamAlphaAPI.data.user
    • upsert
  • roam.block
    • Functions in this namespace are equivalent to those in roamAlphaAPI.data.block
      • Example of conversion from

        window
          .roamAlphaAPI
          .createBlock(
        	{"location": 
        		{"parent-uid": "01-21-2021", 
        		 "order": 0}, 
        	 "block": 
        		{"string": "test"}})

        to use in clojure
        • {{roam/render:

          (ns dev-doc.roam.block.2
            (:require [roam.block :as block]))
          
          (defn main []
            [:button
             {:on-click
              (fn [] (-> (block/create {:location {:parent-uid "06-14-2022"
                                                   :order      0}
                                        :block    {:string     "test"}})
                         (.then #(js/console.log "done"))
                         (.catch #(js/console.log "failed" %))))}
             "Click me to create the block"])

          }}

          • (ns dev-doc.roam.block.2
              (:require [roam.block :as block]))
            
            (defn main []
              [:button
               {:on-click
                (fn [] (-> (block/create {:location {:parent-uid "06-14-2022"
                                                     :order      0}
                                          :block    {:string     "test"}})
                           (.then #(js/console.log "done"))
                           (.catch #(js/console.log "failed" %))))}
               "Click me to create the block"])

        • Test
          • go to December 5th, 2021
    • create
      • Example::

        • (roam.block/create
            {:location {:parent-uid "asdlkjfe"
                        :order "first"}
             :block {:string "hello world"}})

    • move
      • Example::

        • (roam.block/move
            {:location {:parent-uid "asdlkjfe"
                        :order "last"}
             :block {:uid "f8cXfDIRn"}})

    • update
      • Example::

        • (roam.block/update
            {:block {:uid "f8cXfDIRn"
                     :string "foo"}})

    • delete
      • Example::

        • (roam.block/delete
            {:block {:uid "f8cXfDIRn}})

    • reorder-blocks
      • Example::

        • (reorder-blocks
            {:location {:parent-uid "hisjslk"}
             :blocks ["QCE0cNNNL" "IATKcVmWE" "nC22orMO4"]})

  • roam.page
    • Functions in this namespace are equivalent to those in roamAlphaAPI.data.page
    • create
      • Example::

        • (roam.page/create
            {:page {:title "test me!"}})

    • update
      • Example::

        • (roam.page/update
            {:page {:uid "asdflele"
                    :title "test me!"}})

    • delete
      • Example::

        • (roam.page/delete
            {:page {:uid "asdflele"}})

• External Libraries
  • Reagent
    • version used: reagent/reagent {:mvn/version "1.1.0"}
    • reagent.core
      • reagent.core docs
      • exposed vars
        • {{roam/render:

          (ns ns-vars-lister
            (:require [reagent.core]))
          
          (defn main [{:keys [block-uid]} ns-name]
            (let [ns-symbol (symbol ns-name)]
              [:div [:div
                     [:h3 "public vars of ns: " (pr-str ns-symbol)]
                     [:div (map
                            (fn [n] [:div (pr-str n)])
                            (->> (ns-publics ns-symbol)
                                 (seq)
                                 (sort)))]]]))

          "reagent.core"}}
    • reagent.dom
      • reagent.dom docs
      • exposed vars
        • {{roam/render:

          (ns ns-vars-lister
            (:require [reagent.core]))
          
          (defn main [{:keys [block-uid]} ns-name]
            (let [ns-symbol (symbol ns-name)]
              [:div [:div
                     [:h3 "public vars of ns: " (pr-str ns-symbol)]
                     [:div (map
                            (fn [n] [:div (pr-str n)])
                            (->> (ns-publics ns-symbol)
                                 (seq)
                                 (sort)))]]]))

          "reagent.dom"}}
  • datascript.core
    • you will most likely want to use roam.datascript or roam.datascript.reactive
    • datascript.core docs
    • exposed vars:
      • {{roam/render:

        (ns ns-vars-lister
          (:require [reagent.core]))
        
        (defn main [{:keys [block-uid]} ns-name]
          (let [ns-symbol (symbol ns-name)]
            [:div [:div
                   [:h3 "public vars of ns: " (pr-str ns-symbol)]
                   [:div (map
                          (fn [n] [:div (pr-str n)])
                          (->> (ns-publics ns-symbol)
                               (seq)
                               (sort)))]]]))

        "datascript.core"}}
  • instaparse.core
    • instaparse.core docs
    • exposed vars
      • {{roam/render:

        (ns ns-vars-lister
          (:require [reagent.core]))
        
        (defn main [{:keys [block-uid]} ns-name]
          (let [ns-symbol (symbol ns-name)]
            [:div [:div
                   [:h3 "public vars of ns: " (pr-str ns-symbol)]
                   [:div (map
                          (fn [n] [:div (pr-str n)])
                          (->> (ns-publics ns-symbol)
                               (seq)
                               (sort)))]]]))

        "instaparse.core"}}
    • Example
      • instaparse.core readme example
        • Code::

          • (ns developer-documentation.test-instaparse.1
              (:require 
               [reagent.core :as r]
               [roam.block :as block]
               [blueprintjs.core :as bp-core]
               [cljs.pprint :refer [pprint]]
               [instaparse.core :as insta]))
            
            (def as-and-bs
              (insta/parser
                "S = AB*
                 AB = A B
                 A = 'a'+
                 B = 'b'+"))
            
            (defn main [{:keys [block-uid]}]
              [:button 
               {:on-click 
                #(pprint (as-and-bs "aaaaabbbaaaabb"))} "Click me!"])

        • Output::
          • {{[[roam/render]]: ((6DXyUOHhH))}}
          • {{roam/render:

            (ns developer-documentation.test-instaparse.1
              (:require 
               [reagent.core :as r]
               [roam.block :as block]
               [blueprintjs.core :as bp-core]
               [cljs.pprint :refer [pprint]]
               [instaparse.core :as insta]))
            
            (def as-and-bs
              (insta/parser
                "S = AB*
                 AB = A B
                 A = 'a'+
                 B = 'b'+"))
            
            (defn main [{:keys [block-uid]}]
              [:button 
               {:on-click 
                #(pprint (as-and-bs "aaaaabbbaaaabb"))} "Click me!"])

            }} (check console after clicking)
  • blueprintjs.core
    • everything in @blueprintjs/core docs
    • Note: Since this is a ReactJS library, the classes need some treatment before they can be used.
      • For most cases, you just have to use reagent/adapt-react-class. See the example below
      • For more detail: read through Reagent Docs/InteropWithReact.md
    • Example
      • Click me template using blueprintjs.core
        • Code::

          • (ns dev-docs.test-blueprint.1
              (:require 
               [reagent.core :as r]
               [roam.block :as block]
               [blueprintjs.core :as bp-core]))
            
            (defonce bp3-button (r/adapt-react-class bp-core/Button))
            
            (defn main [{:keys [block-uid]}]
              [bp3-button 
               {:large true
                :disabled true
                :icon "history"
                :on-click 
                #(block/update 
                  {:block {:uid block-uid 
                           :string "Hello world!"}})} 
               "Click me!"])

        • Output::
          • {{[[roam/render]]: ((O1iyYWZsW))}}
          • {{roam/render:

            (ns dev-docs.test-blueprint.1
              (:require 
               [reagent.core :as r]
               [roam.block :as block]
               [blueprintjs.core :as bp-core]))
            
            (defonce bp3-button (r/adapt-react-class bp-core/Button))
            
            (defn main [{:keys [block-uid]}]
              [bp3-button 
               {:large true
                :disabled true
                :icon "history"
                :on-click 
                #(block/update 
                  {:block {:uid block-uid 
                           :string "Hello world!"}})} 
               "Click me!"])

            }}
  • Promesa
    • version used: funcool/promesa {:mvn/version "6.0.0"}
    • docs
    • promesa.core
      • exposed vars
        • {{roam/render:

          (ns ns-vars-lister
            (:require [reagent.core]))
          
          (defn main [{:keys [block-uid]} ns-name]
            (let [ns-symbol (symbol ns-name)]
              [:div [:div
                     [:h3 "public vars of ns: " (pr-str ns-symbol)]
                     [:div (map
                            (fn [n] [:div (pr-str n)])
                            (->> (ns-publics ns-symbol)
                                 (seq)
                                 (sort)))]]]))

          "promesa.core"}}
    • promesa.protocols
      • exposed vars
        • {{roam/render:

          (ns ns-vars-lister
            (:require [reagent.core]))
          
          (defn main [{:keys [block-uid]} ns-name]
            (let [ns-symbol (symbol ns-name)]
              [:div [:div
                     [:h3 "public vars of ns: " (pr-str ns-symbol)]
                     [:div (map
                            (fn [n] [:div (pr-str n)])
                            (->> (ns-publics ns-symbol)
                                 (seq)
                                 (sort)))]]]))

          "promesa.protocols"}}
  • applied-science.js-interop
    • version used: applied-science/js-interop  {:mvn/version "0.3.3"}
    • docs
    • exposed vars
      • {{roam/render:

        (ns ns-vars-lister
          (:require [reagent.core]))
        
        (defn main [{:keys [block-uid]} ns-name]
          (let [ns-symbol (symbol ns-name)]
            [:div [:div
                   [:h3 "public vars of ns: " (pr-str ns-symbol)]
                   [:div (map
                          (fn [n] [:div (pr-str n)])
                          (->> (ns-publics ns-symbol)
                               (seq)
                               (sort)))]]]))

        "applied-science.js-interop"}}

markdown version · view in Roam Research · exported 2026-07-03