@putout/printer 17.8.0 → 17.9.0

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.02.22, v17.9.0
+
+feature:
+- cc0746d @putout/printer: private import: #types
+- 0e9fa7f @putout/printer: move out indent
+- c7f8249 @putout/printer: printer: simplify
+- d2f8005 @putout/printer: tokenize: printer: add
+
+2026.02.22, v17.8.1
+
+feature:
+- 89ae686 tokenize: rm useless round
+
 2026.02.22, v17.8.0
 
 feature:

package/lib/tokenize/{debug.js → printer/debug.js}

@@ -1,7 +1,7 @@
 import process from 'node:process';
 import toSnakeCase from 'just-snake-case';
 import {codeFrameColumns} from '@putout/babel';
-import {TYPES} from '../types.js';
+import {TYPES} from '#types';
 
 const {stringify} = JSON;
 const {

package/lib/tokenize/printer/indent.js

@@ -0,0 +1,38 @@
+import {TYPES} from '#types';
+
+const {assign} = Object;
+
+export const createIndent = ({format, addToken}) => {
+    let i = 0;
+    
+    const incIndent = () => ++i;
+    const decIndent = () => --i;
+    
+    const indent = () => {
+        addToken({
+            type: TYPES.INDENT,
+            value: printIndent(i, format.indent),
+        });
+    };
+    
+    assign(indent, {
+        inc: incIndent,
+        dec: decIndent,
+        getLevel() {
+            return i;
+        },
+    });
+    
+    return indent;
+};
+
+function printIndent(i, indent) {
+    let result = '';
+    ++i;
+    
+    while (--i > 0) {
+        result += indent;
+    }
+    
+    return result;
+}

package/lib/tokenize/printer/printer.js

@@ -0,0 +1,314 @@
+import {fullstore} from 'fullstore';
+import {TYPES} from '#types';
+import {createDebug, createLog} from './debug.js';
+import {maybeMarkAfter} from '../mark.js';
+import * as baseVisitors from '../visitors.js';
+import {maybeVisitor, maybeThrow} from '../maybe/index.js';
+import {
+    parseLeadingComments,
+    parseTrailingComments,
+} from '../comment/comment.js';
+import {parseOverrides} from '../overrides/overrides.js';
+import {createIndent} from './indent.js';
+
+const isObject = (a) => a && typeof a === 'object';
+const isString = (a) => typeof a === 'string';
+
+const GET = '__';
+const get = (path, command) => path.get(command.replace(GET, ''));
+
+const {freeze, assign} = Object;
+
+export const createPrinter = (overrides) => {
+    const tokens = [];
+    const {
+        format,
+        semantics,
+        visitors,
+    } = parseOverrides(overrides);
+    
+    const addToken = createAddToken(tokens);
+    const debug = createDebug(tokens);
+    const write = createWrite(addToken);
+    
+    const indent = createIndent({
+        format,
+        addToken,
+    });
+    
+    const newline = createNewline({
+        format,
+        addToken,
+    });
+    
+    const breakline = createBreakline({
+        newline,
+        indent,
+    });
+    
+    const linebreak = createLinebreak({
+        indent,
+        newline,
+    });
+    
+    const space = createSpace({
+        format,
+        addToken,
+    });
+    
+    const splitter = createSplitter({
+        format,
+        addToken,
+    });
+    
+    const endOfFile = createEndOfFile({
+        format,
+        addToken,
+    });
+    
+    const quote = createQuote({
+        addToken,
+        format,
+    });
+    
+    assign(write, {
+        indent,
+        newline,
+        linebreak,
+        breakline,
+        space,
+        splitter,
+        quote,
+        endOfFile,
+    });
+    
+    const maybeBreakline = createMaybe(breakline);
+    const maybeNewline = createMaybe(newline);
+    const maybeLinebreak = createMaybe(linebreak);
+    const maybeSpace = createMaybe(space);
+    
+    const maybeWrite = createMaybeWrite({
+        write,
+    });
+    
+    assign(maybeWrite, {
+        newline: maybeNewline,
+        breakline: maybeBreakline,
+        linebreak: maybeLinebreak,
+        space: maybeSpace,
+    });
+    
+    const maybeIndent = createMaybe(indent);
+    
+    const maybe = {
+        indent: maybeIndent,
+        markAfter: maybeMarkAfter,
+        write: maybeWrite,
+        space: maybeSpace,
+    };
+    
+    const maybeIndentInc = createMaybe(indent.inc);
+    const maybeIndentDec = createMaybe(indent.dec);
+    
+    assign(maybe.indent, {
+        inc: maybeIndentInc,
+        dec: maybeIndentDec,
+    });
+    
+    const getMainPrinter = () => mainPrinter;
+    
+    const traverse = createTraverse({
+        maybeNewline,
+        maybeLinebreak,
+        maybeSpace,
+        maybeBreakline,
+        indent,
+        write,
+        debug,
+        semantics,
+        visitors,
+        getMainPrinter,
+    });
+    
+    // should never change to avoid unexpected errors related to printing path, since it hard to debug
+    const mainPrinter = freeze({
+        indent,
+        write,
+        debug,
+        maybe,
+        quote,
+        store: fullstore(),
+        traverse,
+    });
+    
+    const getTokens = () => tokens;
+    
+    return {
+        getTokens,
+        traverse,
+    };
+};
+
+const createTraverse = (overrides) => function traverse(path) {
+    const {
+        write,
+        debug,
+        maybeLinebreak,
+        maybeSpace,
+        maybeBreakline,
+        maybeNewline,
+        indent,
+        semantics,
+        visitors,
+        getMainPrinter,
+    } = overrides;
+    
+    const mainPrinter = getMainPrinter();
+    
+    const currentTraversers = {
+        ...baseVisitors,
+        ...visitors,
+    };
+    
+    const {type} = path;
+    const currentTraverse = currentTraversers[type];
+    
+    if (!path.node)
+        return;
+    
+    const print = createPrint(path, {
+        write,
+        traverse,
+    });
+    
+    const printer = {
+        ...mainPrinter,
+        traverse,
+        print,
+    };
+    
+    const maybePrint = (a, b) => a && print(b);
+    
+    assign(maybePrint, {
+        newline: maybeNewline,
+        breakline: maybeBreakline,
+        linebreak: maybeLinebreak,
+        space: maybeSpace,
+    });
+    
+    assign(printer.maybe, {
+        print: maybePrint,
+    });
+    
+    maybeThrow(!currentTraverse, path, `☝️ Node type '{{ type }}' is not supported yet by @putout/printer: '{{ path }}'`);
+    
+    const currentIndent = indent.getLevel();
+    
+    parseLeadingComments(path, printer, semantics, {
+        currentTraverse,
+    });
+    
+    // this is main thing
+    maybeVisitor(currentTraverse, path, printer, semantics);
+    parseTrailingComments(path, printer, semantics, {
+        currentTraverse,
+    });
+    
+    maybeThrow(indent.getLevel() !== currentIndent, path, `☝️Looks like indent level changed after token visitor: '{{ type }}', for code: '{{ path }}'`);
+    
+    debug(path.type);
+};
+
+const createPrint = (path, {traverse, write}) => {
+    const print = (maybeLine) => {
+        if (maybeLine === path)
+            return null;
+        
+        const computed = computePath(path, maybeLine);
+        
+        if (isObject(computed))
+            return traverse(computed);
+        
+        return write(computed);
+    };
+    
+    assign(print, write);
+    
+    return print;
+};
+
+const computePath = (path, maybeLine) => {
+    if (isString(maybeLine) && maybeLine.startsWith(GET))
+        return get(path, maybeLine);
+    
+    if (isObject(maybeLine))
+        return maybeLine;
+    
+    return maybeLine;
+};
+
+const createWrite = (addToken) => (value) => {
+    addToken({
+        type: TYPES.TOKEN,
+        value,
+    });
+};
+
+const createNewline = ({format, addToken}) => () => {
+    addToken({
+        type: TYPES.NEWLINE,
+        value: format.newline,
+    });
+};
+
+const createMaybe = (fn) => (a) => a && fn();
+
+const createBreakline = ({newline, indent}) => () => {
+    newline();
+    indent();
+};
+
+const createLinebreak = ({indent, newline}) => () => {
+    indent();
+    newline();
+};
+
+const createMaybeWrite = ({write}) => (a, b) => a && write(b);
+
+const createSpace = ({format, addToken}) => () => {
+    addToken({
+        type: TYPES.SPACE,
+        value: format.space,
+    });
+};
+
+const createSplitter = ({format, addToken}) => () => {
+    addToken({
+        type: TYPES.SPLITTER,
+        value: format.splitter,
+    });
+};
+
+const createQuote = ({addToken, format}) => () => {
+    addToken({
+        type: TYPES.QUOTE,
+        value: format.quote,
+    });
+};
+
+const createEndOfFile = ({format, addToken}) => () => {
+    addToken({
+        type: TYPES.END_OF_FILE,
+        value: format.endOfFile,
+    });
+};
+
+const createAddToken = (tokens) => {
+    const log = createLog();
+    
+    return (token) => {
+        log(token);
+        tokens.push(token);
+    };
+};
+

package/lib/tokenize/tokenize.js

@@ -1,175 +1,9 @@
-import {fullstore} from 'fullstore';
 import {traverse as babelTraverse} from '@putout/babel';
-import {TYPES} from '../types.js';
-import * as baseVisitors from './visitors.js';
-import {
-    maybeFile,
-    maybeVisitor,
-    maybeThrow,
-} from './maybe/index.js';
-import {createDebug, createLog} from './debug.js';
-import {maybeMarkAfter} from './mark.js';
-import {
-    parseLeadingComments,
-    parseTrailingComments,
-} from './comment/comment.js';
-import {parseOverrides} from './overrides/overrides.js';
-
-const isObject = (a) => a && typeof a === 'object';
-const {round} = Math;
-const isString = (a) => typeof a === 'string';
-const {assign, freeze} = Object;
-
-const GET = '__';
-const get = (path, command) => path.get(command.replace(GET, ''));
-
-const createAddToken = (tokens) => {
-    const log = createLog();
-    
-    return (token) => {
-        log(token);
-        tokens.push(token);
-    };
-};
+import {maybeFile} from './maybe/index.js';
+import {createPrinter} from './printer/printer.js';
 
 export const tokenize = (ast, overrides) => {
-    const {
-        visitors,
-        format,
-        semantics,
-    } = parseOverrides(overrides);
-    
-    const tokens = [];
-    const addToken = createAddToken(tokens);
-    const debug = createDebug(tokens);
-    
-    const write = (value) => {
-        addToken({
-            type: TYPES.TOKEN,
-            value,
-        });
-    };
-    
-    const indent = () => {
-        addToken({
-            type: TYPES.INDENT,
-            value: printIndent(i, format.indent),
-        });
-    };
-    
-    const maybeIndent = (a) => a && indent();
-    
-    const maybeIndentInc = (a) => a && indent.inc();
-    
-    const maybeIndentDec = (a) => a && indent.dec();
-    
-    const newline = () => {
-        addToken({
-            type: TYPES.NEWLINE,
-            value: format.newline,
-        });
-    };
-    
-    const maybeNewline = (a) => a && newline();
-    
-    const breakline = () => {
-        newline();
-        indent();
-    };
-    
-    const maybeBreakline = (a) => a && breakline();
-    
-    const linebreak = () => {
-        indent();
-        newline();
-    };
-    
-    const maybeLinebreak = (a) => a && linebreak();
-    const maybeWrite = (a, b) => a && write(b);
-    
-    const space = () => {
-        addToken({
-            type: TYPES.SPACE,
-            value: format.space,
-        });
-    };
-    
-    const maybeSpace = (a) => a && space();
-    let i = 0;
-    const incIndent = () => ++i;
-    const decIndent = () => --i;
-    
-    assign(indent, {
-        inc: incIndent,
-        dec: decIndent,
-    });
-    
-    const splitter = () => {
-        addToken({
-            type: TYPES.SPLITTER,
-            value: format.splitter,
-        });
-    };
-    
-    const quote = () => {
-        addToken({
-            type: TYPES.QUOTE,
-            value: format.quote,
-        });
-    };
-    
-    const endOfFile = () => {
-        addToken({
-            type: TYPES.END_OF_FILE,
-            value: format.endOfFile,
-        });
-    };
-    
-    assign(write, {
-        indent,
-        newline,
-        linebreak,
-        breakline,
-        space,
-        splitter,
-        quote,
-        endOfFile,
-    });
-    
-    assign(maybeWrite, {
-        newline: maybeNewline,
-        breakline: maybeBreakline,
-        linebreak: maybeLinebreak,
-        space: maybeSpace,
-    });
-    
-    const maybe = {
-        indent: maybeIndent,
-        markAfter: maybeMarkAfter,
-        write: maybeWrite,
-        space: maybeSpace,
-    };
-    
-    assign(maybe.indent, {
-        inc: maybeIndentInc,
-        dec: maybeIndentDec,
-    });
-    
-    // should never change to avoid unexpected errors related to printing path, since it hard to debug
-    const mainPrinter = freeze({
-        indent,
-        write,
-        debug,
-        traverse,
-        maybe,
-        quote,
-        store: fullstore(),
-    });
-    
-    const currentTraversers = {
-        ...baseVisitors,
-        ...visitors,
-    };
+    const {getTokens, traverse} = createPrinter(overrides);
     
     if (ast.parentPath)
         pathTraverse(ast, traverse);
@@ -181,92 +15,7 @@ export const tokenize = (ast, overrides) => {
             },
         });
     
