@diplodoc/transform 4.71.0 → 4.72.0

package/lib/typings.d.ts

@@ -110,6 +110,15 @@ export interface MarkdownItPluginOpts {
         enabled: boolean;
         maxFileSize: number;
     };
+    /**
+     * When true, term definitions continue past blank lines until the next
+     * `[*key]:` or end of block. Designed for documents where all term
+     * definitions are placed at the end of the file.
+     *
+     * When false (default), a blank line terminates the definition unless
+     * the next non-blank line is an `{% include %}` directive.
+     */
+    multilineTermDefinitions?: boolean;
 }
 export type MarkdownItPluginCb<T extends {} = {}> = {
     (md: MarkdownIt, opts: T & MarkdownItPluginOpts): void;
@@ -129,4 +138,5 @@ export type CssWhiteList = {
 export type ImageOptions = {
     width: string | undefined | null;
     height: string | undefined | null;
+    title: string | undefined | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diplodoc/transform",
-  "version": "4.71.0",
+  "version": "4.72.0",
   "description": "A simple transformer of text in YFM (Yandex Flavored Markdown) to HTML",
   "keywords": [
     "markdown",
@@ -49,7 +49,7 @@
     "lint": "lint update && lint",
     "lint:fix": "lint update && lint fix",
     "pre-commit": "lint update && lint-staged",
-    "prepare": "husky"
+    "prepare": "husky || exit 0"
   },
   "dependencies": {
     "@diplodoc/cut-extension": "^1.1.1",

package/src/transform/plugins/images/index.ts

@@ -147,6 +147,7 @@ const index: MarkdownItPluginCb<Opts> = (md, opts) => {
                 const imageOpts = {
                     width: image.attrGet('width'),
                     height: image.attrGet('height'),
+                    title: image.attrGet('title'),
                 };
 
                 const from = state.env.path || opts.path;
@@ -225,6 +226,13 @@ function replaceSvgContent(content: string | null, options: ImageOptions) {
         content = content.replace(/.*?<svg([^>]*)>/, `<svg${svgRoot}>`);
     }
 
+    // title
+    const hasTitle = /<title>.*?<\/title>/i.test(content);
+    if (!hasTitle && options.title) {
+        // Insert title tag after the opening svg tag
+        content = content.replace(/(<svg[^>]*>)/, `$1<title>${options.title}</title>`);
+    }
+
     // randomize ids
     content = optimize(content, {
         plugins: [

package/src/transform/plugins/term/termDefinitions.ts

@@ -6,24 +6,38 @@ import {BASIC_TERM_REGEXP} from './constants';
 
 const INCLUDE_LINE_RE = /^{%\s*include\s/;
 const NEW_LINE_RE = /^(\r\n|\r|\n)/;
-const TERM_DEF_RE = /^\[\*(\w+)\]:/;
+const TERM_DEF_RE = /^\[\*([^[\]]+)\]:/;
+
+/**
+ * @param state - markdown-it block state
+ * @param line - line number to read
+ * @returns raw source text of the given line
+ */
+function getNextLineContent(state: StateBlock, line: number): string {
+    const start = state.bMarks[line];
+    const end = state.eMarks[line];
+
+    return start === end ? state.src[start] : state.src.slice(start, end);
+}
 
 /**
  * Checks whether the first non-blank line after {@link fromLine} is an
  * `{% include %}` directive.  Used to allow blank-line gaps between
  * consecutive includes inside a single term definition.
  *
- * @param {StateBlock} state - The markdown-it state block containing parsing information
- * @param {number} fromLine - The line number from which to start searching for include directives
- * @param {number} endLine - The last line number to search within
- * @returns {boolean} Returns true if an include directive is found after blank lines, false otherwise
+ * @param state - markdown-it block state
+ * @param fromLine - line number from which to start searching
+ * @param endLine - last line number to search within
+ * @returns true if the first non-blank line is an include directive
  */
 function hasIncludeAfterBlanks(state: StateBlock, fromLine: number, endLine: number): boolean {
     for (let line = fromLine + 1; line <= endLine; line++) {
         const start = state.bMarks[line];
         const end = state.eMarks[line];
 
-        if (start === end) continue;
+        if (start === end) {
+            continue;
+        }
 
         const content = state.src.slice(start, end);
         return INCLUDE_LINE_RE.test(content.trimStart());
@@ -31,7 +45,51 @@ function hasIncludeAfterBlanks(state: StateBlock, fromLine: number, endLine: num
     return false;
 }
 
+/**
+ * Scans forward from {@link startLine} to find where the current term
+ * definition ends.
+ *
+ * When `multilineTermDefinitions` is enabled, the definition continues
+ * past blank lines and stops only at the next `[*key]:` or end of block.
+ * Otherwise blank lines terminate the definition unless followed by an
+ * `{% include %}` directive (legacy behaviour).
+ *
+ * @param state - markdown-it block state
+ * @param startLine - line where the current definition starts
+ * @param endLine - last line of the block
+ * @param multiline - whether multiline mode is enabled
+ * @returns line number where the definition ends
+ */
+function findDefinitionEnd(
+    state: StateBlock,
+    startLine: number,
+    endLine: number,
+    multiline: boolean,
+): number {
+    let currentLine = startLine;
+
+    for (; currentLine < endLine; currentLine++) {
+        const nextLine = getNextLineContent(state, currentLine + 1);
+
+        if (TERM_DEF_RE.test(nextLine)) {
+            break;
+        }
+
+        if (!multiline && NEW_LINE_RE.test(nextLine)) {
+            if (!hasIncludeAfterBlanks(state, currentLine + 1, endLine)) {
+                break;
+            }
+        }
+
+        state.line = currentLine + 1;
+    }
+
+    return currentLine;
+}
+
 export function termDefinitions(md: MarkdownIt, options: MarkdownItPluginOpts) {
+    const multiline = options.multilineTermDefinitions === true;
+
     return (state: StateBlock, startLine: number, endLine: number, silent: boolean) => {
         let ch;
         let labelEnd;
@@ -63,33 +121,7 @@ export function termDefinitions(md: MarkdownIt, options: MarkdownItPluginOpts) {
             }
         }
 
-        let currentLine = startLine;
-
-        // Allow multiline term definition.
-        // Blank lines normally terminate the definition, but we look ahead
-        // past them: if the next non-blank line is an {% include %} directive,
-        // we keep scanning so that multiple includes can be part of one term.
-        for (; currentLine < endLine; currentLine++) {
-            const nextLineStart = state.bMarks[currentLine + 1];
-            const nextLineEnd = state.eMarks[currentLine + 1];
-
-            const nextLine =
-                nextLineStart === nextLineEnd
-                    ? state.src[nextLineStart]
-                    : state.src.slice(nextLineStart, nextLineEnd);
-
-            if (TERM_DEF_RE.test(nextLine)) {
-                break;
-            }
-
-            if (NEW_LINE_RE.test(nextLine)) {
-                if (!hasIncludeAfterBlanks(state, currentLine + 1, endLine)) {
-                    break;
-                }
-            }
-
-            state.line = currentLine + 1;
-        }
+        const currentLine = findDefinitionEnd(state, startLine, endLine, multiline);
 
         max = state.eMarks[currentLine];
 
@@ -165,6 +197,8 @@ function processTermDefinition(
         state.env.terms[':' + label] = title;
     }
 
+    const fromInclude = Array.isArray(state.env.includes) && state.env.includes.length > 0;
+
     token = new state.Token('dfn_open', 'dfn', 1);
     token.attrSet('class', 'yfm yfm-term_dfn');
     token.attrSet('id', ':' + label + '_element');
@@ -172,6 +206,10 @@ function processTermDefinition(
     token.attrSet('aria-live', 'polite');
     token.attrSet('aria-modal', 'true');
 
+    if (fromInclude) {
+        token.attrSet('from-include', 'true');
+    }
+
     state.tokens.push(token);
 
     const titleTokens = md.parse(title, state.env);

package/src/transform/typings.ts

@@ -144,6 +144,15 @@ export interface MarkdownItPluginOpts {
         enabled: boolean;
         maxFileSize: number;
     };
+    /**
+     * When true, term definitions continue past blank lines until the next
+     * `[*key]:` or end of block. Designed for documents where all term
+     * definitions are placed at the end of the file.
+     *
+     * When false (default), a blank line terminates the definition unless
+     * the next non-blank line is an `{% include %}` directive.
+     */
+    multilineTermDefinitions?: boolean;
 }
 
 export type MarkdownItPluginCb<T extends {} = {}> = {
@@ -174,4 +183,5 @@ export type CssWhiteList = {[property: string]: boolean};
 export type ImageOptions = {
     width: string | undefined | null;
     height: string | undefined | null;
+    title: string | undefined | null;
 };