+99 -68

actions/publishToPublication.ts

··· 7 7 import { 8 8 AtpBaseClient, 9 9 PubLeafletBlocksHeader, 10 10 + PubLeafletBlocksImage, 10 11 PubLeafletBlocksText, 12 12 + PubLeafletBlocksUnorderedList, 11 13 PubLeafletDocument, 12 14 PubLeafletPagesLinearDocument, 13 15 PubLeafletRichtextFacet, ··· 23 25 YJSFragmentToString, 24 26 } from "components/Blocks/TextBlock/RenderYJSFragment"; 25 27 import { ids } from "lexicons/api/lexicons"; 26 26 - import { OmitKey } from "lexicons/api/util"; 27 28 import { BlobRef } from "@atproto/lexicon"; 28 29 import { IdResolver } from "@atproto/identity"; 29 30 import { AtUri } from "@atproto/syntax"; 30 31 import { Json } from "supabase/database.types"; 31 31 - import { UnicodeString } from "@atproto/api"; 32 32 + import { $Typed, UnicodeString } from "@atproto/api"; 33 33 + import { List, parseBlocksToList } from "src/utils/parseBlocksToList"; 32 34 33 35 const idResolver = new IdResolver(); 34 36 export async function publishToPublication({ ··· 138 140 blocks: Block[], 139 141 imageMap: Map<string, BlobRef>, 140 142 scan: ReturnType<typeof scanIndexLocal>, 143 143 + ): PubLeafletPagesLinearDocument.Block[] { 144 144 + let parsedBlocks = parseBlocksToList(blocks); 145 145 + return parsedBlocks.flatMap((blockOrList) => { 146 146 + if (blockOrList.type === "block") { 147 147 + let alignmentValue = 148 148 + scan.eav(blockOrList.block.value, "block/text-alignment")[0]?.data 149 149 + .value || "left"; 150 150 + let alignment = 151 151 + alignmentValue === "center" 152 152 + ? "lex:pub.leaflet.pages.linearDocument#textAlignCenter" 153 153 + : alignmentValue === "right" 154 154 + ? "lex:pub.leaflet.pages.linearDocument#textAlignRight" 155 155 + : undefined; 156 156 + let b = blockToRecord(blockOrList.block, imageMap, scan); 157 157 + if (!b) return []; 158 158 + let block: PubLeafletPagesLinearDocument.Block = { 159 159 + $type: "pub.leaflet.pages.linearDocument#block", 160 160 + alignment, 161 161 + block: b, 162 162 + }; 163 163 + return [block]; 164 164 + } else { 165 165 + let block: PubLeafletPagesLinearDocument.Block = { 166 166 + $type: "pub.leaflet.pages.linearDocument#block", 167 167 + block: { 168 168 + $type: "pub.leaflet.blocks.unorderedList", 169 169 + children: childrenToRecord(blockOrList.children, imageMap, scan), 170 170 + }, 171 171 + }; 172 172 + return [block]; 173 173 + } 174 174 + }); 175 175 + } 176 176 + 177 177 + function childrenToRecord( 178 178 + children: List[], 179 179 + imageMap: Map<string, BlobRef>, 180 180 + scan: ReturnType<typeof scanIndexLocal>, 181 181 + ) { 182 182 + return children.flatMap((child) => { 183 183 + let content = blockToRecord(child.block, imageMap, scan); 184 184 + if (!content) return []; 185 185 + let record: PubLeafletBlocksUnorderedList.ListItem = { 186 186 + $type: "pub.leaflet.blocks.unorderedList#listItem", 187 187 + content, 188 188 + children: childrenToRecord(child.children, imageMap, scan), 189 189 + }; 190 190 + return record; 191 191 + }); 192 192 + } 193 193 + function blockToRecord( 194 194 + b: Block, 195 195 + imageMap: Map<string, BlobRef>, 196 196 + scan: ReturnType<typeof scanIndexLocal>, 141 197 ) { 142 198 const getBlockContent = (b: string) => { 143 199 let [content] = scan.eav(b, "block/text"); 144 144 - if (!content) return ""; 200 200 + if (!content) return ["", [] as PubLeafletRichtextFacet.Main[]] as const; 145 201 let doc = new Y.Doc(); 146 202 const update = base64.toByteArray(content.data.value); 147 203 Y.applyUpdate(doc, update); 148 204 let nodes = doc.getXmlElement("prosemirror").toArray(); 149 205 let stringValue = YJSFragmentToString(nodes[0]); 150 206 let facets = YJSFragmentToFacets(nodes[0]); 151 151 - return [stringValue, facets]; 207 207 + return [stringValue, facets] as const; 152 208 }; 153 153 - return blocks.flatMap((b) => { 154 154 - if (b.type !== "text" && b.type !== "heading" && b.type !== "image") 155 155 - return []; 156 156 - let alignmentValue = 157 157 - scan.eav(b.value, "block/text-alignment")[0]?.data.value || "left"; 209 209 + if (b.type !== "text" && b.type !== "heading" && b.type !== "image") return; 210 210 + let alignmentValue = 211 211 + scan.eav(b.value, "block/text-alignment")[0]?.data.value || "left"; 158 212 159 159 - let alignment = 160 160 - alignmentValue === "center" 161 161 - ? "lex:pub.leaflet.pages.linearDocument#textAlignCenter" 162 162 - : alignmentValue === "right" 163 163 - ? "lex:pub.leaflet.pages.linearDocument#textAlignRight" 164 164 - : undefined; 213 213 + if (b.type === "heading") { 214 214 + let [headingLevel] = scan.eav(b.value, "block/heading-level"); 165 215 166 166 - if (b.type === "heading") { 167 167 - let [headingLevel] = scan.eav(b.value, "block/heading-level"); 216 216 + let [stringValue, facets] = getBlockContent(b.value); 217 217 + let block: $Typed<PubLeafletBlocksHeader.Main> = { 218 218 + $type: "pub.leaflet.blocks.header", 219 219 + level: headingLevel?.data.value || 1, 220 220 + plaintext: stringValue, 221 221 + facets, 222 222 + }; 223 223 + return block; 224 224 + } 168 225 169 169 - let [stringValue, facets] = getBlockContent(b.value); 170 170 - return [ 171 171 - { 172 172 - $type: "pub.leaflet.pages.linearDocument#block", 173 173 - alignment, 174 174 - block: { 175 175 - $type: "pub.leaflet.blocks.header", 176 176 - level: headingLevel?.data.value || 1, 177 177 - plaintext: stringValue, 178 178 - facets, 179 179 - }, 180 180 - } as PubLeafletPagesLinearDocument.Block, 181 181 - ]; 182 182 - } 183 183 - 184 184 - if (b.type == "text") { 185 185 - let [stringValue, facets] = getBlockContent(b.value); 186 186 - return [ 187 187 - { 188 188 - $type: "pub.leaflet.pages.linearDocument#block", 189 189 - alignment, 190 190 - block: { 191 191 - $type: ids.PubLeafletBlocksText, 192 192 - plaintext: stringValue, 193 193 - facets, 194 194 - }, 195 195 - } as PubLeafletPagesLinearDocument.Block, 196 196 - ]; 197 197 - } 198 198 - if (b.type == "image") { 199 199 - let [image] = scan.eav(b.value, "block/image"); 200 200 - if (!image) return []; 201 201 - let blobref = imageMap.get(image.data.src); 202 202 - if (!blobref) return []; 203 203 - return [ 204 204 - { 205 205 - $type: "pub.leaflet.pages.linearDocument#block", 206 206 - alignment, 207 207 - block: { 208 208 - $type: "pub.leaflet.blocks.image", 209 209 - image: blobref, 210 210 - aspectRatio: { 211 211 - height: image.data.height, 212 212 - width: image.data.width, 213 213 - }, 214 214 - }, 215 215 - } as PubLeafletPagesLinearDocument.Block, 216 216 - ]; 217 217 - } 218 218 - return []; 219 219 - }); 226 226 + if (b.type == "text") { 227 227 + let [stringValue, facets] = getBlockContent(b.value); 228 228 + let block: $Typed<PubLeafletBlocksText.Main> = { 229 229 + $type: ids.PubLeafletBlocksText, 230 230 + plaintext: stringValue, 231 231 + facets, 232 232 + }; 233 233 + return block; 234 234 + } 235 235 + if (b.type == "image") { 236 236 + let [image] = scan.eav(b.value, "block/image"); 237 237 + if (!image) return; 238 238 + let blobref = imageMap.get(image.data.src); 239 239 + if (!blobref) return; 240 240 + let block: $Typed<PubLeafletBlocksImage.Main> = { 241 241 + $type: "pub.leaflet.blocks.image", 242 242 + image: blobref, 243 243 + aspectRatio: { 244 244 + height: image.data.height, 245 245 + width: image.data.width, 246 246 + }, 247 247 + }; 248 248 + return block; 249 249 + } 250 250 + return; 220 251 } 221 252 222 253 async function sendPostToEmailSubscribers(

+28

app/lish/[did]/[publication]/[rkey]/page.tsx

··· 6 6 PubLeafletBlocksHeader, 7 7 PubLeafletBlocksImage, 8 8 PubLeafletBlocksText, 9 9 + PubLeafletBlocksUnorderedList, 9 10 PubLeafletDocument, 10 11 PubLeafletPagesLinearDocument, 11 12 } from "lexicons/api"; ··· 109 110 let className = `${b.alignment === "lex:pub.leaflet.pages.linearDocument#textAlignRight" ? "text-right" : b.alignment === "lex:pub.leaflet.pages.linearDocument#textAlignCenter" ? "text-center" : ""}`; 110 111 console.log(b.alignment); 111 112 switch (true) { 113 113 + case PubLeafletBlocksUnorderedList.isMain(b.block): { 114 114 + return ( 115 115 + <ul> 116 116 + {b.block.children.map((child, index) => ( 117 117 + <ListItem item={child} did={did} key={index} /> 118 118 + ))} 119 119 + </ul> 120 120 + ); 121 121 + } 112 122 case PubLeafletBlocksImage.isMain(b.block): { 113 123 return ( 114 124 <img ··· 156 166 return null; 157 167 } 158 168 }; 169 169 + 170 170 + function ListItem(props: { 171 171 + item: PubLeafletBlocksUnorderedList.ListItem; 172 172 + did: string; 173 173 + }) { 174 174 + return ( 175 175 + <li> 176 176 + <Block block={{ block: props.item.content }} did={props.did} /> 177 177 + {props.item.children?.length ? ( 178 178 + <ul> 179 179 + {props.item.children.map((child, index) => ( 180 180 + <ListItem item={child} did={props.did} key={index} /> 181 181 + ))} 182 182 + </ul> 183 183 + ) : null} 184 184 + </li> 185 185 + ); 186 186 + }

+2

lexicons/api/index.ts

··· 10 10 import * as PubLeafletBlocksHeader from './types/pub/leaflet/blocks/header' 11 11 import * as PubLeafletBlocksImage from './types/pub/leaflet/blocks/image' 12 12 import * as PubLeafletBlocksText from './types/pub/leaflet/blocks/text' 13 13 + import * as PubLeafletBlocksUnorderedList from './types/pub/leaflet/blocks/unorderedList' 13 14 import * as PubLeafletPagesLinearDocument from './types/pub/leaflet/pages/linearDocument' 14 15 import * as PubLeafletRichtextFacet from './types/pub/leaflet/richtext/facet' 15 16 import * as ComAtprotoLabelDefs from './types/com/atproto/label/defs' ··· 31 32 export * as PubLeafletBlocksHeader from './types/pub/leaflet/blocks/header' 32 33 export * as PubLeafletBlocksImage from './types/pub/leaflet/blocks/image' 33 34 export * as PubLeafletBlocksText from './types/pub/leaflet/blocks/text' 35 35 + export * as PubLeafletBlocksUnorderedList from './types/pub/leaflet/blocks/unorderedList' 34 36 export * as PubLeafletPagesLinearDocument from './types/pub/leaflet/pages/linearDocument' 35 37 export * as PubLeafletRichtextFacet from './types/pub/leaflet/richtext/facet' 36 38 export * as ComAtprotoLabelDefs from './types/com/atproto/label/defs'

+42

lexicons/api/lexicons.ts

··· 179 179 }, 180 180 }, 181 181 }, 182 182 + PubLeafletBlocksUnorderedList: { 183 183 + lexicon: 1, 184 184 + id: 'pub.leaflet.blocks.unorderedList', 185 185 + defs: { 186 186 + main: { 187 187 + type: 'object', 188 188 + required: ['children'], 189 189 + properties: { 190 190 + children: { 191 191 + type: 'array', 192 192 + items: { 193 193 + type: 'ref', 194 194 + ref: 'lex:pub.leaflet.blocks.unorderedList#listItem', 195 195 + }, 196 196 + }, 197 197 + }, 198 198 + }, 199 199 + listItem: { 200 200 + type: 'object', 201 201 + required: ['content'], 202 202 + properties: { 203 203 + content: { 204 204 + type: 'union', 205 205 + refs: [ 206 206 + 'lex:pub.leaflet.blocks.text', 207 207 + 'lex:pub.leaflet.blocks.header', 208 208 + 'lex:pub.leaflet.blocks.image', 209 209 + ], 210 210 + }, 211 211 + children: { 212 212 + type: 'array', 213 213 + items: { 214 214 + type: 'ref', 215 215 + ref: 'lex:pub.leaflet.blocks.unorderedList#listItem', 216 216 + }, 217 217 + }, 218 218 + }, 219 219 + }, 220 220 + }, 221 221 + }, 182 222 PubLeafletPagesLinearDocument: { 183 223 lexicon: 1, 184 224 id: 'pub.leaflet.pages.linearDocument', ··· 205 245 'lex:pub.leaflet.blocks.text', 206 246 'lex:pub.leaflet.blocks.header', 207 247 'lex:pub.leaflet.blocks.image', 248 248 + 'lex:pub.leaflet.blocks.unorderedList', 208 249 ], 209 250 }, 210 251 alignment: { ··· 1301 1342 PubLeafletBlocksHeader: 'pub.leaflet.blocks.header', 1302 1343 PubLeafletBlocksImage: 'pub.leaflet.blocks.image', 1303 1344 PubLeafletBlocksText: 'pub.leaflet.blocks.text', 1345 1345 + PubLeafletBlocksUnorderedList: 'pub.leaflet.blocks.unorderedList', 1304 1346 PubLeafletPagesLinearDocument: 'pub.leaflet.pages.linearDocument', 1305 1347 PubLeafletRichtextFacet: 'pub.leaflet.richtext.facet', 1306 1348 ComAtprotoLabelDefs: 'com.atproto.label.defs',

+49

lexicons/api/types/pub/leaflet/blocks/unorderedList.ts

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { ValidationResult, BlobRef } from '@atproto/lexicon' 5 5 + import { CID } from 'multiformats/cid' 6 6 + import { validate as _validate } from '../../../../lexicons' 7 7 + import { $Typed, is$typed as _is$typed, OmitKey } from '../../../../util' 8 8 + import type * as PubLeafletBlocksText from './text' 9 9 + import type * as PubLeafletBlocksHeader from './header' 10 10 + import type * as PubLeafletBlocksImage from './image' 11 11 + 12 12 + const is$typed = _is$typed, 13 13 + validate = _validate 14 14 + const id = 'pub.leaflet.blocks.unorderedList' 15 15 + 16 16 + export interface Main { 17 17 + $type?: 'pub.leaflet.blocks.unorderedList' 18 18 + children: ListItem[] 19 19 + } 20 20 + 21 21 + const hashMain = 'main' 22 22 + 23 23 + export function isMain<V>(v: V) { 24 24 + return is$typed(v, id, hashMain) 25 25 + } 26 26 + 27 27 + export function validateMain<V>(v: V) { 28 28 + return validate<Main & V>(v, id, hashMain) 29 29 + } 30 30 + 31 31 + export interface ListItem { 32 32 + $type?: 'pub.leaflet.blocks.unorderedList#listItem' 33 33 + content: 34 34 + | $Typed<PubLeafletBlocksText.Main> 35 35 + | $Typed<PubLeafletBlocksHeader.Main> 36 36 + | $Typed<PubLeafletBlocksImage.Main> 37 37 + | { $type: string } 38 38 + children?: ListItem[] 39 39 + } 40 40 + 41 41 + const hashListItem = 'listItem' 42 42 + 43 43 + export function isListItem<V>(v: V) { 44 44 + return is$typed(v, id, hashListItem) 45 45 + } 46 46 + 47 47 + export function validateListItem<V>(v: V) { 48 48 + return validate<ListItem & V>(v, id, hashListItem) 49 49 + }

+2

lexicons/api/types/pub/leaflet/pages/linearDocument.ts

··· 8 8 import type * as PubLeafletBlocksText from '../blocks/text' 9 9 import type * as PubLeafletBlocksHeader from '../blocks/header' 10 10 import type * as PubLeafletBlocksImage from '../blocks/image' 11 11 + import type * as PubLeafletBlocksUnorderedList from '../blocks/unorderedList' 11 12 12 13 const is$typed = _is$typed, 13 14 validate = _validate ··· 34 35 | $Typed<PubLeafletBlocksText.Main> 35 36 | $Typed<PubLeafletBlocksHeader.Main> 36 37 | $Typed<PubLeafletBlocksImage.Main> 38 38 + | $Typed<PubLeafletBlocksUnorderedList.Main> 37 39 | { $type: string } 38 40 alignment?: 39 41 | 'lex:pub.leaflet.pages.linearDocument#textAlignLeft'

+44

lexicons/pub/leaflet/blocks/unorderedList.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "pub.leaflet.blocks.unorderedList", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "object", 7 7 + "required": [ 8 8 + "children" 9 9 + ], 10 10 + "properties": { 11 11 + "children": { 12 12 + "type": "array", 13 13 + "items": { 14 14 + "type": "ref", 15 15 + "ref": "#listItem" 16 16 + } 17 17 + } 18 18 + } 19 19 + }, 20 20 + "listItem": { 21 21 + "type": "object", 22 22 + "required": [ 23 23 + "content" 24 24 + ], 25 25 + "properties": { 26 26 + "content": { 27 27 + "type": "union", 28 28 + "refs": [ 29 29 + "pub.leaflet.blocks.text", 30 30 + "pub.leaflet.blocks.header", 31 31 + "pub.leaflet.blocks.image" 32 32 + ] 33 33 + }, 34 34 + "children": { 35 35 + "type": "array", 36 36 + "items": { 37 37 + "type": "ref", 38 38 + "ref": "#listItem" 39 39 + } 40 40 + } 41 41 + } 42 42 + } 43 43 + } 44 44 + }

