@putout/printer 1.8.11 → 1.9.1

package/ChangeLog

@@ -1,3 +1,16 @@
+2023.03.28, v1.9.1
+
+feature:
+- 063bb53 @putout/printer: improve support of AST witout parent File
+- d6fd09d @putout/printer: add support of trailingComments
+- a323b20 @putout/printer: shouldAddNewlineAfter
+
+2023.03.27, v1.9.0
+
+feature:
+- cdcea37 @putout/printer: add support of ExportDefaultDeclaration
+- e891b21 @putout/printer: add support of ExportDefaultDeclaration
+
 2023.03.27, v1.8.11
 
 fix:

package/lib/print-tokens/cook.js

@@ -3,9 +3,10 @@
 module.exports.cook = (tokens) => {
     const cookedTokens = [];
     
-    for (const [i, {value}] of tokens.entries()) {
+    for (const {value} of tokens) {
         cookedTokens.push(value);
     }
     
     return cookedTokens;
 };
+

package/lib/printer.js

@@ -5,5 +5,7 @@ const {printTokens} = require('./print-tokens');
 
 module.exports.print = (ast, overrides) => {
     const tokens = tokenize(ast, overrides);
-    return printTokens(tokens);
+    const result = printTokens(tokens);
+    
+    return result;
 };

package/lib/tokenize/comments.js

@@ -3,15 +3,11 @@
 const {isFirst} = require('./is');
 const {markBefore} = require('./mark');
 
-module.exports.parseComments = (path, {print, indent, maybe}) => {
+module.exports.parseLeadingComments = (path, {print, indent}) => {
     const {leadingComments} = path.node;
     
-    if (leadingComments)
-        parseLeadingComments(path, {print, indent, maybe});
-};
-
-function parseLeadingComments(path, {print, indent}) {
-    const {leadingComments} = path.node;
+    if (!leadingComments || !leadingComments.length)
+        return;
     
     if (shouldAddNewlineBefore(path))
         print.linebreak();
@@ -22,6 +18,7 @@ function parseLeadingComments(path, {print, indent}) {
         if (type === 'CommentLine') {
             print(`//${value}`);
             print.newline();
+            
             continue;
         }
         
@@ -36,9 +33,24 @@ function parseLeadingComments(path, {print, indent}) {
             continue;
         }
     }
-}
+};
+
+module.exports.parseTrailingComments = (path, {print}) => {
+    const {trailingComments} = path.node;
+    
+    if (!trailingComments || !trailingComments.length)
+        return;
+    
+    for (const {type, value} of trailingComments) {
+        if (type === 'CommentLine') {
+            print.space();
+            print(`//${value}`);
+            
+            continue;
+        }
+    }
+};
 
 function shouldAddNewlineBefore(path) {
     return path.isStatement() && !isFirst(path);
 }
-

package/lib/tokenize/debug.js

@@ -1,8 +1,15 @@
 'use strict';
 
+const {stringify} = JSON;
+
 const {TYPES} = require('../types');
 const toSnakeCase = require('just-snake-case');
-const {LOG, DEBUG} = process.env;
+const {
+    LOG,
+    LOG_ALL,
+    LOG_TOKENS,
+    DEBUG,
+} = process.env;
 const {codeFrameColumns} = require('@babel/code-frame');
 
 module.exports.createDebug = (tokens) => (a) => {
@@ -15,18 +22,31 @@ module.exports.createDebug = (tokens) => (a) => {
     });
 };
 
