`
}
diff --git a/src/html/emit/inline.ts b/src/html/emit/inline.ts
index d84f4b6..2be4a11 100644
--- a/src/html/emit/inline.ts
+++ b/src/html/emit/inline.ts
@@ -2,7 +2,7 @@ import type { AdfMark, AdfNode } from '../../adf/document.ts'
import { anchorOpener } from '../anchor-element.ts'
import { carriedInline } from './carry-element.ts'
import { elementOfMark } from '../mark-elements.ts'
-import { holdsOnlyAttributes, isSpellableText, isUnmarkedSpellableText, nodeAttrs, nodeContent, nodeMarks } from '../../adf/document.ts'
+import { holdsOnlyAttributes, isSpellableText, isUnmarkedSpellableText, nodeAttrs, nodeMarks } from '../../adf/document.ts'
import { linkAttrs } from '../../adf/mark-attributes.ts'
import { nodeElement } from './node-element.ts'
import { success, type ConvertErrorPath, type Result } from '../../result.ts'
@@ -25,7 +25,7 @@ export function inlineHtml(nodes: readonly AdfNode[], path: ConvertErrorPath): R
}
function tryInlineNode(node: AdfNode): string | undefined {
- if (node.type === 'hardBreak') return holdsOnlyAttributes(node, []) && nodeContent(node).length === 0 ? '
' : undefined
+ if (node.type === 'hardBreak') return holdsOnlyAttributes(node, []) ? '
' : undefined
const element = nodeElement(node)
if (element !== undefined) return element
const text = isSpellableText(node) ? writableText(node.text) : undefined
diff --git a/src/html/parse/html-to-adf.test.ts b/src/html/parse/html-to-adf.test.ts
index 90ea354..b745e24 100644
--- a/src/html/parse/html-to-adf.test.ts
+++ b/src/html/parse/html-to-adf.test.ts
@@ -187,6 +187,19 @@ test('refuses a carry element holding an inline card a link marks, at any depth
}
})
+test('refuses a carry element holding a shape every writer refuses, at any depth in the node it carries', () => {
+ const shapes = [
+ { message: 'a panel carries no text: this one holds text', node: { text: 'x', type: 'panel' } },
+ { message: 'a rule holds no content: this one holds some', node: { content: [{ type: 'paragraph' }], type: 'rule' } },
+ { message: 'a status node holds neither content nor text: this one holds text', node: { text: 'x', type: 'status' } },
+ ]
+ for (const { message: refusal, node } of shapes) {
+ for (const carried of [node, { content: [node], type: 'futureBlock' }]) {
+ assert.equal(message(htmlToAdf(`${carry('div', carried, '')}\n`)), `a carry element's data-adf holds a node every writer refuses: ${refusal}`)
+ }
+ }
+})
+
test('reads a carry element from its data-adf, what it shows read back as adfToHtml writes it', () => {
assert.deepEqual(read(htmlToAdf(`${carry('div', panel, 'Check the collation.
')}\nAsk ${carry('span', mention, '@Mikael')}
\n`)), document(panel, paragraph(text('Ask '), mention)))
assert.deepEqual(read(htmlToAdf(`${carry('span', text('a\u0085b', { type: 'underline' }), 'ab').replace('\u0085', '\\u0085')}
\n`)), document(paragraph(text('a\u0085b', { type: 'underline' }))))
diff --git a/src/markdown/emit/adf-to-markdown.ts b/src/markdown/emit/adf-to-markdown.ts
index e9af1b5..178c120 100644
--- a/src/markdown/emit/adf-to-markdown.ts
+++ b/src/markdown/emit/adf-to-markdown.ts
@@ -174,8 +174,6 @@ function directivePair(node: AdfNode, opener: string, body: BlockText, headroom:
}
function emitDirectiveBlock(node: AdfNode, model: BlockNodeModel, path: ConvertErrorPath, depth: number, walkBody: () => Result): Result {
- if (node.text !== undefined) return failure('unsupported-node-shape', `a ${node.type} carries no text: this one holds text`, path)
- if (blockDirectiveForm(node.type) === 'leaf' && nodeContent(node).length > 0) return failure('unsupported-node-shape', `a ${node.type} holds no content: this one holds some`, path)
if (model.contentModel === 'code') return emitCodeDirective(node, model, path, depth)
const opener = spellBlockDirectiveOpener(node, model, path)
if (opener === undefined) return carriedFence(carriedBlock(node, path, depth))
diff --git a/src/markdown/emit/inline-line.ts b/src/markdown/emit/inline-line.ts
index a7b3700..dff4b89 100644
--- a/src/markdown/emit/inline-line.ts
+++ b/src/markdown/emit/inline-line.ts
@@ -15,7 +15,7 @@ import { highlightDelimiter } from '../inline-tokens.ts'
import { holdsNullCharacter, trimTrailingSpace } from '../commonmark/grammar.ts'
import { inlineNodeModel, takenMarkTypes } from '../../adf/inline-nodes.ts'
import { inlineRuns } from './inline-runs.ts'
-import { isSpellableText, nodeAttrs, nodeContent, nodeMarks } from '../../adf/document.ts'
+import { isSpellableText, nodeAttrs, nodeMarks } from '../../adf/document.ts'
import { joinsWhenRead, textBreakSpelling } from '../adjacent-text.ts'
import { largestNesting } from '../../nesting.ts'
import { longestBacktickRun } from '../commonmark/backtick-runs.ts'
@@ -143,7 +143,7 @@ function carries(node: AdfNode, carried: ReadonlySet, index: number): bo
const model = inlineNodeModel(node.type)
if (model === undefined) return true
const slot = model.textAttribute === undefined ? undefined : nodeAttrs(node)[model.textAttribute]
- return typeof slot === 'string' && slotFault(node.type, slot) !== undefined && nodeContent(node).length === 0 && node.text === undefined
+ return typeof slot === 'string' && slotFault(node.type, slot) !== undefined
}
export function takeFallback(fallbacks: LineFallbacks, fallback: Fallback, path: ConvertErrorPath): Result {
@@ -225,11 +225,6 @@ function bracketedLinkTarget(target: string): InlineSegment {
return { escaping: 'bracketed-link-target', text: escapeUnbalanced(target, '[', ']') }
}
-function heldContentOrText(node: AdfNode): 'content' | 'text' | undefined {
- if (nodeContent(node).length > 0) return 'content'
- return node.text === undefined ? undefined : 'text'
-}
-
function emitRun(nodes: readonly RunNode[], depth: number, firstIndex: number, context: InlineContext): Result {
if (depth > largestNesting) {
return failure('unsupported-nesting-depth', `the marks nest deeper than the ${largestNesting} levels the emitter carries`, context.path)
@@ -268,8 +263,6 @@ function emitLeaf({ carried, index, node }: PlainRun, context: InlineContext): R
const types = nodeMarks(node).map((mark) => mark.type)
if (new Set(types).size !== types.length) return failure('unsupported-node-shape', `a ${node.type} node carries one mark type twice`, nodePath(context, index))
const model = inlineNodeModel(node.type)
- const held = model === undefined ? undefined : heldContentOrText(node)
- if (held !== undefined) return failure('unsupported-node-shape', `a ${node.type} node holds neither content nor text: this one holds ${held}`, nodePath(context, index))
const segments = model === undefined ? textSegments(node, context) : node.type === 'hardBreak' ? hardBreakSegments(node, model, context) : inlineDirectiveSegments(node, model)
return segments === undefined ? carriedRun({ first: index, last: index }, context) : success({ segments })
}
diff --git a/src/markdown/parse/markdown-to-adf.test.ts b/src/markdown/parse/markdown-to-adf.test.ts
index c70fd6d..965c02c 100644
--- a/src/markdown/parse/markdown-to-adf.test.ts
+++ b/src/markdown/parse/markdown-to-adf.test.ts
@@ -497,6 +497,16 @@ test('refuses a carry holding an inline card a link marks, whether it stands alo
}
})
+test('refuses a carry holding a shape every writer refuses, whether it stands alone, in a block or in a fence', () => {
+ const refused = 'unsupported-node-shape: the opaque carry holds a node every writer refuses: '
+ const refusal = (markdown: string): string => String(content(losslessMarkdownToAdf(markdown))).replace(/; .*$/, '')
+ const status = { text: 'x', type: 'status' }
+ const json = JSON.stringify(status).replaceAll('"', '\\"')
+ assert.equal(refusal(`!adf:carry{json="${json}"}\n`), `${refused}a status node holds neither content nor text: this one holds text`)
+ assert.equal(refusal(`\`\`\`adf:futureBlock\n${JSON.stringify({ content: [status] }, null, 2)}\n\`\`\`\n`), `${refused}a status node holds neither content nor text: this one holds text`)
+ assert.equal(refusal(`\`\`\`adf:panel\n${JSON.stringify({ text: 'x' }, null, 2)}\n\`\`\`\n`), `${refused}a panel carries no text: this one holds text`)
+})
+
test('names the shape the inline carry reads alone', () => {
assert.equal(content(losslessMarkdownToAdf('!adf:carry[x]{json="{}"}\n')), 'unsupported-node-shape: carry takes no content: this one holds some')
assert.equal(content(losslessMarkdownToAdf('!adf:carry{}\n')), 'unsupported-node-shape: carry holds one json attribute alone: this one does not')