-    function traverse(path) {
-        const {type} = path;
-        const currentTraverse = currentTraversers[type];
-        
-        if (!path.node)
-            return;
-        
-        const print = createPrint(path, {
-            write,
-            traverse,
-        });
-        
-        assign(print, write, {
-            space,
-            round,
-        });
-        
-        const printer = {
-            ...mainPrinter,
-            print,
-        };
-        
-        const maybePrint = (a, b) => a && print(b);
-        
-        assign(maybePrint, {
-            newline: maybeNewline,
-            breakline: maybeBreakline,
-            linebreak: maybeLinebreak,
-            space: maybeSpace,
-        });
-        
-        assign(printer.maybe, {
-            print: maybePrint,
-        });
-        
-        maybeThrow(!currentTraverse, path, `☝️ Node type '{{ type }}' is not supported yet by @putout/printer: '{{ path }}'`);
-        
-        const currentIndent = i;
-        parseLeadingComments(path, printer, semantics, {
-            currentTraverse,
-        });
-        
-        // this is main thing
-        maybeVisitor(currentTraverse, path, printer, semantics);
-        parseTrailingComments(path, printer, semantics, {
-            currentTraverse,
-        });
-        maybeThrow(i !== currentIndent, path, `☝️Looks like indent level changed after token visitor: '{{ type }}', for code: '{{ path }}'`);
-        
-        debug(path.type);
-    }
-    
-    return tokens;
-};
-
-function printIndent(i, indent) {
-    let result = '';
-    ++i;
-    
-    while (--i > 0) {
-        result += indent;
-    }
-    
-    return result;
-}
-
-const createPrint = (path, {traverse, write}) => (maybeLine) => {
-    if (maybeLine === path)
-        return null;
-    
-    const computed = computePath(path, maybeLine);
-    
-    if (isObject(computed))
-        return traverse(computed);
-    
-    return write(computed);
-};
-
-const computePath = (path, maybeLine) => {
-    if (isString(maybeLine) && maybeLine.startsWith(GET))
-        return get(path, maybeLine);
-    
-    if (isObject(maybeLine))
-        return maybeLine;
-    
-    return maybeLine;
+    return getTokens();
 };
 
 function pathTraverse(ast, traverse) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "17.8.0",
+  "version": "17.9.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -59,7 +59,8 @@
     "#is": "./lib/tokenize/is.js",
     "#maybe-parens": "./lib/tokenize/maybe/maybe-parens.js",
     "#print-params": "./lib/tokenize/expressions/function/params.js",
-    "#import-attributes": "./lib/tokenize/statements/import-declaration/import-attribute.js"
+    "#import-attributes": "./lib/tokenize/statements/import-declaration/import-attribute.js",
+    "#types": "./lib/types.js"
   },
   "devDependencies": {
     "@babel/parser": "^7.28.5",