31:T7bf,function strip(tree, txt) { let entries = [] const cursor = tree.cursor(0) if (cursor.name === "HeaderMark" || cursor.name === "ListMark") { entries.push(["block", "skip"]) entries.push(["children", []]) return Object.fromEntries(entries) } else if (cursor.name.startsWith("ATXHeading")) { entries.push(["block", "h" + cursor.name.slice(10,11)]) entries.push(["content", txt.slice(cursor.from, cursor.to + 1)]) entries.push(["children", []]) return Object.fromEntries(entries) } else if (cursor.name === "Paragraph") { entries.push(["block", "p"]) entries.push(["content", txt.slice(cursor.from, cursor.to + 1)]) entries.push(["children", []]) return Object.fromEntries(entries) } else if (cursor.name === "BulletList") { entries.push(["block", "l"]) // console.log("BulletList", cursor); // console.log("BulletList.name", cursor.name); // console.log("content", txt.slice(cursor.from, cursor.to + 1)); } else if (cursor.name === "ListItem") { entries.push(["block", "i"]) // entries.push(["content", txt.slice(cursor.from, cursor.to + 1)]) // console.log("ListItem", cursor); // console.log("ListItem.name", cursor.name); // console.log("content", txt.slice(cursor.from, cursor.to + 1)); } else if (cursor.name === "Task") { entries.push(["block", "t"]) entries.push(["content", txt.slice(cursor.from, cursor.to + 1)]) } else if (cursor.name === "Blockquote") { entries.push(["block", "q"]) } else { entries.push(["block", cursor.name]) } let children = [] if (cursor.firstChild()) { let go = true; while (go) { if (cursor.tree === null) { console.log("cursor treeBuffer", cursor.buffer.buffer.toString()) } else { children.push(strip(cursor.tree, txt.slice(cursor.from, cursor.to))) } go = cursor.nextSibling() } } entries.push(["children", children]) return Object.fromEntries(entries) }32:T2c1b,current = `module Main where import Prelude import Debug import Control.Comonad.Cofree (head, tail) import Data.Array as A import Data.Either (Either(..), either) import Data.Enum import Data.Enum.Generic import Data.List (List(..), (:), drop) import Data.List (head, tail) as L import Data.Maybe (Maybe(..), maybe, isNothing, fromJust) import Data.Foldable (foldMap, foldl) import Data.Generic.Rep (class Generic) import Partial.Unsafe (unsafePartial, unsafeCrashWith) import Data.Profunctor (wrapIso) import Foreign (Foreign) import Data.Newtype (class Newtype) import Data.NonEmpty (NonEmpty, (:|), singleton) import Data.NonEmpty as NE import Data.Show.Generic (genericShow) import Yoga.Tree (Tree, mkTree, appendChild) import Yoga.Tree.Zipper as TZ import Data.Tuple import Data.Tuple.Nested import Data.Codec.Foreign as F import Data.Codec.Foreign.Record as FR import Data.Codec.Foreign.Common as FC -- newtype Loc a = Loc -- { node :: Tree a -- , before :: Forest a -- , after :: Forest a -- , parents :: List (Loc a) -- } -- insertChild :: forall a. Tree a -> Loc a -> Loc a -- insertChild n l = -- case down l of -- Just c -> insertAfter n c -- Nothing -> Loc -- { node: n -- , after: Nil -- , before: Nil -- , parents: l : (parents l) -- } -- | Insert a node as a child to the current node, and DO NOT move cursor to the new node. insertChild' :: forall a. Tree a -> TZ.Loc a -> TZ.Loc a insertChild' n (TZ.Loc l@{node}) = let n' = appendChild n node in TZ.Loc $ l { node = n' } data BlockType = Doc | H1 | H2 | H3 | H4 | H5 | H6 | L | I | T | P | Q | LISTMARK | SKIP derive instance Eq BlockType derive instance Ord BlockType derive instance Generic BlockType _ instance Bounded BlockType where top = SKIP bottom = Doc instance Enum BlockType where pred = genericPred succ = genericSucc instance BoundedEnum BlockType where cardinality = genericCardinality toEnum = genericToEnum fromEnum = genericFromEnum instance Show BlockType where show = genericShow newtype Block = Block { block :: BlockType , content :: Maybe String , children :: Array Block } derive instance Eq Block derive instance Newtype Block _ derive instance Generic Block _ instance Show Block where show (Block {block, content, children}) = "

" <> show block <> ": " <> maybe "" identity content <> "" <> foldMap show children <> "

" block ∷ F.ForeignCodec Block block = F.fix \codec → wrapIso Block $ FR.object "Block" { block: blockTypeCodec , content: FR.optional F.string , children: FC.array codec } blockTypeCodec :: F.ForeignCodec BlockType blockTypeCodec = F.prismaticCodec "BlockType" dec enc F.string where dec = case _ of "Document" -> Just Doc "h1" -> Just H1 "h2" -> Just H2 "h3" -> Just H3 "h4" -> Just H4 "h5" -> Just H5 "h6" -> Just H6 "p" -> Just P "l" -> Just L "i" -> Just I "t" -> Just T "q" -> Just Q "ListMark" -> Just LISTMARK _ -> Just SKIP enc = case _ of Doc -> "Document" _ -> "TODO" type Blocky = { block :: BlockType, content :: Maybe String } -- type Tree a = Cofree List a type BlockTree = Tree Blocky showBlockTree :: BlockTree -> String showBlockTree bt = "

" <> show block <> ": " <> maybe "" identity content <> children <> "

" where { block, content } = head bt children = foldMap showBlockTree $ tail bt input :: Foreign -> Maybe Block input f = either (const Nothing) Just (F.decode block f) blockTree :: Block -> BlockTree blockTree (Block { block, content, children } ) = mkTree { block, content } $ blockTree <$> children unBlockTree :: BlockTree -> Block unBlockTree bt = case head bt, tail bt of { block, content }, t -> Block { block, content, children: unBlockTree <$> t } -- transformBlockTree :: BlockTree -> BlockTree -- transformBlockTree orig = transformed -- where -- zipped = TZ.fromTree orig -- newRoot = TZ.fromTree $ mkTree (TZ.value zipped) Nil -- -- Under root, check for h1s. For each h1, get indexes. -- children = TZ.children zipped -- -- scanl :: forall a b f. Traversable f => (b -> a -> b) -> b -> f a -> f b -- -- foldl :: forall a b. (b -> a -> b) -> b -> f a -> b -- headings level { seenH, res } child -- | not seenH && (head child).name == "h" <> level -- -- first heading, append heading to new root and move after new child -- = { seenH: true, res: TZ.insertChild child res } -- | seenH && (head child).name == "h" <> level -- -- additional headings, move back up out of current heading, append heading and move to new child -- = { seenH, res: unsafePartial $ TZ.insertChild child (fromJust $ TZ.up $ res) } -- | not seenH -- -- top level outside of h1 blocks -- = { seenH, res: insertChild' child res } -- | otherwise -- -- append anything else to h1 and don't move -- = { seenH, res: insertChild' child res } -- { res: res1 } = foldl (headings "1") { seenH: false, res: newRoot } children -- { res } = foldl (headings "2") { seenH: false, res: TZ.root res1 } $ TZ.children res1 -- -- { res: res3 } = foldl (headings "3") { seenH: false, res: TZ.root res2 } $ TZ.children res2 -- -- { res } = foldl (headings "4") { seenH: false, res: TZ.root res3 } $ TZ.children res3 -- -- transformed = TZ.toTree zipped -- transformed = TZ.toTree res showTransform :: Foreign -> String showTransform f = "

original	transformed
" <> orig <> "	" <> bt <> "

" where orig = either show show $ F.decode block f inp = input f bt = maybe "" showBlockTree $ (transformBlockTree <<< blockTree) <$> inp -- transform val = case runExcept $ readBlock val of -- Left errs -> foldMap show errs -- Right block -> show block -- transformBlockTree = identity type BlockAcc = { spine :: NonEmpty List BlockType, cursor :: TZ.Loc Blocky } blk :: BlockTree -> BlockType blk child = (head child).block push :: forall a. a -> NonEmpty List a -> NonEmpty List a push a (b :| rest) = a :| b : rest pop :: forall a. NonEmpty List a -> Either a (Tuple a (NonEmpty List a)) pop (a :| rest) = case L.head rest, L.tail rest of Just b, Just c -> Right (Tuple a (b :| c)) _, _ -> Left a unsafePop :: forall a. NonEmpty List a -> Tuple a (NonEmpty List a) unsafePop (a :| rest ) = case L.head rest, L.tail rest of Just b, Just c -> Tuple a (b:| c) _, _ -> unsafeCrashWith "Spine invariants don't hold in blocky tree input. This code is flawed, please review." unsafePop' :: forall a. NonEmpty List a -> NonEmpty List a unsafePop' = snd <<< unsafePop transformBlockTree :: BlockTree -> BlockTree transformBlockTree orig = transformed where zipped = TZ.fromTree orig newRoot = TZ.fromTree $ mkTree (TZ.value zipped) [] {cursor} = foldl blocky { spine: singleton Doc , cursor: newRoot } $ TZ.children zipped transformed = TZ.toTree cursor transform :: Foreign -> Foreign transform f = F.encode block $ unBlockTree $ transformBlockTree $ case F.decode block f of Left err -> unsafeCrashWith $ show err Right f -> blockTree f -- semantics -- in this case -- # a -- ### b -- ## c -- insert a b' empty H2 between a and b -- - a -- - b' <-- empty H2 -- - b -- - c blocky :: BlockAcc -> BlockTree -> BlockAcc blocky { spine, cursor } c -- #, ## | blk c <= H6 && ( blk c > NE.head spine) = spyWith "downwards" (\{spine: newSpine} -> "\n b: " <> show (blk c) <> "\n spine: " <> show spine <> "\n newSpine: " <> show newSpine <> "\n cursor: " <> show (TZ.value cursor).block) { spine: push (blk c) spine, cursor: TZ.insertChild c cursor } -- ##, # | blk c <= H6 && ( blk c <= NE.head spine) = spyWith "upwards" (\_ -> "\n b: " <> show (blk c) <> "\n spine: " <> show spine <> "\n cursor: " <> show (TZ.value cursor).block) $ reattach c { spine, cursor } -- | blk c <= H6 = spyWith "blocky.reattach" (\_ -> "b: " <> show (blk c) <> " / spine: " <> show spine) $ reattach c { spine, cursor } | blk c > H6 = spyWith "leaf" (\_ -> "\n b: " <> show (blk c) <> "\n spine: " <> show spine <> "\n cursor: " <> show (TZ.value cursor).block) { spine, cursor: insertChild' c cursor } | otherwise = { spine, cursor } -- We're seeing an upper container, so we need to go back up the spine to know how to attach it reattach :: BlockTree -> BlockAcc -> BlockAcc reattach c acc@{ spine, cursor } = spyWith "reattach" (\_ -> "\n spine: " <> show spine <> "\n newSpine: " <> show newSpine <> "\n cursor: " <> show (TZ.value cursor).block <> " / " <> (foldMap show (blk <$> TZ.children cursor)) <> "\n newCursor: " <> show (TZ.value newCursor).block <> " / " <> (foldMap show (blk <$> TZ.children newCursor))) { spine: newSpine, cursor: TZ.insertAfter c $ unsafePartial $ fromJust $ TZ.lastChild newCursor } where -- find the top most container, if it already has a child of our level we're good. -- if not we need to elongate the spine with an empty container level (see semantics above). -- we leave the cursor at the right place to insert the child findContainer :: BlockType -> BlockAcc -> BlockAcc findContainer b acc@{spine, cursor} = case pop spine of Left d | d == Doc -> elongate acc -- we've backtracked all the way to the root, so we'll need to elongate | otherwise -> unsafeCrashWith "Invariant don't hold. No Doc block type at the root." Right (lv /\ sp) -- we've found the level in the spine. we return the spine as it is, and position the cursor up. | b == lv -> spyWith "b == lv" (\_ -> "\n b: " <> show b <> "\n lv: " <> show lv <> "\n sp: " <> show sp <> "\n cursor: " <> show (TZ.value cursor).block <> " / " <> (foldMap show (blk <$> TZ.children cursor))) { spine, cursor: unsafePartial $ fromJust $ TZ.up cursor } -- we've found a smaller container, we continue up. | b < lv -> spyWith "b < lv" (\_ -> "\n b: " <> show b <> "\n lv: " <> show lv <> "\n cursor: " <> show (TZ.value cursor).block <> " / " <> (foldMap show (blk <$> TZ.children cursor))) $ findContainer b { spine: sp, cursor: unsafePartial $ fromJust $ TZ.up cursor } -- we've backtracked and found a larger container, we need to elongate | otherwise -> spyWith "otherwise" (\_ -> "\n b: " <> show b <> "\n lv: " <> show lv) $ elongate { spine: sp, cursor } elongate :: BlockAcc -> BlockAcc elongate = identity { spine: newSpine, cursor: newCursor } = findContainer (blk c) acc`33:[] 2f:{"title":"Markdown tree transform","cells":[{"id":0,"value":"# Markdown tree transform\n\n> NOTE: this won't run without a [local try purescript compiler on http://127.0.0.1:8080](https://observablehq.com/@jmatsushita/purescript#cell-735) with a [forked `Data.Codec.Foreign` module](https://github.com/jmatsushita/purescript-codec-foreign).\n\nthis is observablehq.com a notebook platform developed by the nyt datavisualiser who also engineered d3js.\n\nI've yesterday put out a couple of notebooks.\n\nThis one:\n- parses some markdown with a shape I tend to use with obsidian with an existing extensible commonmark lezer parser\n- renders a \"spine\" for that tree, showing it's relevant structure and type.\n- loads the purescript compiler and runs a tree transformation\n- the resulting structure will be used to annotate the markdown document, loaded in codemirror\n- I'll try and make the codemirror gutter annotation into a reusable component","pinned":false,"hidden":false,"mode":"md"},{"id":5,"value":"lezerMarkdown = import(\"https://cdn.jsdelivr.net/npm/@lezer/markdown@1.1.2/+esm\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":11,"value":"text = `\n# LOG\n\n## Doing\n\n### Some activity\n\nAnd some text for that activity\n\n### Some H3 activity\n\nSome text\n\n#### Some H4 activity\n\nSome text before the bullet list\n\n### #tagged activity\n\nAnd some text for that tagged activity\n\n- A bullet point\n - A nested bullet point\n - A second nested point\n\nA paragraph.\n\n> A blockquote\n\n# Another H1\n\n### #tagged H3 activity\n\n- [ ] A task\n - [ ] A nested task\n - A bullet in a nested task\n - [ ] A nested task in a nested bullet\n - [x] A completed task\n - [/] A task with a custom \"in progress\" status\n`;","pinned":true,"hidden":false,"mode":"ojs"},{"id":16,"value":"//render(tree)","pinned":true,"hidden":false,"mode":"ojs"},{"id":9,"value":"tree = lezerMarkdown.parser.parse(text)","pinned":true,"hidden":false,"mode":"ojs"},{"id":14,"value":"function render(tree) {\n let lists = \"\"\n \n tree.iterate({\n //${node.tree.children.map(child => `${child}.`)}\n enter(node) {\n lists += `

${node.type.name} (${node.from} → ${node.to}) ${text.slice(node.from, node.to)}\\n`\n },\n leave() {\n lists += `

`\n },\n mode: 1\n })\n \n return Object.assign(\n html`${lists.split(\"\\n\").slice(0, 200).join(\"\\n\")}`, \n { value: tree }\n )\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":38,"value":"treeGFM = lezerMarkdown.parser.configure(lezerMarkdown.GFM).parse(text)","pinned":true,"hidden":false,"mode":"ojs"},{"id":43,"value":"//render(treeGFM)","pinned":true,"hidden":false,"mode":"ojs"},{"id":46,"value":"function spine(tree) {\n let lists = []\n \n tree.iterate({\n //${node.tree.children.map(child => `${child}.`)}\n enter(node) {\n lists += `

${abbrev(node.type.name)}\\n`\n },\n leave() {\n lists += `

`\n },\n mode: 0\n // mode: 1\n })\n \n return Object.assign(\n html`${lists.split(\"\\n\").join(\"\\n\")}`, \n { value: tree }\n )\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":52,"value":"abbrev = (type) => {\n // First deal with headings\n\n if (type.startsWith(\"ATXHeading\")) \n return type.replace(\"ATXHeading\", \"h\")\n \n switch (type) {\n case \"Document\":\n return \"doc\";\n\n case \"HeaderMark\":\n case \"QuoteMark\":\n case \"ListMark\":\n return \"...\";\n \n case \"Paragraph\":\n return \"para\";\n\n case \"BulletList\":\n return \"ul\";\n\n case \"Blockquote\":\n return \">\";\n\n case \"ListItem\":\n return \"li\";\n\n case \"Task\":\n return \"[]\";\n\n case \"TaskMarker\":\n return \"...\";\n\n default:\n console.log(\"💥 type\", type)\n return \"💥\";\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":49,"value":"spine(treeGFM)","pinned":true,"hidden":false,"mode":"ojs"},{"id":106,"value":"viewof source = PurescriptEditor()","pinned":false,"hidden":false,"mode":"ojs"},{"id":121,"value":"Inputs.button([\n [\"Compile\", () => viewof source.dispatchEvent(new Event('input', {bubbles: true}))],\n])","pinned":false,"hidden":false,"mode":"ojs"},{"id":84,"value":"$${unsafe_html`${compilation.module.showTransform(strip(treeGFM, text))}`}","pinned":false,"hidden":false,"mode":"html"},{"id":224,"value":"strip(tree, text)","pinned":true,"hidden":false,"mode":"ojs"},{"id":142,"value":"$${renderCompilationStatus(source, compilation.warnings, compilation.errors)}","pinned":false,"hidden":false,"mode":"html"},{"id":88,"value":"mdPlus`\n- [x] import purescriptEditor\n- [x] modularise and import compiler warnings and errors rendering\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":405,"value":"### corner case\n\nNot bad. TODO: implement `elongate` to add empty h2","pinned":false,"hidden":false,"mode":"md"},{"id":402,"value":"$${unsafe_html`${compilation.module.showTransform(strip(lezerMarkdown.parser.configure(lezerMarkdown.GFM).parse(cornerText), cornerText))}`}","pinned":false,"hidden":false,"mode":"html"},{"id":407,"value":"cornerText = `\n# a\n\n### c\n\n## b\n`;","pinned":false,"hidden":false,"mode":"ojs"},{"id":373,"value":"### Call purescript transform from JS","pinned":false,"hidden":false,"mode":"md"},{"id":369,"value":"compilation.module.transform(strip(treeGFM, text))","pinned":true,"hidden":false,"mode":"ojs"},{"id":375,"value":"### Add codemirror with linenumber gutter component ","pinned":false,"hidden":false,"mode":"md"},{"id":377,"value":"import {CodeMirror, myDefaultTheme} from '@jmatsushita/codemirror'","pinned":true,"hidden":false,"mode":"ojs"},{"id":379,"value":"MarkdownEditor = async (doc = '', extensions = []) => {\n const { markdown, markdownLanguage } = await import('https://jspm.dev/@codemirror/lang-markdown')\n const { lineNumbers } = await import('https://jspm.dev/@codemirror/view')\n // const { languages } = await import('@codemirror/language-data')\n return CodeMirror(doc, {\n extensions: [\n myDefaultTheme, \n lineNumbers(),\n markdown({\n base: markdownLanguage,\n // codeLanguages: languages,\n }), \n ...extensions]\n });\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":382,"value":"MarkdownEditor(text)","pinned":true,"hidden":false,"mode":"ojs"},{"id":152,"value":"## Internals","pinned":false,"hidden":false,"mode":"md"},{"id":221,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":91,"value":"import {mdPlus} from \"@tmcw/bonus-markdown-flavor\"","pinned":true,"hidden":false,"mode":"ojs"},{"id":67,"value":"import { Purescript } from \"@jmatsushita/purescript\"","pinned":true,"hidden":false,"mode":"ojs"},{"id":94,"value":"import { PurescriptEditor, renderCompilationStatus } from \"@jmatsushita/try-purescript\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":117,"value":"import {localStorageView} from \"@tomlarkworthy/local-storage-view\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":70,"value":"viewof localStorage = localStorageView(\"transform\", { defaultValue: current, bindTo: viewof source})","pinned":true,"hidden":false,"mode":"ojs"},{"id":169,"value":"persisted = { \n if (navigator.storage && navigator.storage.persist) \n { \n await navigator.storage.persist()\n let isPersisted = await navigator.storage.persisted();\n return `isPersisted: ${isPersisted}`\n } else { return \"not\" }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":180,"value":"{ if (navigator.storage && navigator.storage.estimate) {\n const storageEstimate = await navigator.storage.estimate();\n const availableSpace = storageEstimate.quota > storageEstimate.usage ? storageEstimate.quota - storageEstimate.usage : 0;\n return `${JSON.stringify(storageEstimate)} ${availableSpace}`\n}\n}\n","pinned":true,"hidden":false,"mode":"ojs"},{"id":187,"value":"{ \n let persistent, result\nif (navigator.storage && navigator.storage.persisted) {\n persistent = await navigator.storage.persisted();\n if (!persistent && navigator.storage.persist)\n result = await navigator.storage.persist();\n}\n return {persistent,result}\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":191,"value":"storage = {\n const storage = window.localStorage;\n const key = \"__storage_test__\";\n storage.setItem(key, key);\n storage.removeItem(key);\n return storage;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":193,"value":"//storage.setItem(\"save\", \"me\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":195,"value":"storage.getItem(\"save\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":231,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":200,"value":"storage.getItem(\"transform\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":198,"value":"document","pinned":true,"hidden":false,"mode":"ojs"},{"id":110,"value":"// Inputs.bind(viewof editor, viewof source)","pinned":true,"hidden":false,"mode":"ojs"},{"id":77,"value":"compilation = await Purescript(source, {compilerUrl: \"http://127.0.0.1:8080\"})","pinned":true,"hidden":false,"mode":"ojs"},{"id":138,"value":"spine(blockyTree)","pinned":true,"hidden":false,"mode":"ojs"},{"id":282,"value":"function unsafe_html() {\n const span = document.createElement(\"span\");\n span.innerHTML = String.raw.apply(this, arguments);\n return span;\n}","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W33","stdlib":"1","titling":"auto"}