-module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => (chunk) => {
-    if (!LOG)
+module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => ({type, value}) => {
+    if (LOG_TOKENS) {
+        console.log(codeFrameColumns(stringify({type, value}), {}, {
+            highlightCode: true,
+        }));
         return;
+    }
     
-    if (chunk === newline) {
-        console.log(codeFrameColumns(store(), {}, {
+    if (LOG_ALL) {
+        console.log(codeFrameColumns(value, {}, {
             highlightCode: true,
         }));
         return;
     }
     
-    store(chunk);
+    if (LOG) {
+        if (value === newline) {
+            console.log(codeFrameColumns(store(), {}, {
+                highlightCode: true,
+            }));
+            return;
+        }
+        
+        store(value);
+    }
 };
 
 function createStore() {

package/lib/tokenize/expressions/call-expression.js

@@ -20,7 +20,7 @@ module.exports.CallExpression = CallExpression;
 function CallExpression(path, {indent, print, maybe}) {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
-    if (isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath)) {
+    if (shouldAddNewlineBefore(path)) {
         print.breakline();
     }
     
@@ -92,3 +92,7 @@ function toLong(path) {
     
     return false;
 }
+
+function shouldAddNewlineBefore(path) {
+    return isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath);
+}

package/lib/tokenize/expressions/class-declaration.js

@@ -1,14 +1,7 @@
 'use strict';
 
 const {entries} = Object;
-
-const isFirst = (path) => path.node === path.parentPath.node.body[0];
-
 module.exports.ClassDeclaration = (path, {maybe, print, indent}) => {
-    if (!isFirst(path)) {
-        print.breakline();
-    }
-    
     indent();
     print('class ');
     print('__id');

package/lib/tokenize/expressions/index.js

@@ -4,13 +4,19 @@ const functions = require('./functions');
 const unaryExpressions = require('./unary-expressions');
 const memberExpressions = require('./member-expressions');
 const {ClassDeclaration} = require('./class-declaration');
+
 const {
     CallExpression,
     OptionalCallExpression,
 } = require('./call-expression');
 
 const {NewExpression} = require('./new-expression');
-const {ObjectExpression} = require('./object-expression');
+
+const {
+    ObjectExpression,
+    ObjectProperty,
+} = require('./object-expression');
+
 const {ObjectPattern} = require('./object-pattern');
 const {AssignmentExpression} = require('./assignment-expression');
 const {ArrayExpression} = require('./array-expression');
@@ -20,10 +26,12 @@ const {RestElement} = require('./rest-element');
 const {SpreadElement} = require('./spread-element');
 const {SequenceExpression} = require('./sequence-expression');
 const {TaggedTemplateExpression} = require('./tagged-template-expression');
+
 const {
     BinaryExpression,
     LogicalExpression,
 } = require('./binary-expression');
+
 const {ConditionalExpression} = require('./conditional-expression');
 
 module.exports = {
@@ -42,6 +50,7 @@ module.exports = {
     LogicalExpression,
     OptionalCallExpression,
     ObjectExpression,
+    ObjectProperty,
     ObjectPattern,
     RestElement,
     SpreadElement,

package/lib/tokenize/expressions/object-expression.js

@@ -3,6 +3,7 @@
 const {isCoupleLines} = require('../is');
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
+
 const isForOf = (path) => {
     if (path.parentPath.isForOfStatement())
         return true;
@@ -20,7 +21,6 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
     
     maybe.print(parens, '(');
     print('{');
-    
     maybe.print(manyLines, '\n');
     
     for (const property of properties) {
@@ -36,8 +36,6 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
             continue;
         }
         
-        const {shorthand, computed} = property.node;
-        
         maybe.indent(manyLines);
         
         if (property.isObjectMethod()) {
@@ -45,25 +43,36 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
             continue;
         }
         
-        maybe.print(computed, '[');
-        print(property.get('key'));
-        maybe.print(computed, ']');
-        
-        if (!shorthand) {
-            print(': ');
-            print(property.get('value'));
-        }
-        
-        maybe.print(manyLines, ',\n');
+        print(property);
+        maybe.print.newline(manyLines);
     }
     
     indent.dec();
-    
     maybe.indent(manyLines);
     print('}');
     maybe.print.newline(path.parentPath.isLogicalExpression());
     maybe.print(parens, ')');
 };
+
+module.exports.ObjectProperty = (path, {print, maybe}) => {
+    const {
+        shorthand,
+        computed,
+    } = path.node;
+    const manyLines = !isOneLine(path.parentPath);
+    
+    maybe.print(computed, '[');
+    print('__key');
+    maybe.print(computed, ']');
+    
+    if (!shorthand) {
+        print(': ');
+        print('__value');
+    }
+    
+    maybe.print(manyLines, ',');
+};
+
 function isOneLine(path) {
     const isCall = path.parentPath.isCallExpression();
     const {length} = path.get('properties');

package/lib/tokenize/is.js

@@ -1,11 +1,15 @@
 'use strict';
 
+const isParentProgram = (path) => path.parentPath?.isProgram();
+const isParentBlock = (path) => path.parentPath.isBlockStatement();
+const isNext = (path) => path.getNextSibling().node;
+
 module.exports.isFirst = (path) => path.node === path.parentPath.node.body[0];
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
-module.exports.isNext = (path) => path.getNextSibling().node;
-module.exports.isProgramParent = (path) => path.parentPath?.isProgram();
-module.exports.isNextParent = (path) => path.parentPath.getNextSibling().node;
-module.exports.isNextBlock = (path) => path.getNextSibling().isBlockStatement();
+module.exports.isNext = isNext;
+module.exports.isParentProgram = isParentProgram;
+module.exports.isParentBlock = isParentBlock;
+module.exports.isLast = (path) => isParentProgram(path) && !isNext(path);
 
 module.exports.isCoupleLines = (path) => {
     const start = path.node?.loc?.start?.line;

package/lib/tokenize/literals/index.js

@@ -4,24 +4,24 @@ const {TemplateLiteral} = require('./template-literal');
 
 module.exports = {
     TemplateLiteral,
-    NumericLiteral(path, {print}) {
+    NumericLiteral(path, {write}) {
         const {
             raw,
             extra,
         } = path.node;
         
-        print(raw || extra.raw);
+        write(raw || extra.raw);
     },
-    BooleanLiteral(path, {print}) {
-        print(path.node.value);
+    BooleanLiteral(path, {write}) {
+        write(path.node.value);
     },
-    StringLiteral(path, {print}) {
+    StringLiteral(path, {write}) {
         const {
             raw,
             value,
         } = path.node;
         
-        print(raw || `'${value}'`);
+        write(raw || `'${value}'`);
     },
     Identifier(path, {write}) {
         write(path.node.name);
@@ -29,7 +29,10 @@ module.exports = {
     RegExpLiteral(path, {print}) {
         print(path.node.raw);
     },
-    NullLiteral(path, {print}) {
-        print('null');
+    NullLiteral(path, {write}) {
+        write('null');
+    },
+    MetaProperty(path, {write}) {
+        write('import.meta');
     },
 };

package/lib/tokenize/mark.js

@@ -5,6 +5,7 @@ const WATER_MARK_AFTER = '__putout_newline_after';
 
 module.exports.markBefore = markBefore;
 module.exports.markAfter = markAfter;
+module.exports.maybeMarkAfter = (a, path) => a && markAfter(path);
 
 function markBefore(path) {
     path[WATER_MARK_BEFORE] = true;

package/lib/tokenize/maybe.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const {
+    isProgram,
+    isFile,
+    File,
+    ExpressionStatement,
+    Program,
+} = require('@babel/types');
+
+const maybeProgram = (ast) => isProgram(ast) ? ast : Program([
+    ExpressionStatement(ast),
+]);
+
+module.exports.maybeFile = (ast) => isFile(ast) ? ast : File(maybeProgram(ast));

package/lib/tokenize/statements/block-statement.js

@@ -2,8 +2,9 @@
 
 const {
     isNext,
-    isProgramParent,
+    isParentProgram,
 } = require('../is');
+
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
 module.exports.BlockStatement = (path, {indent, maybe, print}) => {
@@ -38,7 +39,7 @@ module.exports.BlockStatement = (path, {indent, maybe, print}) => {
 function shouldAddNewlineAfter(path) {
     const {parentPath} = path;
     
-    if (!isNext(path) && !isNext(path.parentPath) && isProgramParent(path.parentPath))
+    if (!isNext(path) && !isNext(path.parentPath) && isParentProgram(path.parentPath))
         return false;
     
     if (parentPath.isStatement() && !path.node.body.length && !isNext(parentPath))

package/lib/tokenize/statements/export-default-declaration.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports.ExportDefaultDeclaration = (path, {print}) => {
+    print('export default ');
+    print('__declaration');
+    print(';');
+};

package/lib/tokenize/statements/expression-statement.js

@@ -2,18 +2,26 @@
 
 const {
     markBefore,
-    markAfter,
     hasPrevNewline,
 } = require('../mark');
 
 const {
     isNext,
-    isProgramParent,
-    isNextParent,
-
+    isParentProgram,
+    isLast,
+    isParentBlock,
 } = require('../is');
 
-module.exports.ExpressionStatement = (path, {indent, print}) => {
+const isNextDifferent = (path) => {
+    const next = path.getNextSibling();
+    
+    if (!next.isExpressionStatement())
+        return true;
+    
+    return next.node.expression.type !== path.node.expression.type;
+};
+
+module.exports.ExpressionStatement = (path, {indent, print, maybe}) => {
     if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewlineBefore(path) && !hasPrevNewline(path)) {
         print.breakline();
         markBefore(path);
@@ -23,23 +31,50 @@ module.exports.ExpressionStatement = (path, {indent, print}) => {
     print('__expression');
     print(';');
     
-    if (isNext(path) || isNextParent(path) || path.parentPath.isBlockStatement() && !isProgramParent(path)) {
+    let wasNewline = false;
+    
+    if (shouldBreakline(path)) {
         print.newline();
+        maybe.indent(isNext(path));
+        
+        wasNewline = true;
     }
     
     if (shouldAddNewLineAfter(path)) {
         print.newline();
-        markAfter(path);
+        maybe.markAfter(wasNewline, path);
     }
 };
 
-function shouldAddNewLineAfter(path) {
-    if (!isNext(path))
+function shouldBreakline(path) {
+    if (isLast(path) || isLast(path.parentPath))
+        return false;
+    
+    if (!isNext(path) && isParentBlock(path))
         return false;
     
+    if (path.parentPath.get('body') === path)
+        return true;
+    
     if (isStrictMode(path) || isCoupleLinesExpression(path))
         return true;
     
+    if (isNext(path) && isNextDifferent(path) && path.parentPath.node.body?.length > 2)
+        return true;
+    
+    return false;
+}
+
+function shouldAddNewLineAfter(path) {
+    if (isLast(path))
+        return false;
+    
+    if (isParentBlock(path) && !isParentProgram(path))
+        return true;
+    
+    if (isNext(path))
+        return true;
+    
     return false;
 }
 

package/lib/tokenize/statements/if-statement.js

@@ -4,9 +4,8 @@ const {hasPrevNewline, markAfter} = require('../mark');
 const {isFirst} = require('../is');
 
 module.exports.IfStatement = (path, {indent, print}) => {
-    if (!isFirst(path) && !hasPrevNewline(path)) {
-        print.indent();
-        print.newline();
+    if (shouldAddNewlineBefore(path)) {
+        print.linebreak();
     }
     
     indent();
@@ -31,6 +30,7 @@ module.exports.IfStatement = (path, {indent, print}) => {
         print(' else ');
         print(alternate);
     } else if (alternate.node) {
+        print.breakline();
         print('else');
         print.newline();
         indent.inc();
@@ -48,3 +48,6 @@ module.exports.IfStatement = (path, {indent, print}) => {
     markAfter(path);
 };
 
+function shouldAddNewlineBefore(path) {
+    return !isFirst(path) && !hasPrevNewline(path);
+}

package/lib/tokenize/statements/import-declarations.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {markAfter} = require('../mark');
 const {entries} = Object;
 
 module.exports.ImportDeclaration = (path, {print, maybe}) => {
@@ -13,7 +14,7 @@ module.exports.ImportDeclaration = (path, {print, maybe}) => {
         }
         
         if (spec.isImportSpecifier()) {
-            maybe.print(index, ', ');
+            maybe.print(Number(index), ', ');
             print('{');
             print(spec.get('imported'));
             print('}');
@@ -27,5 +28,16 @@ module.exports.ImportDeclaration = (path, {print, maybe}) => {
     print('__source');
     print(';');
     print.newline();
+    
+    if (shouldAddNewlineAfter(path)) {
+        print.newline();
+        markAfter(path);
+    }
 };
 
+function shouldAddNewlineAfter(path) {
+    if (path.getNextSibling().isImportDeclaration())
+        return false;
+    
+    return true;
+}

package/lib/tokenize/statements/index.js

@@ -14,12 +14,14 @@ const exportDeclarations = require('./export-declarations');
 const {WhileStatement} = require('./while-statement');
 const {SwitchStatement} = require('./switch-statement');
 const {ForInStatement} = require('./for-in-statement');
+const {ExportDefaultDeclaration} = require('./export-default-declaration');
 
 module.exports = {
     ...importDeclarations,
     ...exportDeclarations,
     BlockStatement,
     ExpressionStatement,
+    ExportDefaultDeclaration,
     VariableDeclaration,
     IfStatement,
     ForStatement,

package/lib/tokenize/statements/variable-declaration.js

@@ -3,9 +3,8 @@
 const {
     isNext,
     isCoupleLines,
-    isNextBlock,
-
 } = require('../is');
+
 const {
     hasPrevNewline,
     markAfter,
@@ -26,6 +25,7 @@ module.exports.VariableDeclaration = (path, {maybe, print}) => {
     maybe.print(initPath.node, ' = ');
     print(initPath);
     maybe.print(isParentBlock(path), ';');
+    
     let wasNewline = false;
     
     if (isParentBlock(path) && isNext(path)) {
@@ -44,9 +44,6 @@ function shouldAddNewlineAfter(path) {
     if (!isNext(path) && path.parentPath.isBlockStatement())
         return true;
     
-    if (isNextBlock(path))
-        return false;
-    
     if (isLast(path))
         return false;
     
@@ -61,7 +58,6 @@ function shouldAddNewlineAfter(path) {
     
     return false;
 }
-
 const isLast = (path) => path.parentPath.isProgram() && !isNext(path);
 
 function shouldAddNewlineBefore(path) {
@@ -81,15 +77,6 @@ function shouldAddNewlineBefore(path) {
     
     if (isCoupleLines(path))
         return true;
-    
-    const nextPath = path.getNextSibling();
-    const nextNextPath = nextPath.getNextSibling();
-    const twoNext = nextPath.node && nextNextPath.node;
-    
-    if (!twoNext)
-        return false;
-    
-    return true;
 }
 
 function isFirst(path) {
@@ -103,4 +90,3 @@ const isNextAssign = (path) => {
     
     return nextPath.get('expression').isAssignmentExpression();
 };
-

package/lib/tokenize/statements/while-statement.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const {isLast} = require('../is');
+
 module.exports.WhileStatement = (path, {print, indent}) => {
     print('while (');
     print('__test');
@@ -15,5 +17,14 @@ module.exports.WhileStatement = (path, {print, indent}) => {
         indent.dec();
     }
     
-    print.linebreak();
+    if (shouldAddNewlineAfter(path)) {
+        print.linebreak();
+    }
 };
+
+function shouldAddNewlineAfter(path) {
+    if (isLast(path))
+        return false;
+    
+    return true;
+}

package/lib/tokenize/tokenize.js

@@ -6,14 +6,23 @@ const expressions = require('./expressions');
 const statements = require('./statements');
 const literals = require('./literals');
 const {TYPES} = require('../types');
-const {createDebug, createLog} = require('./debug');
+const {maybeFile} = require('./maybe');
+
+const {
+    createDebug,
+    createLog,
+} = require('./debug');
 
 const {
     maybeMarkAfter,
     maybeMarkBefore,
 } = require('./mark');
 
-const {parseComments} = require('./comments');
+const {
+    parseLeadingComments,
+    parseTrailingComments,
+} = require('./comments');
+
 const isString = (a) => typeof a === 'string';
 const {assign} = Object;
 
@@ -32,13 +41,11 @@ function initFormat(format) {
         indent: '    ',
     };
 }
-
 const createAddToken = (tokens) => {
     const log = createLog();
+    
     return (token) => {
-        const {value} = token;
-        
-        log(value);
+        log(token);
         tokens.push(token);
     };
 };
@@ -137,7 +144,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
         ...overrides.visitors,
     };
     
-    babelTraverse(ast, {
+    babelTraverse(maybeFile(ast), {
         Program(path) {
             traverse(path);
             path.stop();
@@ -179,8 +186,9 @@ module.exports.tokenize = (ast, overrides = {}) => {
         if (!currentTraverse)
             throw Error(`Node type '${type}' is not supported yet: '${path}'`);
         
-        parseComments(path, printer);
+        parseLeadingComments(path, printer);
         currentTraverse(path, printer);
+        parseTrailingComments(path, printer);
         debug(path.type);
     }
     
@@ -212,4 +220,3 @@ const createPrint = (path, {traverse, write}) => (maybeLine) => {
     
     return write(maybeLine);
 };
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.8.11",
+  "version": "1.9.1",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",
@@ -49,7 +49,6 @@
     "eslint-plugin-putout": "^17.0.0",
     "estree-to-babel": "^5.0.1",
     "just-kebab-case": "^4.2.0",
-    "lerna": "^6.0.1",
     "madrun": "^9.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.0.0",

package/rules/putout-plugin-apply-computed-print/index.js

@@ -1,11 +1,21 @@
 'use strict';
 
+const {assign} = Object;
+
 module.exports.report = () => `Use print('__path') instead of path.get(__path)`;
 
 module.exports.replace = () => ({
     'print(path.get(__a))': ({__a}) => {
-        __a.value = '__' + __a.value;
+        const {
+            raw,
+            value,
+        } = __a;
+        
+        assign(__a, {
+            value: `__${value}`,
+            raw: raw.replace(value, `__${value}`),
+        });
+        
         return 'print(__a)';
     },
 });
-