@diplodoc/transform 4.17.2 → 4.18.0

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/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;