16 - no link wraps a link: the outer brackets go literal, the directive form is refused

src/markdown/parse/inline-content.ts

@@ -53,6 +53,7 @@ type SlotContent = { carry: boolean; nodes: AdfNode[] }
 const carriedInMark = 'no mark spelling wraps an opaque carry: the carried node restores exactly, marks included'
 const hreflessLink = 'the link mark spells its href: this one spells none'
 const imageAlone = 'an image fits only as a paragraph of its own: this one sits inside other content'
+const linkInLink = 'no link wraps a link: the [content] this one marks already holds one'
 const spellableLink = 'link takes the directive form only where CommonMark cannot spell it: this one it can, as [text](url "title") or <url>'
 
 export function parseInlineContent(source: string, definitions: LinkDefinitions, path: ConvertErrorPath, container: LineContainer): Result<InlineContent> {
@@ -218,6 +219,7 @@ function directiveMarkPiece(scan: Scan, name: string, mark: AdfMark, slot: SlotC
 function refuseLinkDirective(scan: Scan, mark: AdfMark, nodes: readonly AdfNode[], index: number): Result<Piece> | undefined {
   const href = linkHref(nodeAttrs(mark))
   if (href === undefined) return failure('unsupported-node-shape', hreflessLink, scan.path)
+  if (holdsLink(nodes)) return failure('unsupported-node-shape', linkInLink, scan.path)
   if (commonMarkLink(nodeAttrs(mark), href, nodes, 0, scan.container === undefined) === undefined) return undefined
   if (index !== 0 || scan.container !== 'paragraph') return failure('unsupported-node-shape', spellableLink, scan.path)
   scan.openingSpellableLink = true
@@ -264,6 +266,10 @@ function holdsImage(pieces: readonly Piece[]): boolean {
   return pieces.some((piece) => piece.kind === 'image')
 }
 
+function holdsLink(nodes: readonly AdfNode[]): boolean {
+  return nodes.some((node) => nodeMarks(node).some((mark) => mark.type === 'link'))
+}
+
 function readDelimiterRun(scan: Scan, index: number): number {
   const character = scan.source.charAt(index)
   const length = runLength(scan.source, index)
@@ -340,14 +346,14 @@ function resolveTarget(scan: Scan, bracket: Bracket, index: number): { definitio
   return { definition, length: label?.length ?? 0 }
 }
 
-// `false` where the link text is empty: the mark has no node to ride, so the brackets stay text.
+// `false` keeps the brackets text: an empty link text gives the mark no node to ride, and a linked one no room for a second.
 function closeLink(scan: Scan, at: number, inner: readonly Piece[], definition: LinkDefinition): Result<boolean> {
   if (holdsImage(inner)) return failure('unmappable-image', imageAlone, scan.path)
   if (holdsCarry(inner)) return failure('unsupported-node-shape', carriedInMark, scan.path)
   const resolved = resolveNodes(inner, scan.path)
   if (!resolved.ok) return resolved
   const nodes = resolved.value
-  if (nodes.length === 0) return success(false)
+  if (nodes.length === 0 || holdsLink(nodes)) return success(false)
   const attrs = definition.title === undefined ? { href: definition.destination } : { href: definition.destination, title: definition.title }
   scan.pieces.length = at
   // CommonMark: no link nests inside another, though an image's description holds one.

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

@@ -825,6 +825,22 @@ test('leaves the bracket pair no link parses as the text it holds', () => {
   ])
 })
 
+test('leaves the brackets of a link whose text already holds one the text they are', () => {
+  const held: AdfMark = { attrs: { collection: 'c', href: '/u' }, type: 'link' }
+  assert.deepEqual(content(markdownToAdf('[<http://x/>](/v)\n')), [
+    { content: [text('['), marked('http://x/', link('http://x/')), text('](/v)')], type: 'paragraph' },
+  ])
+  assert.deepEqual(content(markdownToAdf('[a<http://x/>b](/v)\n')), [
+    { content: [text('[a'), marked('http://x/', link('http://x/')), text('b](/v)')], type: 'paragraph' },
+  ])
+  assert.deepEqual(content(markdownToAdf('[!adf:link[a]{collection=c href="/u"}](/v)\n')), [
+    { content: [text('['), marked('a', held), text('](/v)')], type: 'paragraph' },
+  ])
+  assert.deepEqual(content(markdownToAdf('[<http://x/>][r]\n\n[r]: /v\n')), [
+    { content: [text('['), marked('http://x/', link('http://x/')), text(']'), marked('r', link('/v'))], type: 'paragraph' },
+  ])
+})
+
 test('reads the reference links a definition resolves, and leaves the rest literal', () => {
   assert.deepEqual(content(markdownToAdf('[a][r]\n\n[r]: /url\n')), [{ content: [marked('a', link('/url'))], type: 'paragraph' }])
   assert.deepEqual(content(markdownToAdf('[a][]\n\n[a]: /url\n')), [{ content: [marked('a', link('/url'))], type: 'paragraph' }])
@@ -996,6 +1012,14 @@ test('names the href the directive link spells no value for', () => {
   assert.equal(content(markdownToAdf('!adf:link[a]\n')), named)
   assert.equal(content(markdownToAdf('!adf:link[a]{title=t}\n')), named)
   assert.equal(content(markdownToAdf('See !adf:link[a]{id=01a032c3-7a90-70c9-88f6-c60f710eda07}.\n')), named)
+  assert.equal(content(markdownToAdf('!adf:link[<http://x/>]{collection=c}\n')), named)
+})
+
+test('names the link a directive link wraps, no link holding another', () => {
+  const named = 'unsupported-node-shape: no link wraps a link: the [content] this one marks already holds one'
+  assert.equal(content(markdownToAdf('!adf:link[<http://x/>]{collection=c href="/u"}\n')), named)
+  assert.equal(content(markdownToAdf('!adf:link[[a](/v)]{collection=c href="/u"}\n')), named)
+  assert.equal(content(markdownToAdf('!adf:link[a <http://x/> b]{collection=c href="/u"}\n')), named)
 })
 
 test('names the directive mark left without the content it wraps', () => {