@putout/printer 1.44.0 → 1.46.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.04.14, v1.46.0
+
+feature:
+- 7fafdd3 @putout/printer: add support of TSInterfaceDeclaration
+
+2023.04.14, v1.45.0
+
+feature:
+- 7a54443 @putout/printer: add support of TSMappedType
+
 2023.04.13, v1.44.0
 
 feature:

package/README.md

@@ -7,7 +7,13 @@ Prints [**Babel AST**](https://github.com/coderaiser/estree-to-babel) to readabl
 
 - ☝️ Similar to **Recast**, but simpler and easier in maintenance, since it supports only **Babel**.
 - ☝️ As opinionated as **Prettier**, but has more user-friendly output and works directly with **AST**.
-- ☝️ Like **ESLint** but without any configuration and plugins 🤷‍, also works directly with **Babel AST** only.
+- ☝️ Like **ESLint** but works directly with **Babel AST**.
+- ☝️ Easily extandable with help of [Overrides](h#overrides).
+
+Supports:
+- ✅ **ES2023**;
+- ✅ **JSX**;
+- ✅ **TypeScript**;
 
 ## Install
 
@@ -64,7 +70,27 @@ print(ast, {
 'const {a /* [hello world] */= 5} = b;\n';
 ```
 
-## Maybe
+### `print`
+
+Used in previous example `print` can be used for a couple purposes:
+
+- to print `string`;
+- to print `node` when `object` passed;
+- to print `node` when `string` started with `__`;
+
+```js
+print(ast, {
+    visitors: {
+        AssignmentPattern(path, {print, maybe}) {
+            maybe.print.newline(path.parentPath.isCallExpression());
+            print(' /* [hello world] */= ');
+            print('__right');
+        },
+    },
+});
+```
+
+### `maybe`
 
 When you need some condition use `maybe`. For example, to add newline only when parent node is `CallExpression` you
 can use `maybe.print.newline(condition)`:
@@ -81,6 +107,56 @@ print(ast, {
 });
 ```
 
+### `write`
+
+When are you going to output string you can use low-level function `write`:
+
+```js
+print(ast, {
+    visitors: {
+        BlockStatement(path, {write}) {
+            write('hello');
+        },
+    },
+});
+```
+
+### `indent`
+
+When you need to add indentation use `indent`, for example when you output body,
+you need to increment indentation, and then decrement it back:
+
+```js
+print(ast, {
+    visitors: {
+        BlockStatement(path, {write, indent}) {
+            write('{');
+            indent.inc();
+            indent();
+            write('some;');
+            indent.dec();
+            write('{');
+        },
+    },
+});
+```
+
+### `traverse`
+
+When are you needing to traverse node, you can use `traverse`:
+
+```js
+print(ast, {
+    visitors: {
+        AssignmentExpression(path, {traverse}) {
+            traverse(path.get('left'));
+        },
+    },
+});
+```
+
+This is the same as `print('__left')` but more low-level, and supports only objects.
+
 ## License
 
 MIT

package/lib/printer.js

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

package/lib/tokenize/comments.js

@@ -61,8 +61,6 @@ module.exports.parseTrailingComments = (path, {write, maybe}) => {
             maybe.indent(!sameLine);
             write(`//${value}`);
             maybe.write.newline(!sameLine);
-            
-            continue;
         }
     }
 };

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

@@ -5,6 +5,7 @@ module.exports.ExportSpecifier = (path, {print}) => {
         local,
         exported,
     } = path.node;
+    
     print('__local');
     
     if (exported.name !== local.name) {

package/lib/tokenize/typescript/index.js

@@ -3,10 +3,12 @@
 const {exists} = require('../is');
 const {TSTypeLiteral} = require('./ts-type-literal');
 const {TSTypeAliasDeclaration} = require('./ts-type-alias-declaration');
+const {TSMappedType} = require('./ts-mapped-type');
 
 module.exports = {
     TSTypeLiteral,
     TSTypeAliasDeclaration,
+    TSMappedType,
     TSTypeParameterDeclaration(path, {print}) {
         print('<');
         
@@ -33,12 +35,46 @@ module.exports = {
         print('__elementType');
         print('[]');
     },
-    TSTypeParameter(path, {write}) {
+    TSTypeParameter(path, {write, traverse}) {
+        const constraint = path.get('constraint');
         write(path.node.name);
+        
+        if (exists(constraint)) {
+            write(' in ');
+            traverse(constraint);
+        }
+    },
+    TSTypeOperator(path, {write, print}) {
+        const {operator} = path.node;
+        write(`${operator} `);
+        print('__typeAnnotation');
+    },
+    TSInterfaceDeclaration(path, {print}) {
+        print('interface ');
+        print('__id');
+        print('__body');
+    },
+    TSInterfaceBody(path, {traverse, write, indent}) {
+        write(' {');
+        write.newline();
+        indent.inc();
+        
+        for (const item of path.get('body')) {
+            indent();
+            traverse(item);
+            write(';');
+            write.newline();
+        }
+        
+        indent.dec();
+        write('}');
     },
     TSUndefinedKeyword(path, {write}) {
         write('undefined');
     },
+    TSBooleanKeyword(path, {write}) {
+        write('boolean');
+    },
     TSUnionType(path, {traverse, write}) {
         const types = path.get('types');
         const n = types.length - 1;
@@ -56,6 +92,12 @@ module.exports = {
     TSNumberKeyword(path, {write}) {
         write('number');
     },
+    TSIndexedAccessType(path, {print}) {
+        print('__objectType');
+        print('[');
+        print('__indexType');
+        print(']');
+    },
     TSStringKeyword(path, {write}) {
         write('string');
     },

package/lib/tokenize/typescript/ts-mapped-type.js

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports.TSMappedType = (path, {print, write, indent, maybe}) => {
+    const {
+        readonly,
+        optional,
+    } = path.node;
+    
+    write('{');
+    write.newline();
+    indent.inc();
+    indent();
+    
+    if (readonly) {
+        maybe.write(readonly === '-', '-');
+        write('readonly ');
+    }
+    
+    write('[');
+    print('__typeParameter');
+    write(']');
+    
+    if (optional) {
+        maybe.write(optional === '+', '+');
+        maybe.write(optional === '-', '-');
+        write('?');
+    }
+    
+    write(':');
+    write.space();
+    print('__typeAnnotation');
+    write(';');
+    indent.dec();
+    write.newline();
+    write('}');
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.44.0",
+  "version": "1.46.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",