+2 -1

lexicons/pub/leaflet/pages/linearDocument.json

··· 25 25 "refs": [ 26 26 "pub.leaflet.blocks.text", 27 27 "pub.leaflet.blocks.header", 28 28 - "pub.leaflet.blocks.image" 28 28 + "pub.leaflet.blocks.image", 29 29 + "pub.leaflet.blocks.unorderedList" 29 30 ] 30 31 }, 31 32 "alignment": {

+30 -1

lexicons/src/blocks.ts

··· 68 68 }, 69 69 }; 70 70 71 71 + export const PubLeafletBlocksUnorderedList: LexiconDoc = { 72 72 + lexicon: 1, 73 73 + id: "pub.leaflet.blocks.unorderedList", 74 74 + defs: { 75 75 + main: { 76 76 + type: "object", 77 77 + required: ["children"], 78 78 + properties: { 79 79 + children: { type: "array", items: { type: "ref", ref: "#listItem" } }, 80 80 + }, 81 81 + }, 82 82 + listItem: { 83 83 + type: "object", 84 84 + required: ["content"], 85 85 + properties: { 86 86 + content: { 87 87 + type: "union", 88 88 + refs: [ 89 89 + PubLeafletBlocksText, 90 90 + PubLeafletBlocksHeader, 91 91 + PubLeafletBlocksImage, 92 92 + ].map((l) => l.id), 93 93 + }, 94 94 + children: { type: "array", items: { type: "ref", ref: "#listItem" } }, 95 95 + }, 96 96 + }, 97 97 + }, 98 98 + }; 71 99 export const BlockLexicons = [ 72 100 PubLeafletBlocksText, 73 101 PubLeafletBlocksHeader, 74 102 PubLeafletBlocksImage, 103 103 + PubLeafletBlocksUnorderedList, 75 104 ]; 76 105 export const BlockUnion: LexRefUnion = { 77 106 type: "union", 78 78 - refs: BlockLexicons.map((lexicon) => lexicon.id), 107 107 + refs: [...BlockLexicons.map((lexicon) => lexicon.id)], 79 108 };

