@diplodoc/transform 4.17.1 → 4.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diplodoc/transform",
-  "version": "4.17.1",
+  "version": "4.18.0",
   "description": "A simple transformer of text in YFM (Yandex Flavored Markdown) to HTML",
   "keywords": [
     "markdown",

package/src/scss/_anchor.scss

@@ -13,11 +13,11 @@
 
         .yfm-anchor::before {
             content: '#';
-            visibility: hidden;
+            opacity: 0;
         }
 
         &:hover .yfm-anchor::before {
-            visibility: visible;
+            opacity: 1;
         }
     }
 

package/src/scss/print/cut.scss

@@ -11,6 +11,7 @@
 
             &-content {
                 height: auto;
+                display: block;
                 padding: 5px 0 15px 30px;
             }
         }

package/src/scss/print/tabs.scss

@@ -5,6 +5,12 @@
                 display: none;
             }
 
+            &-panel {
+                visibility: visible;
+                height: auto;
+                display: block;
+            }
+
             &-panel:before {
                 content: attr(data-title);
                 margin-bottom: -1px;

package/src/scss/print/term.scss

@@ -0,0 +1,10 @@
+@media print {
+    .yfm {
+        .yfm-term {
+            &_title {
+                color: currentColor;
+                border-bottom: none;
+            }
+        }
+    }
+}

package/src/scss/print.scss

@@ -3,4 +3,5 @@
 @import 'print/cut';
 @import 'print/note';
 @import 'print/table';
-@import 'print/tabs';
+@import 'print/tabs';
+@import 'print/term';

package/src/transform/liquid/conditions.ts

@@ -225,7 +225,7 @@ export = function conditions(
 
     // Consumes all between curly braces
     // and all closest upon to first linebreak before and after braces.
-    const R_LIQUID = /((?:\n\s*)?{%-?([\s\S]*?)-?%}(?:\s*\n)?)/g;
+    const R_LIQUID = /((?:\n[\t ]*)?{%-?([\s\S]*?)-?%}(?:[\t ]*\n)?)/g;
 
     let match;
     while ((match = R_LIQUID.exec(input)) !== null) {

package/src/transform/liquid/index.ts

@@ -124,7 +124,10 @@ function liquid<
         output = applySubstitutions(output, vars, path);
     }
 
-    output = conditionsInCode ? output : repairCode(output, codes);
+    if (!conditionsInCode && typeof output === 'string') {
+        output = repairCode(output, codes);
+    }
+
     codes.length = 0;
 
     if (withSourceMap) {

package/src/transform/liquid/lexical.ts

@@ -6,6 +6,7 @@ const quoted = new RegExp(`${singleQuoted.source}|${doubleQuoted.source}`);
 export const quoteBalanced = new RegExp(`(?:${quoted.source}|[^'"])*`);
 
 export const vars = /((not_var)?({{2}([. \w-|(),]+)}{2}))/gm;
+export const singleVariable = /^{{2}([. \w-|(),]+)}{2}$/;
 
 // basic types
 const number = /-?\d+\.?\d*|\.?\d+/;
@@ -66,6 +67,7 @@ export const getParsedMethod = (exp: String) => {
 
 export const isLiteral = (str: string) => literalLine.test(str);
 export const isVariable = (str: string) => variableLine.test(str);
+export const isSingleVariable = (str: string) => singleVariable.test(str);
 
 export function parseLiteral(str: string) {
     let res = str.match(numberLine);

package/src/transform/liquid/substitutions.ts

@@ -4,11 +4,35 @@ import ArgvService from './services/argv';
 import getObject from '../getObject';
 import {evalExp} from './evaluation';
 import {log} from '../log';
-import {isVariable, vars as varsRe} from './lexical';
+import {
+    isSingleVariable,
+    isVariable,
+    singleVariable as singleVariableRe,
+    vars as varsRe,
+} from './lexical';
 
 const substitutions = (str: string, builtVars: Record<string, unknown>, path?: string) => {
     const {keepNotVar} = ArgvService.getConfig();
 
+    if (isSingleVariable(str)) {
+        const match = str.match(singleVariableRe);
+
+        if (!match) {
+            return str;
+        }
+
+        const trimVarPath = match[1].trim();
+        const value = substituteVariable(trimVarPath, builtVars);
+
+        if (value === undefined) {
+            logNotFoundVariable(trimVarPath, path);
+
+            return str;
+        }
+
+        return value;
+    }
+
     return str.replace(varsRe, (match, _groupNotVar, flag, groupVar, groupVarValue) => {
         if (flag) {
             return keepNotVar ? _groupNotVar : groupVar;
@@ -20,21 +44,31 @@ const substitutions = (str: string, builtVars: Record<string, unknown>, path?: s
             return groupVar;
         }
 
-        let value;
-        if (isVariable(trimVarPath)) {
-            value = getObject(trimVarPath, builtVars);
-        } else {
-            value = evalExp(trimVarPath, builtVars);
-        }
+        const value = substituteVariable(trimVarPath, builtVars);
 
         if (value === undefined) {
-            value = match;
+            logNotFoundVariable(trimVarPath, path);
 
-            log.warn(`Variable ${bold(trimVarPath)} not found${path ? ` in ${bold(path)}` : ''}`);
+            return match;
         }
 
         return value;
     });
 };
 
+function logNotFoundVariable(varPath: string, path?: string) {
+    log.warn(`Variable ${bold(varPath)} not found${path ? ` in ${bold(path)}` : ''}`);
+}
+
+function substituteVariable(varPath: string, builtVars: Record<string, unknown>) {
+    let value;
+    if (isVariable(varPath)) {
+        value = getObject(varPath, builtVars);
+    } else {
+        value = evalExp(varPath, builtVars);
+    }
+
+    return value;
+}
+
 export = substitutions;