@putout/printer 1.9.1 → 1.11.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2023.03.29, v1.11.0
+
+feature:
+- a2250dd @putout/printer: add newline at eof
+- c1fb26f @putout/printer: use '__array.entries()' instead of 'entries(__array)'
+
+2023.03.28, v1.10.0
+
+feature:
+- c2f1d12 @putout/printer: add new pluginObject type of plugin
+
 2023.03.28, v1.9.1
 
 feature:

package/README.md

@@ -60,7 +60,7 @@ print(ast, {
 });
 
 // returns
-'const {a /* [hello world] */= 5} = b;';
+'const {a /* [hello world] */= 5} = b;\n';
 ```
 
 ## License

package/lib/print-tokens/cook.js

@@ -9,4 +9,3 @@ module.exports.cook = (tokens) => {
     
     return cookedTokens;
 };
-

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

@@ -5,61 +5,59 @@ const {
     hasPrevNewline,
 } = require('../mark');
 
-module.exports.OptionalCallExpression = (path, {indent, print, maybe}) => {
-    return CallExpression(path, {
-        indent,
-        print,
-        maybe,
-    });
-};
-
 const {entries} = Object;
 
-module.exports.CallExpression = CallExpression;
-
-function CallExpression(path, {indent, print, maybe}) {
-    const isParentCall = toLong(path) && path.parentPath.isCallExpression();
-    
-    if (shouldAddNewlineBefore(path)) {
+const CallExpression = {
+    beforeIf(path) {
+        return isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath);
+    },
+    before(path, {print}) {
         print.breakline();
-    }
-    
-    print('__callee');
-    
-    if (path.node.optional)
-        print('?.');
-    
-    print('(');
-    
-    const args = path.get('arguments');
-    const n = args.length - 1;
-    
-    maybe.indent.inc(isParentCall);
-    
-    for (const [i, arg] of entries(args)) {
-        if (isParentCall) {
-            print.newline();
-            indent();
-        }
+    },
+    print(path, {indent, print, maybe}) {
+        const isParentCall = toLong(path) && path.parentPath.isCallExpression();
+        
+        print('__callee');
         
-        print(arg);
+        if (path.node.optional)
+            print('?.');
+        
+        print('(');
+        
+        const args = path.get('arguments');
+        const n = args.length - 1;
+        
+        maybe.indent.inc(isParentCall);
+        
+        for (const [i, arg] of entries(args)) {
+            if (isParentCall) {
+                print.newline();
+                indent();
+            }
+            
+            print(arg);
+            
+            if (isParentCall) {
+                print(',');
+                continue;
+            }
+            
+            maybe.print(i < n, ', ');
+        }
         
         if (isParentCall) {
-            print(',');
-            continue;
+            indent.dec();
+            print.newline();
+            print.indent();
         }
         
-        maybe.print(i < n, ', ');
-    }
-    
-    if (isParentCall) {
-        indent.dec();
-        print.newline();
-        print.indent();
-    }
-    
-    print(')');
-}
+        print(')');
+    },
+};
+
+module.exports.OptionalCallExpression = CallExpression;
+
+module.exports.CallExpression = CallExpression;
 
 function isNewLineBefore({parentPath}) {
     if (!parentPath.isExpressionStatement())
@@ -92,7 +90,3 @@ function toLong(path) {
     
     return false;
 }
-
-function shouldAddNewlineBefore(path) {
-    return isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath);
-}

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

@@ -1,7 +1,5 @@
 'use strict';
 
-const {entries} = Object;
-
 module.exports.NewExpression = (path, {indent, print, maybe}) => {
     indent();
     print('new ');
@@ -12,7 +10,7 @@ module.exports.NewExpression = (path, {indent, print, maybe}) => {
     
     const n = args.length - 1;
     
-    for (const [i, arg] of entries(args)) {
+    for (const [i, arg] of args.entries()) {
         print(arg);
         maybe.print(i < n, ', ');
     }

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

@@ -1,6 +1,5 @@
 'use strict';
 
-const {entries} = Object;
 const isForOf = (path) => path.parentPath?.parentPath?.parentPath?.isForOfStatement();
 
 module.exports.ObjectPattern = (path, {indent, print, maybe}) => {
@@ -13,7 +12,7 @@ module.exports.ObjectPattern = (path, {indent, print, maybe}) => {
     const is = !isForOf(path) && !path.parentPath.isFunction() && n && checkLength(properties);
     maybe.print(is, '\n');
     
-    for (const [i, property] of entries(properties)) {
+    for (const [i, property] of properties.entries()) {
         if (property.isRestElement()) {
             print(property);
             continue;

package/lib/tokenize/is.js

@@ -3,17 +3,27 @@
 const isParentProgram = (path) => path.parentPath?.isProgram();
 const isParentBlock = (path) => path.parentPath.isBlockStatement();
 const isNext = (path) => path.getNextSibling().node;
+const isNextParent = (path) => path.parentPath.getNextSibling().node;
+const isLast = (path) => isParentProgram(path) && !isNext(path);
 
 module.exports.isFirst = (path) => path.node === path.parentPath.node.body[0];
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 module.exports.isNext = isNext;
+module.exports.isNextParent = isNextParent;
 module.exports.isParentProgram = isParentProgram;
 module.exports.isParentBlock = isParentBlock;
-module.exports.isLast = (path) => isParentProgram(path) && !isNext(path);
+module.exports.isLast = isLast;
+module.exports.isParentLast = (path) => isLast(path.parentPath);
+module.exports.isCoupleLines = isCoupleLines;
+module.exports.isNextCoupleLines = isNextCoupleLines;
 
-module.exports.isCoupleLines = (path) => {
+function isCoupleLines(path) {
     const start = path.node?.loc?.start?.line;
     const end = path.node?.loc?.end?.line;
     
     return end > start;
-};
+}
+
+function isNextCoupleLines(path) {
+    return isCoupleLines(path.getNextSibling());
+}

package/lib/tokenize/maybe.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const isFn = (a) => typeof a === 'function';
+
 const {
     isProgram,
     isFile,
@@ -13,3 +15,31 @@ const maybeProgram = (ast) => isProgram(ast) ? ast : Program([
 ]);
 
 module.exports.maybeFile = (ast) => isFile(ast) ? ast : File(maybeProgram(ast));
+
+module.exports.maybePlugin = (plugin, path, printer) => {
+    if (isFn(plugin))
+        return plugin(path, printer);
+    
+    return objectPlugin(plugin, path, printer);
+};
+
+function objectPlugin(plugin, path, printer) {
+    const {
+        print,
+        split,
+        before = split,
+        beforeIf,
+        after = split,
+        afterIf,
+    } = plugin;
+    
+    if (beforeIf?.(path, printer)) {
+        before(path, printer);
+    }
+    
+    print(path, printer);
+    
+    if (afterIf?.(path, printer)) {
+        after(path, printer);
+    }
+}

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

@@ -3,37 +3,43 @@
 const {
     isNext,
     isParentProgram,
+    isLast,
+
 } = require('../is');
 
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
-module.exports.BlockStatement = (path, {indent, maybe, print}) => {
-    const body = path.get('body');
-    
-    if (path.parentPath.isBlockStatement())
-        indent();
-    
-    indent.inc();
-    print('{');
-    
-    if (body.length > 1 || isFirstStatement(path))
+module.exports.BlockStatement = {
+    print(path, {indent, maybe, print}) {
+        const body = path.get('body');
+        
+        if (path.parentPath.isBlockStatement())
+            indent();
+        
+        indent.inc();
+        print('{');
+        
+        if (body.length > 1 || isFirstStatement(path))
+            print.newline();
+        
+        for (const element of body) {
+            print(element);
+        }
+        
+        indent.dec();
+        maybe.indent(body.length);
+        print('}');
+        
+        if (path.parentPath.isObjectMethod()) {
+            print(',');
+        }
+    },
+    afterIf(path) {
+        return shouldAddNewlineAfter(path);
+    },
+    after(path, {print}) {
         print.newline();
-    
-    for (const element of body) {
-        print(element);
-    }
-    
-    indent.dec();
-    maybe.indent(body.length);
-    print('}');
-    
-    if (path.parentPath.isObjectMethod()) {
-        print(',');
-    }
-    
-    if (shouldAddNewlineAfter(path)) {
-        print.newline();
-    }
+    },
 };
 
 function shouldAddNewlineAfter(path) {
@@ -48,6 +54,9 @@ function shouldAddNewlineAfter(path) {
     if (isTry(path) || /FunctionExpression/.test(path.parentPath.type))
         return false;
     
+    if (isLast(path))
+        return false;
+    
     return true;
 }
 

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

@@ -0,0 +1,23 @@
+'use strict';
+
+const {
+    isNext,
+    isParentBlock,
+    isNextParent,
+} = require('../is');
+
+module.exports.BreakStatement = {
+    split(path, {print}) {
+        print.newline();
+    },
+    print(path, {print, indent}) {
+        indent();
+        print('break;');
+    },
+    afterIf(path) {
+        if (!isNext(path) && !isParentBlock(path) && !isNextParent(path))
+            return false;
+        
+        return true;
+    },
+};

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

@@ -1,15 +1,13 @@
 'use strict';
 
-const {
-    markBefore,
-    hasPrevNewline,
-} = require('../mark');
-
 const {
     isNext,
     isParentProgram,
     isLast,
     isParentBlock,
+    isCoupleLines,
+    isNextCoupleLines,
+    isParentLast,
 } = require('../is');
 
 const isNextDifferent = (path) => {
@@ -21,33 +19,29 @@ const isNextDifferent = (path) => {
     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);
-    }
-    
-    indent();
-    print('__expression');
-    print(';');
-    
-    let wasNewline = false;
-    
-    if (shouldBreakline(path)) {
-        print.newline();
-        maybe.indent(isNext(path));
+module.exports.ExpressionStatement = {
+    print(path, {indent, print, maybe, store}) {
+        indent();
+        print('__expression');
+        print(';');
         
-        wasNewline = true;
-    }
-    
-    if (shouldAddNewLineAfter(path)) {
+        if (shouldBreakline(path)) {
+            print.newline();
+            maybe.indent(isNext(path));
+            store(true);
+        }
+    },
+    afterIf(path) {
+        return shouldAddNewLineAfter(path);
+    },
+    after(path, {print, maybe, store}) {
         print.newline();
-        maybe.markAfter(wasNewline, path);
-    }
+        maybe.markAfter(store(), path);
+    },
 };
 
 function shouldBreakline(path) {
-    if (isLast(path) || isLast(path.parentPath))
+    if (isLast(path) || isParentLast(path))
         return false;
     
     if (!isNext(path) && isParentBlock(path))
@@ -56,17 +50,20 @@ function shouldBreakline(path) {
     if (path.parentPath.get('body') === path)
         return true;
     
-    if (isStrictMode(path) || isCoupleLinesExpression(path))
+    if (isStrictMode(path))
         return true;
     
     if (isNext(path) && isNextDifferent(path) && path.parentPath.node.body?.length > 2)
         return true;
     
+    if (isCoupleLines(path) || isNextCoupleLines(path))
+        return true;
+    
     return false;
 }
 
 function shouldAddNewLineAfter(path) {
-    if (isLast(path))
+    if (isLast(path) || isParentLast(path))
         return false;
     
     if (isParentBlock(path) && !isParentProgram(path))
@@ -78,13 +75,6 @@ function shouldAddNewLineAfter(path) {
     return false;
 }
 
-function isCoupleLinesExpression(path) {
-    const start = path.node.loc?.start?.line;
-    const end = path.node.loc?.end?.line;
-    
-    return end > start;
-}
-
 function isStrictMode(path) {
     const expressionPath = path.get('expression');
     
@@ -95,22 +85,3 @@ function isStrictMode(path) {
     
     return value === 'use strict';
 }
-
-function isFirst(path) {
-    return path.node === path.parentPath.node.body[0];
-}
-
-function shouldAddNewlineBefore(path) {
-    const prev = path.getPrevSibling();
-    
-    if (prev.isVariableDeclaration())
-        return false;
-    
-    if (prev.isIfStatement())
-        return false;
-    
-    if (isStrictMode(prev))
-        return false;
-    
-    return true;
-}

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

@@ -1,36 +1,42 @@
 'use strict';
 
-module.exports.ForStatement = (path, {print, maybe, indent}) => {
-    const {
-        test,
-        update,
-        body,
-    } = path.node;
-    
-    print('for (');
-    print('__init');
-    print(';');
-    maybe.print(test, ' ');
-    print('__test');
-    print(';');
-    maybe.print(update, ' ');
-    print('__update');
-    print(')');
-    
-    if (body.body) {
-        print(' ');
-        print('__body');
-        print.newline();
+const {isLast} = require('../is');
+
+module.exports.ForStatement = {
+    print(path, {print, maybe, indent}) {
+        const {
+            test,
+            update,
+            body,
+        } = path.node;
         
-        return;
-    }
-    
-    if (!body.body) {
-        print.newline();
-        indent.inc();
-        print('__body');
-        indent.dec();
+        print('for (');
+        print('__init');
+        print(';');
+        maybe.print(test, ' ');
+        print('__test');
+        print(';');
+        maybe.print(update, ' ');
+        print('__update');
+        print(')');
+        
+        if (body.body) {
+            print(' ');
+            print('__body');
+        } else {
+            print.newline();
+            indent.inc();
+            print('__body');
+            indent.dec();
+        }
+    },
+    after(path, {print}) {
         print.newline();
-    }
+    },
+    afterIf(path) {
+        if (isLast(path))
+            return false;
+        
+        return true;
+    },
 };
-

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

@@ -1,20 +1,19 @@
 'use strict';
 
 const {markAfter} = require('../mark');
-const {entries} = Object;
 
 module.exports.ImportDeclaration = (path, {print, maybe}) => {
     const specifiers = path.get('specifiers');
     print('import ');
     
-    for (const [index, spec] of entries(specifiers)) {
+    for (const [index, spec] of specifiers.entries()) {
         if (spec.isImportDefaultSpecifier()) {
             print(spec.get('local'));
             continue;
         }
         
         if (spec.isImportSpecifier()) {
-            maybe.print(Number(index), ', ');
+            maybe.print(index, ', ');
             print('{');
             print(spec.get('imported'));
             print('}');

package/lib/tokenize/statements/index.js

@@ -15,6 +15,7 @@ const {WhileStatement} = require('./while-statement');
 const {SwitchStatement} = require('./switch-statement');
 const {ForInStatement} = require('./for-in-statement');
 const {ExportDefaultDeclaration} = require('./export-default-declaration');
+const {BreakStatement} = require('./break-statement');
 
 module.exports = {
     ...importDeclarations,
@@ -31,14 +32,11 @@ module.exports = {
     DebuggerStatement,
     Program(path, {print}) {
         path.get('body').forEach(print);
+        print.newline();
     },
     SwitchStatement,
     ...TryStatements,
-    BreakStatement(path, {print, indent}) {
-        indent();
-        print('break;');
-        print.newline();
-    },
+    BreakStatement,
     ContinueStatement(path, {indent, print}) {
         indent();
         print('continue;');

package/lib/tokenize/tokenize.js

@@ -1,12 +1,14 @@
 'use strict';
 
+const fullstore = require('fullstore');
+
 const isObject = (a) => a && typeof a === 'object';
 const babelTraverse = require('@babel/traverse').default;
 const expressions = require('./expressions');
 const statements = require('./statements');
 const literals = require('./literals');
 const {TYPES} = require('../types');
-const {maybeFile} = require('./maybe');
+const {maybeFile, maybePlugin} = require('./maybe');
 
 const {
     createDebug,
@@ -137,6 +139,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
         debug,
         traverse,
         maybe,
+        store: fullstore(),
     };
     
     const currentTraversers = {
@@ -187,8 +190,9 @@ module.exports.tokenize = (ast, overrides = {}) => {
             throw Error(`Node type '${type}' is not supported yet: '${path}'`);
         
         parseLeadingComments(path, printer);
-        currentTraverse(path, printer);
+        maybePlugin(currentTraverse, path, printer);
         parseTrailingComments(path, printer);
+        
         debug(path.type);
     }
     
@@ -220,3 +224,4 @@ const createPrint = (path, {traverse, write}) => (maybeLine) => {
     
     return write(maybeLine);
 };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.9.1",
+  "version": "1.11.0",
   "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",
@@ -30,6 +30,7 @@
     "@babel/parser": "^7.19.0",
     "@babel/traverse": "^7.21.2",
     "@babel/types": "^7.21.3",
+    "fullstore": "^3.0.0",
     "just-snake-case": "^3.2.0"
   },
   "keywords": [