@diplodoc/transform 4.65.3 → 4.66.0

package/src/transform/plugins/checkbox/checkbox.ts

@@ -15,12 +15,20 @@ export const CheckboxTokenType = {
     CheckboxLabelClose: 'checkbox_label_close',
 } as const;
 
+type ParsedCheckbox = {
+    tokens: Token[];
+    startLine: number;
+    endLine: number;
+    checked: boolean;
+};
+
 function matchOpenToken(tokens: Token[], i: number) {
-    return (
-        tokens[i].type === 'paragraph_open' &&
-        tokens[i + 1].type === 'inline' &&
-        tokens[i + 1].content.match(pattern)
-    );
+    if (tokens[i].type !== 'paragraph_open' || tokens[i + 1].type !== 'inline') {
+        return false;
+    }
+
+    const firstInline = tokens[i + 1].children?.[0];
+    return firstInline?.type === 'text' && pattern.test(firstInline.content);
 }
 
 export type CheckboxOptions = {
@@ -39,16 +47,16 @@ export const checkboxReplace = function (_md: MarkdownIt, opts?: CheckboxOptions
     };
     const options = Object.assign(defaults, opts);
 
-    const createTokens = function (state: StateCore, checked: boolean, label: string, i: number) {
+    const createTokens = function (state: StateCore, checkbox: ParsedCheckbox): Token[] {
         let token: Token;
-        const nodes = [];
+        const nodes: Token[] = [];
 
         /**
          * <div class="checkbox">
          */
         token = new state.Token(CheckboxTokenType.CheckboxOpen, 'div', 1);
         token.block = true;
-        token.map = state.tokens[i].map;
+        token.map = [checkbox.startLine, checkbox.endLine];
         token.attrs = [['class', options.divClass]];
         nodes.push(token);
 
@@ -59,7 +67,7 @@ export const checkboxReplace = function (_md: MarkdownIt, opts?: CheckboxOptions
         lastId += 1;
         token = new state.Token(CheckboxTokenType.CheckboxInput, 'input', 0);
         token.block = true;
-        token.map = state.tokens[i].map;
+        token.map = [checkbox.startLine, checkbox.endLine];
         token.attrs = [
             ['type', 'checkbox'],
             ['id', id],
@@ -67,7 +75,7 @@ export const checkboxReplace = function (_md: MarkdownIt, opts?: CheckboxOptions
         if (options.disabled) {
             token.attrSet('disabled', '');
         }
-        if (checked === true) {
+        if (checkbox.checked === true) {
             token.attrSet('checked', 'true');
         }
         nodes.push(token);
@@ -82,41 +90,111 @@ export const checkboxReplace = function (_md: MarkdownIt, opts?: CheckboxOptions
         /**
          * content of label tag
          */
-        token = state.md.parseInline(label, state.env)[0];
-        nodes.push(token);
+        nodes.push(...checkbox.tokens);
 
         /**
          * closing tags
          */
         token = new state.Token(CheckboxTokenType.CheckboxLabelClose, 'label', -1);
         token.block = true;
-        token.map = state.tokens[i].map;
+        token.map = [checkbox.startLine, checkbox.endLine];
         nodes.push(token);
         token = new state.Token(CheckboxTokenType.CheckboxClose, 'div', -1);
         token.block = true;
-        token.map = state.tokens[i].map;
+        token.map = [checkbox.startLine, checkbox.endLine];
         nodes.push(token);
 
         return nodes;
     };
-    const splitTextToken = function (state: StateCore, matches: RegExpMatchArray, i: number) {
-        let checked = false;
-        const value = matches[1];
-        const label = matches[2];
-        if (value === 'X' || value === 'x') {
-            checked = true;
-        }
-        return createTokens(state, checked, label, i);
-    };
     return function (state) {
         const blockTokens = state.tokens;
         for (let i = 0; i < blockTokens.length; i++) {
-            const match = matchOpenToken(blockTokens, i);
-            if (!match) {
+            if (!matchOpenToken(blockTokens, i)) {
                 continue;
             }
 
-            blockTokens.splice(i, 3, ...splitTextToken(state, match, i));
+            const pToken = blockTokens[i];
+            const startLine = pToken.map?.[0] ?? NaN;
+
+            const checkboxes = parseInlineContent(blockTokens[i + 1], startLine);
+
+            const checkboxTokens: Token[] = [];
+            for (const checkbox of checkboxes) {
+                const first = checkbox.tokens[0];
+                // remove checkbox markup [X]␣ at start of text content
+                first.content = first.content.slice(4);
+                checkboxTokens.push(...createTokens(state, checkbox));
+            }
+
+            // replace paragraph tokens with checkbox tokens
+            if (checkboxTokens.length > 0) {
+                blockTokens.splice(i, 3, ...checkboxTokens);
+                i += checkboxTokens.length - 1;
+            }
         }
     };
 };
+
+function parseInlineContent(inlineToken: Token, startLine: number): ParsedCheckbox[] {
+    const children = inlineToken.children || [];
+    const lines = splitInlineTokensByBreaks(children);
+    return parseCheckboxesByLines(lines, startLine);
+}
+
+function splitInlineTokensByBreaks(tokens: Token[]): Token[][] {
+    const lines: Token[][] = [];
+    let lineIdx = 0;
+    for (const token of tokens) {
+        lines[lineIdx] ||= [];
+        lines[lineIdx].push(token);
+
+        if (isBreakToken(token)) {
+            lineIdx += 1;
+        }
+    }
+
+    return lines;
+}
+
+function parseCheckboxesByLines(lines: Token[][], startLine: number): ParsedCheckbox[] {
+    const checkboxes: ParsedCheckbox[] = [];
+
+    let checkboxIdx = -1;
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        const first = line?.[0];
+        if (!first) {
+            continue;
+        }
+
+        let match;
+        if (first.type === 'text' && (match = first.content.match(pattern))) {
+            const prevLastToken = checkboxes[checkboxIdx]?.tokens.at(-1);
+            if (prevLastToken && isBreakToken(prevLastToken)) {
+                // remove hanging line breaks
+                checkboxes[checkboxIdx].tokens.splice(-1);
+            }
+
+            checkboxIdx += 1;
+            checkboxes[checkboxIdx] ||= {
+                tokens: [],
+                checked: isChecked(match[1]),
+                startLine: startLine + lineIdx,
+                endLine: startLine + lineIdx + 1,
+            };
+        }
+
+        checkboxes[checkboxIdx].tokens.push(...line);
+        checkboxes[checkboxIdx].endLine = startLine + lineIdx + 1;
+    }
+
+    return checkboxes;
+}
+
+function isChecked(value: string): boolean {
+    return value === 'X' || value === 'x';
+}
+
+function isBreakToken(token: Token): boolean {
+    return token.type === 'softbreak' || token.type === 'hardbreak';
+}