We’ve recently added a number of these features (links, main index, &c), but I can’t say for sure whether it would meet all of your needs out of the box. However, it’s been an important goal of Clerk to be not only a tool but also a toolbox, so one can customize it to suit other uses with very little code!

We have some additional stuff for custom TOCs and interlinking, but I’m not sure the status is head. My colleague @U9EQP1K0X was working on that functionality, but he’s currently on holiday for another week or so, and I haven’t time just now to dig into it myself.

We have some utilities around e.g. cross-doc ToC which might be extracted from a private project sometime, the rough idea of it though should be contained in this example: https://github.com/nextjournal/clerk/blob/main/notebooks/meta_toc.clj

not yet, at least if your index isn’t called index.clj

but coming soon:tm:

A quick-and-dirty example of what I'm trying to do:

^{::clerk/sync true}
(do (def x (atom nil))
    (doto (Thread. (fn []
                     (Thread/sleep 1000)
                     (swap! x (fnil inc 0))
                     (recur)))
      (.start))
    x)

clerk sync currently needs to be defined on vars, need to check why your example doesn’t error (think it should). It works if you take things apart like so:

(ns scratch.debug
  (:require [nextjournal.clerk :as clerk]))

^{::clerk/sync true}
(def x (atom nil))

(defonce thread
  (doto (Thread. (fn []
                   (Thread/sleep 1000)
                   (swap! x (fnil inc 0))
                   (recur)))
    (.start)))

here’s a notebook where I tried basic shapes a while ago btw https://github.com/nextjournal/clerk/blob/1f6c5331418aaf9c5a4335fc2e6e95f07dc3af6b/notebooks/shapes.clj

Would Dave's example work if it returned #'x?

I think the var would need to be wrapped in a map under a :nextjournal.clerk/var-from-def key. Can try when I’m back at a 💻

this works as well

^{::clerk/sync true}
(defonce a
  (do (doto (Thread. (fn []
                       (Thread/sleep 1000)
                       (swap! a (fnil inc 0))
                       (recur)))
        (.start))
      (atom nil)))

NB this will leak threads

A slightly more mature approach: https://gist.github.com/daveliepmann/0fcb2f4204a395673b723ea721d51a5e Is there a way to accomplish this without manually wrapping with ::clerk/var-from-def?

@U05092LD5 The problem is that if someone edits a Clerk document to remove a defonce containing an interval, it will just keep updating the atom in background forever. We need a way for the interval subsystem to know when a var is no longer bound.

If we are using cells, and Clerk is watching the cell, and the interval is started from within the cell, then cleanup can happen automatically when clerk unwatches the cell

Assuming we port this to clj https://github.com/mhuebert/maria/tree/main/editor2/src/main/cells

Which shouldn't be that hard since the heavy lifting is done by re-db/reactive

@mhuebert these ifs sadly don’t apply to the situation at hand

Ah I thought we were still talking about the original Q

Clerk uses static analysis to provide dataflow-ish behavior without explicit markers (i.e. def, not defcell), which presents different challenges that need to be addresses as part of the solution here. So, in terms of those ifs: we are not using cells, &c, &c.

(that said, there’s definitely utility in creating a cells-like library that can play nice with Clerk!)

Ok. I thought Dave wanted to literally port cells to clj/clerk and had just made a minimal example using an atom to try and figure out the change propagation bit

I'm aware of the orphan thread problem and plan to address that separately (and separate from Clerk's dataflow). Right now I just want to be sure whatever I make will operate harmoniously with Clerk's live updates. My suspicion is that I should be writing a viewer instead of wrapping with {::clerk/var-from-def x} so I was hoping there was an example or some docs so I could understand it. Open to suggestions; maybe we should have a chat