Read the node tables backwards, a directive to the node and marks it names

src/markdown/parse/markdown-to-adf.ts

@@ -1,11 +1,11 @@
 import type { AdfDocument, AdfNode } from '../../adf/document.ts'
-import type { Block } from './blocks.ts'
+import type { Block, DirectiveBlock } from './blocks.ts'
 import type { LinkDefinitions } from './inline-content.ts'
 import { failure, faulted, success, type ConvertErrorPath, type Result } from '../../result.ts'
 import { largestNesting } from '../../nesting.ts'
 import { parseBlocks } from './blocks.ts'
 import { parseInlineContent } from './inline-content.ts'
-import { unknownDirectiveFault } from '../directive-syntax.ts'
+import { readBlockDirectiveNode } from './directive-nodes.ts'
 
 export function markdownToAdf(markdown: string): Result<AdfDocument> {
   const parsed = parseBlocks(markdown)
@@ -34,7 +34,7 @@ function blockNode(block: Block, definitions: LinkDefinitions, path: ConvertErro
     case 'code':
       return success(codeBlockNode(block.language, block.text))
     case 'directive':
-      return faulted(unknownDirectiveFault(block.name), path)
+      return directiveNode(block, definitions, path, depth)
     case 'fault':
       return faulted(block.fault, path)
     case 'heading':
@@ -44,16 +44,42 @@ function blockNode(block: Block, definitions: LinkDefinitions, path: ConvertErro
     case 'orderedList':
       return listNode({ attrs: { order: block.start }, type: 'orderedList' }, block.items, definitions, path, depth)
     case 'paragraph':
-      return contentNode({ type: 'paragraph' }, block.text, definitions, path)
+      return paragraphNode(block.text, definitions, path)
     case 'rule':
       return success({ type: 'rule' })
   }
 }
 
+function directiveNode(block: DirectiveBlock, definitions: LinkDefinitions, path: ConvertErrorPath, depth: number): Result<AdfNode> {
+  const read = readBlockDirectiveNode(block.name, block.argument, block.attributes, path)
+  if (!read.ok) return read
+  const { contentModel, node } = read.value
+  const blocks = block.blocks
+  if (blocks === undefined) {
+    if (contentModel === 'none' || contentModel === 'inline') return success(node)
+    return failure('unsupported-node-shape', `a ${node.type} spells its body in the container form :::${node.type}`, path)
+  }
+  if (contentModel === 'none') return failure('unsupported-node-shape', `a ${node.type} holds no content`, path)
+  if (contentModel === 'code') return failure('unsupported-node-shape', `the fenced body of a ${node.type} is unsupported`, path)
+  if (contentModel === 'block') return containerNode(node, blocks, definitions, path, depth)
+  return inlineBodyNode(node, blocks, definitions, path)
+}
+
+function inlineBodyNode(node: AdfNode, blocks: readonly Block[], definitions: LinkDefinitions, path: ConvertErrorPath): Result<AdfNode> {
+  if (blocks.length === 0) return failure('unsupported-node-shape', `an empty ${node.type} is the leaf form ::${node.type}`, path)
+  const only = blocks.length === 1 ? blocks[0] : undefined
+  if (only?.kind !== 'paragraph') return failure('unsupported-node-shape', `a ${node.type} takes one paragraph as its body`, path)
+  return contentNode(node, only.text, definitions, path)
+}
+
 function containerNode(node: AdfNode, blocks: readonly Block[], definitions: LinkDefinitions, path: ConvertErrorPath, depth: number): Result<AdfNode> {
   const content = blockNodes(blocks, definitions, path, depth + 1)
   if (!content.ok) return content
-  return success(content.value.length === 0 ? node : { ...node, content: content.value })
+  return success(withContent(node, content.value))
+}
+
+function withContent(node: AdfNode, content: readonly AdfNode[]): AdfNode {
+  return content.length === 0 ? node : { ...node, content: [...content] }
 }
 
 function listNode(node: AdfNode, items: readonly Block[][], definitions: LinkDefinitions, path: ConvertErrorPath, depth: number): Result<AdfNode> {
@@ -71,13 +97,17 @@ function codeBlockNode(language: string, text: string): AdfNode {
   return text === '' ? node : { ...node, content: [{ text, type: 'text' }] }
 }
 
-// spec/flavour.md, The CommonMark image: only a paragraph gives an image the block it needs.
-function contentNode(node: AdfNode, text: string, definitions: LinkDefinitions, path: ConvertErrorPath): Result<AdfNode> {
+// spec/flavour.md, The CommonMark image: only a plain paragraph gives an image the block it needs.
+function paragraphNode(text: string, definitions: LinkDefinitions, path: ConvertErrorPath): Result<AdfNode> {
   const content = parseInlineContent(text, definitions, path)
   if (!content.ok) return content
   const image = content.value.image
-  if (image !== undefined) {
-    return node.type === 'paragraph' ? success(image) : failure('unmappable-image', `no ADF node carries an image inside a ${node.type}`, path)
-  }
-  return success(content.value.nodes.length === 0 ? node : { ...node, content: content.value.nodes })
+  return success(image === undefined ? withContent({ type: 'paragraph' }, content.value.nodes) : image)
+}
+
+function contentNode(node: AdfNode, text: string, definitions: LinkDefinitions, path: ConvertErrorPath): Result<AdfNode> {
+  const content = parseInlineContent(text, definitions, path)
+  if (!content.ok) return content
+  if (content.value.image !== undefined) return failure('unmappable-image', `no ADF node carries an image inside a ${node.type}`, path)
+  return success(withContent(node, content.value.nodes))
 }