+2 -73

src/utils/getBlocksAsHTML.tsx

··· 6 6 import * as base64 from "base64-js"; 7 7 import { RenderYJSFragment } from "components/Blocks/TextBlock/RenderYJSFragment"; 8 8 import { Block } from "components/Blocks/Block"; 9 9 - import { getBlocksWithType } from "src/hooks/queries/useBlocks"; 9 9 + import { List, parseBlocksToList } from "./parseBlocksToList"; 10 10 11 11 export async function getBlocksAsHTML( 12 12 rep: Replicache<ReplicacheMutators>, ··· 14 14 ) { 15 15 let data = await rep?.query(async (tx) => { 16 16 let result: string[] = []; 17 17 - let parsed = parseBlocks(selectedBlocks); 17 17 + let parsed = parseBlocksToList(selectedBlocks); 18 18 for (let pb of parsed) { 19 19 if (pb.type === "block") result.push(await renderBlock(pb.block, tx)); 20 20 else ··· 150 150 />, 151 151 ); 152 152 } 153 153 - 154 154 - function parseBlocks(blocks: Block[]) { 155 155 - let parsed: ParsedBlocks = []; 156 156 - for (let i = 0; i < blocks.length; i++) { 157 157 - let b = blocks[i]; 158 158 - if (!b.listData) parsed.push({ type: "block", block: b }); 159 159 - else { 160 160 - let previousBlock = parsed[parsed.length - 1]; 161 161 - if ( 162 162 - !previousBlock || 163 163 - previousBlock.type !== "list" || 164 164 - previousBlock.depth > b.listData.depth 165 165 - ) 166 166 - parsed.push({ 167 167 - type: "list", 168 168 - depth: b.listData.depth, 169 169 - children: [ 170 170 - { 171 171 - type: "list", 172 172 - block: b, 173 173 - depth: b.listData.depth, 174 174 - children: [], 175 175 - }, 176 176 - ], 177 177 - }); 178 178 - else { 179 179 - let depth = b.listData.depth; 180 180 - if (depth === previousBlock.depth) 181 181 - previousBlock.children.push({ 182 182 - type: "list", 183 183 - block: b, 184 184 - depth: b.listData.depth, 185 185 - children: [], 186 186 - }); 187 187 - else { 188 188 - let parent = 189 189 - previousBlock.children[previousBlock.children.length - 1]; 190 190 - while (depth > 1) { 191 191 - if ( 192 192 - parent.children[parent.children.length - 1] && 193 193 - parent.children[parent.children.length - 1].depth < 194 194 - b.listData.depth 195 195 - ) { 196 196 - parent = parent.children[parent.children.length - 1]; 197 197 - } 198 198 - depth -= 1; 199 199 - } 200 200 - parent.children.push({ 201 201 - type: "list", 202 202 - block: b, 203 203 - depth: b.listData.depth, 204 204 - children: [], 205 205 - }); 206 206 - } 207 207 - } 208 208 - } 209 209 - } 210 210 - return parsed; 211 211 - } 212 212 - 213 213 - type ParsedBlocks = Array< 214 214 - | { type: "block"; block: Block } 215 215 - | { type: "list"; depth: number; children: List[] } 216 216 - >; 217 217 - 218 218 - type List = { 219 219 - type: "list"; 220 220 - block: Block; 221 221 - depth: number; 222 222 - children: List[]; 223 223 - };

+72

src/utils/parseBlocksToList.ts

··· 1 1 + import type { Block } from "components/Blocks/Block"; 2 2 + 3 3 + export function parseBlocksToList(blocks: Block[]) { 4 4 + let parsed: ParsedBlocks = []; 5 5 + for (let i = 0; i < blocks.length; i++) { 6 6 + let b = blocks[i]; 7 7 + if (!b.listData) parsed.push({ type: "block", block: b }); 8 8 + else { 9 9 + let previousBlock = parsed[parsed.length - 1]; 10 10 + if ( 11 11 + !previousBlock || 12 12 + previousBlock.type !== "list" || 13 13 + previousBlock.depth > b.listData.depth 14 14 + ) 15 15 + parsed.push({ 16 16 + type: "list", 17 17 + depth: b.listData.depth, 18 18 + children: [ 19 19 + { 20 20 + type: "list", 21 21 + block: b, 22 22 + depth: b.listData.depth, 23 23 + children: [], 24 24 + }, 25 25 + ], 26 26 + }); 27 27 + else { 28 28 + let depth = b.listData.depth; 29 29 + if (depth === previousBlock.depth) 30 30 + previousBlock.children.push({ 31 31 + type: "list", 32 32 + block: b, 33 33 + depth: b.listData.depth, 34 34 + children: [], 35 35 + }); 36 36 + else { 37 37 + let parent = 38 38 + previousBlock.children[previousBlock.children.length - 1]; 39 39 + while (depth > 1) { 40 40 + if ( 41 41 + parent.children[parent.children.length - 1] && 42 42 + parent.children[parent.children.length - 1].depth < 43 43 + b.listData.depth 44 44 + ) { 45 45 + parent = parent.children[parent.children.length - 1]; 46 46 + } 47 47 + depth -= 1; 48 48 + } 49 49 + parent.children.push({ 50 50 + type: "list", 51 51 + block: b, 52 52 + depth: b.listData.depth, 53 53 + children: [], 54 54 + }); 55 55 + } 56 56 + } 57 57 + } 58 58 + } 59 59 + return parsed; 60 60 + } 61 61 + 62 62 + type ParsedBlocks = Array< 63 63 + | { type: "block"; block: Block } 64 64 + | { type: "list"; depth: number; children: List[] } 65 65 + >; 66 66 + 67 67 + export type List = { 68 68 + type: "list"; 69 69 + block: Block; 70 70 + depth: number; 71 71 + children: List[]; 72 72 + };