@putout/printer 16.6.0 → 17.0.0

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

@@ -1,7 +1,6 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {
+import {types} from '@putout/babel';
+import {parseComments} from '../../comment/comment.js';
+import {
     isCoupleLines,
     isForOf,
     isIf,
@@ -10,12 +9,10 @@ const {
     noLeadingComment,
     hasLeadingComment,
     exists,
-} = require('../../is');
-
-const {parseComments} = require('../../comment/comment');
-const {isInsideTuple} = require('./is-inside-tuple');
-const {isLooksLikeChain} = require('../member-expression/is-looks-like-chain');
-const {isThirdObjectInsideArray} = require('./is-third-object-inside-array');
+} from '../../is.js';
+import {isInsideTuple} from './is-inside-tuple.js';
+import {isLooksLikeChain} from '../member-expression/is-looks-like-chain.js';
+import {isThirdObjectInsideArray} from './is-third-object-inside-array.js';
 
 const {
     isStringLiteral,
@@ -58,7 +55,7 @@ function isInsideNestedTuple({parentPath}) {
     return isStringLiteral(first);
 }
 
-module.exports.ObjectExpression = (path, printer, semantics) => {
+export const ObjectExpression = (path, printer, semantics) => {
     const {trailingComma} = semantics;
     const {
         print,
@@ -153,8 +150,7 @@ const notLastArgInsideCall = (path) => {
 const ONE_LINE = true;
 const MANY_LINES = false;
 
-module.exports.isOneLine = isOneLine;
-function isOneLine(path) {
+export function isOneLine(path) {
     const {length} = path.get('properties');
     
     if (!length)

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

@@ -1,10 +1,8 @@
-'use strict';
+import {isConcatenation} from '../binary-expression/concatenate.js';
+import {isOneLine} from './object-expression.js';
+import {printKey} from './print-key.js';
 
-const {isConcatenation} = require('../binary-expression/concatenate');
-const {isOneLine} = require('./object-expression');
-const {printKey} = require('./print-key');
-
-module.exports.ObjectProperty = (path, printer, semantics) => {
+export const ObjectProperty = (path, printer, semantics) => {
     const {trailingComma} = semantics;
     const {shorthand} = path.node;
     const {

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

@@ -1,8 +1,6 @@
-'use strict';
+import {maybePrintComputed} from './maybe-print-computed.js';
 
-const {maybePrintComputed} = require('./maybe-print-computed');
-
-module.exports.printKey = (path, printer) => {
+export const printKey = (path, printer) => {
     const key = path.get('key');
     
     maybePrintComputed(path, key, printer);

package/lib/tokenize/expressions/object-pattern/calculate-long-assign-pattern.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isAssignmentPattern,
     isArrayExpression,
@@ -8,7 +7,7 @@ const {
     isIdentifier,
 } = types;
 
-module.exports.calculateAssigns = (property, semantics) => {
+export const calculateAssigns = (property, semantics) => {
     const currentAssign = isLongAssignPattern(property, semantics);
     
     const {right} = property.node.value;
@@ -20,9 +19,7 @@ module.exports.calculateAssigns = (property, semantics) => {
     };
 };
 
-module.exports.isLongAssignPattern = isLongAssignPattern;
-
-function isLongAssignPattern(path, semantics) {
+export function isLongAssignPattern(path, semantics) {
     const {key, value} = path.node;
     
     if (!isAssignmentPattern(value))

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

@@ -1,9 +1,7 @@
-'use strict';
-
 const createPrintCommentLine = (fn) => (value) => fn(`//${value}`);
 const createPrintCommentBlock = (fn) => (value) => fn(`/*${value}*/`);
 
-module.exports.printLeadingComments = (path, {print}) => {
+export const printLeadingComments = (path, {print}) => {
     const printCommentLine = createPrintCommentLine(print);
     const printCommentBlock = createPrintCommentBlock(print);
     const {leadingComments} = path.node;

package/lib/tokenize/expressions/object-pattern/more-then-max-properties-in-one-line.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.moreThenMaxPropertiesInOneLine = (path, {maxPropertiesInOneLine}) => {
+export const moreThenMaxPropertiesInOneLine = (path, {maxPropertiesInOneLine}) => {
     const {parentPath} = path;
     
     if (parentPath.isObjectProperty())

package/lib/tokenize/expressions/object-pattern/more-then-max-properties-length-in-one-line.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isAssignmentPattern,
     isIdentifier,
@@ -16,7 +15,7 @@ function getLength(left, right) {
     return 0;
 }
 
-module.exports.moreThenMaxPropertiesLengthInOneLine = (path, {maxPropertiesLengthInOneLine}) => {
+export const moreThenMaxPropertiesLengthInOneLine = (path, {maxPropertiesLengthInOneLine}) => {
     const {properties} = path.node;
     
     for (const {key, value} of properties) {

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

@@ -1,27 +1,19 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {wrongShorthand} = require('./wrong-shorthand');
-
-const {
+import {types} from '@putout/babel';
+import {wrongShorthand} from './wrong-shorthand.js';
+import {
     isForOf,
     isCoupleLines,
     exists,
-} = require('../../is');
-
-const {moreThenMaxPropertiesInOneLine} = require('./more-then-max-properties-in-one-line');
-
-const {maybeTypeAnnotation} = require('../../maybe/maybe-type-annotation');
-const {moreThenMaxPropertiesLengthInOneLine} = require('./more-then-max-properties-length-in-one-line');
-const {printKey} = require('../object-expression/print-key');
-
-const {
+} from '../../is.js';
+import {moreThenMaxPropertiesInOneLine} from './more-then-max-properties-in-one-line.js';
+import {maybeTypeAnnotation} from '../../maybe/maybe-type-annotation.js';
+import {moreThenMaxPropertiesLengthInOneLine} from './more-then-max-properties-length-in-one-line.js';
+import {printKey} from '../object-expression/print-key.js';
+import {
     calculateAssigns,
     isLongAssignPattern,
-} = require('./calculate-long-assign-pattern');
-
-const {printLeadingComments} = require('./comments');
+} from './calculate-long-assign-pattern.js';
+import {printLeadingComments} from './comments.js';
 
 const {
     isObjectExpression,
@@ -95,7 +87,7 @@ function isNextAssignObject(path) {
     return isObjectExpression(right);
 }
 
-module.exports.ObjectPattern = {
+export const ObjectPattern = {
     print: maybeTypeAnnotation((path, printer, semantics) => {
         const shouldIndent = isIndent(path);
         const {

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

@@ -1,5 +1,3 @@
-'use strict';
-
-module.exports.wrongShorthand = ({computed, isAssign, keyPath, valuePath}) => {
+export const wrongShorthand = ({computed, isAssign, keyPath, valuePath}) => {
     return !computed && !isAssign && keyPath.node.name !== valuePath.node.name;
 };

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

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {isJSXElement} = types;
 
 const condition = (path) => {
@@ -8,7 +7,7 @@ const condition = (path) => {
     return !isJSXElement(expression);
 };
 
-module.exports.ParenthesizedExpression = {
+export const ParenthesizedExpression = {
     before(path, {print}) {
         print('(');
     },

package/lib/tokenize/expressions/rest-element.js

@@ -1,8 +1,6 @@
-'use strict';
+import {maybeTypeAnnotation} from '../maybe/maybe-type-annotation.js';
 
-const {maybeTypeAnnotation} = require('../maybe/maybe-type-annotation');
-
-module.exports.RestElement = maybeTypeAnnotation((path, {print}) => {
+export const RestElement = maybeTypeAnnotation((path, {print}) => {
     print('...');
     print('__argument');
 });

package/lib/tokenize/expressions/sequence-expression/maybe-write-brace.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.condition = (path, printer, semantics) => {
+export const condition = (path, printer, semantics) => {
     const {parentPath} = path;
     const {type} = parentPath;
     const {roundBraces} = semantics;

package/lib/tokenize/expressions/sequence-expression/sequence-expression-comments.js

@@ -1,12 +1,11 @@
-'use strict';
+import {hasLeadingComment} from '#is';
 
-const {hasLeadingComment} = require('#is');
 const noop = () => {};
 
-module.exports.printLeadingCommentLine = noop;
-module.exports.printLeadingCommentBlock = noop;
+export const printLeadingCommentLine = noop;
+export const printLeadingCommentBlock = noop;
 
-module.exports.maybePrintComments = (path, {print}) => {
+export const maybePrintComments = (path, {print}) => {
     if (hasLeadingComment(path)) {
         const {leadingComments} = path.node;
         

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

@@ -1,16 +1,13 @@
-'use strict';
-
-const {hasLeadingComment} = require('#is');
-const {maybeParens} = require('../../maybe/maybe-parens');
-const {condition} = require('./maybe-write-brace');
-
-const {
+import {hasLeadingComment} from '#is';
+import {maybeParens} from '../../maybe/maybe-parens.js';
+import {condition} from './maybe-write-brace.js';
+import {
     maybePrintComments,
     printLeadingCommentLine,
     printLeadingCommentBlock,
-} = require('./sequence-expression-comments');
+} from './sequence-expression-comments.js';
 
-module.exports.SequenceExpression = maybeParens({
+export const SequenceExpression = maybeParens({
     checkParens: false,
     condition,
     print(path, printer) {
@@ -49,5 +46,5 @@ module.exports.SequenceExpression = maybeParens({
     },
 });
 
-module.exports.SequenceExpression.printLeadingCommentLine = printLeadingCommentLine;
-module.exports.SequenceExpression.printLeadingCommentBlock = printLeadingCommentBlock;
+SequenceExpression.printLeadingCommentLine = printLeadingCommentLine;
+SequenceExpression.printLeadingCommentBlock = printLeadingCommentBlock;

package/lib/tokenize/expressions/spread-element.js

@@ -1,8 +1,6 @@
-'use strict';
+import {hasTrailingComment} from '../is.js';
 
-const {hasTrailingComment} = require('../is');
-
-module.exports.SpreadElement = (path, printer) => {
+export const SpreadElement = (path, printer) => {
     const {print} = printer;
     print('...');
     print('__argument');

package/lib/tokenize/expressions/tagged-template-expression.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.TaggedTemplateExpression = (path, {print}) => {
+export const TaggedTemplateExpression = (path, {print}) => {
     print('__tag');
     print('__quasi');
 };

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

@@ -1,7 +1,5 @@
-'use strict';
-
-const {isLast, isNext} = require('../../is');
-const {maybeParens} = require('../../maybe/maybe-parens');
+import {isLast, isNext} from '../../is.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
 const isWord = (a) => /^(delete|typeof|void|throw)$/.test(a);
 
@@ -16,16 +14,16 @@ const unaryExpression = maybeParens((path, printer) => {
     maybe.print(!prefix, operator);
 });
 
-module.exports.UnaryExpression = unaryExpression;
-module.exports.UpdateExpression = unaryExpression;
+export const UnaryExpression = unaryExpression;
+export const UpdateExpression = unaryExpression;
 
-module.exports.AwaitExpression = maybeParens((path, {print}) => {
+export const AwaitExpression = maybeParens((path, {print}) => {
     printUnary('await', {
         print,
     });
 });
 
-module.exports.YieldExpression = maybeParens((path, {print, maybe}) => {
+export const YieldExpression = maybeParens((path, {print, maybe}) => {
     const {delegate} = path.node;
     
     print(`yield`);
@@ -34,7 +32,7 @@ module.exports.YieldExpression = maybeParens((path, {print, maybe}) => {
     print('__argument');
 });
 
-module.exports.ThrowStatement = (path, {print, indent, maybe}) => {
+export const ThrowStatement = (path, {print, indent, maybe}) => {
     indent();
     
     printUnary('throw', {

package/lib/tokenize/is.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isStringLiteral,
     isIdentifier,
@@ -14,10 +13,10 @@ const {
     isLabeledStatement,
 } = types;
 
-const isParentProgram = (path) => path.parentPath?.isProgram();
-const isParentBlock = (path) => path.parentPath.isBlockStatement();
+export const isParentProgram = (path) => path.parentPath?.isProgram();
+export const isParentBlock = (path) => path.parentPath.isBlockStatement();
 
-const isNext = (path) => {
+export const isNext = (path) => {
     const next = path.getNextSibling();
     
     if (!next.node)
@@ -26,35 +25,30 @@ const isNext = (path) => {
     return !next.isEmptyStatement();
 };
 
-const isPrev = (path) => {
+export const isPrev = (path) => {
     const next = path.getPrevSibling();
     return next.node;
 };
 
-const isNextParent = (path) => isNext(path.parentPath);
-const isLast = (path) => isParentProgram(path) && !isNext(path);
+export const isNextParent = (path) => isNext(path.parentPath);
+export const isLast = (path) => isParentProgram(path) && !isNext(path);
 
-module.exports.isNextObject = (a) => a
+export const isNextObject = (a) => a
     .getNextSibling()
     .isObjectExpression();
 
-module.exports.isPrevObject = (a) => a
+export const isPrevObject = (a) => a
     .getPrevSibling()
     .isObjectExpression();
 
-module.exports.isFirst = (path) => path.node === path.parentPath.node.body?.[0];
-module.exports.isPrevBody = (path) => path
+export const isFirst = (path) => path.node === path.parentPath.node.body?.[0];
+export const isPrevBody = (path) => path
     .getPrevSibling()
     .isBlockStatement();
-module.exports.isNext = isNext;
-module.exports.isPrev = isPrev;
-module.exports.isNextParent = isNextParent;
-module.exports.isParentProgram = isParentProgram;
-module.exports.isParentBlock = isParentBlock;
-module.exports.isLast = isLast;
-module.exports.isParentLast = (path) => isLast(path.parentPath);
-
-module.exports.isIndented = (path = {}) => {
+
+export const isParentLast = (path) => isLast(path.parentPath);
+
+export const isIndented = (path = {}) => {
     const {parentPath, node} = path;
     
     if (!parentPath.node.loc)
@@ -63,18 +57,16 @@ module.exports.isIndented = (path = {}) => {
     return node.loc?.start.column !== parentPath.node.loc.start.column;
 };
 
-module.exports.isCoupleLines = isCoupleLines;
-
-function isCoupleLines(path) {
+export function isCoupleLines(path) {
     const start = path.node?.loc?.start?.line;
     const end = path.node?.loc?.end?.line;
     
     return end !== start;
 }
 
-module.exports.exists = (a) => a.node;
-module.exports.isStringAndIdentifier = isStringAndIdentifier;
-function isStringAndIdentifier([a, b]) {
+export const exists = (a) => a.node;
+
+export function isStringAndIdentifier([a, b]) {
     return isStringLiteral(a) && isIdentifier(b);
 }
 
@@ -90,7 +82,7 @@ const checkObject = (elements) => {
     return a.node.properties.length;
 };
 
-module.exports.isSimpleAndNotEmptyObject = (elements) => {
+export const isSimpleAndNotEmptyObject = (elements) => {
     const [a] = elements;
     
     const simpleTypes = [
@@ -107,13 +99,13 @@ module.exports.isSimpleAndNotEmptyObject = (elements) => {
     return checkObject(elements);
 };
 
-module.exports.isIdentifierAndIdentifier = ([a, b]) => {
+export const isIdentifierAndIdentifier = ([a, b]) => {
     return isIdentifier(a) && isIdentifier(b);
 };
 
-module.exports.isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
-module.exports.isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
-module.exports.isStringAndArray = ([a, b]) => {
+export const isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
+export const isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
+export const isStringAndArray = ([a, b]) => {
     if (!isStringLiteral(a))
         return false;
     
@@ -126,9 +118,9 @@ module.exports.isStringAndArray = ([a, b]) => {
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);
 const isForOfOrStatement = (a) => isForOfStatement(a) || isStatement(a);
 
-module.exports.isIf = (path) => isIfStatement(path.find(isIfOrStatement));
+export const isIf = (path) => isIfStatement(path.find(isIfOrStatement));
 
-module.exports.isForOf = (path) => {
+export const isForOf = (path) => {
     const current = path.find(isForOfOrStatement);
     
     if (isForOfStatement(current))
@@ -140,9 +132,9 @@ module.exports.isForOf = (path) => {
     return false;
 };
 
-module.exports.isInsideIf = (path) => path.parentPath?.isIfStatement();
+export const isInsideIf = (path) => path.parentPath?.isIfStatement();
 
-module.exports.isNewlineBetweenSiblings = (path) => {
+export const isNewlineBetweenSiblings = (path) => {
     const endCurrent = path.node?.loc?.end?.line;
     const startNext = path.getNextSibling().node?.loc?.start?.line;
     
@@ -152,9 +144,9 @@ module.exports.isNewlineBetweenSiblings = (path) => {
     return startNext - endCurrent > 1;
 };
 
-module.exports.isInsideLabel = ({parentPath}) => isLabeledStatement(parentPath);
+export const isInsideLabel = ({parentPath}) => isLabeledStatement(parentPath);
 
-module.exports.satisfy = (conditions) => (path) => {
+export const satisfy = (conditions) => (path) => {
     for (const condition of conditions)
         if (condition(path))
             return true;
@@ -164,17 +156,17 @@ module.exports.satisfy = (conditions) => (path) => {
 
 const parseNode = (path) => path.node || path;
 
-module.exports.hasCoupleTrailingComments = (path) => {
+export const hasCoupleTrailingComments = (path) => {
     const node = parseNode(path);
     return node?.trailingComments?.length > 1;
 };
 
-module.exports.hasTrailingComment = (path) => {
+export const hasTrailingComment = (path) => {
     const node = parseNode(path);
     return node.trailingComments?.length;
 };
 
-module.exports.hasLeadingComment = (path) => path.node?.leadingComments?.length;
+export const hasLeadingComment = (path) => path.node?.leadingComments?.length;
 
-module.exports.noTrailingComment = (path) => !path.node.trailingComments?.length;
-module.exports.noLeadingComment = (path) => !path.node.leadingComments?.length;
+export const noTrailingComment = (path) => !path.node.trailingComments?.length;
+export const noLeadingComment = (path) => !path.node.leadingComments?.length;

package/lib/tokenize/jsx/index.js

@@ -1,48 +1,41 @@
-'use strict';
+import {isCoupleLines} from '#is';
+import {parseComments} from '../comment/comment.js';
 
-const {JSXElement} = require('./jsx-element');
-const {JSXAttribute} = require('./jsx-attribute');
-const {isCoupleLines} = require('../is');
-const {JSXOpeningElement} = require('./jsx-opening-element');
-const fragments = require('./jsx-fragment');
-const {JSXText} = require('./jsx-text/jsx-text');
-const {parseComments} = require('../comment/comment');
+export {JSXElement} from './jsx-element.js';
+export {JSXAttribute} from './jsx-attribute.js';
+export {JSXOpeningElement} from './jsx-opening-element.js';
+export * from './jsx-fragment.js';
+export {JSXText} from './jsx-text/jsx-text.js';
 
-module.exports = {
-    ...fragments,
-    JSXElement,
-    JSXAttribute,
-    JSXOpeningElement,
-    JSXText,
-    JSXEmptyExpression(path, operations, semantics) {
-        parseComments(path, operations, semantics);
-    },
-    JSXExpressionContainer(path, {print}) {
-        print('{');
-        print('__expression');
-        print('}');
-    },
-    JSXIdentifier(path, {write}) {
-        write(path.node.name);
-    },
-    JSXMemberExpression(path, {print}) {
-        print('__object');
-        print('.');
-        print('__property');
-    },
-    JSXSpreadAttribute(path, {print, maybe}) {
-        const isNewline = isCoupleLines(path.parentPath);
-        maybe.indent.inc(isNewline);
-        maybe.print.breakline(isNewline);
-        print('{');
-        print('...');
-        print('__argument');
-        print('}');
-        maybe.indent.dec(isNewline);
-    },
-    JSXClosingElement(path, {print}) {
-        print('</');
-        print('__name');
-        print('>');
-    },
+export const JSXEmptyExpression = (path, operations, semantics) => {
+    parseComments(path, operations, semantics);
 };
+export const JSXExpressionContainer = (path, {print}) => {
+    print('{');
+    print('__expression');
+    print('}');
+};
+export const JSXIdentifier = (path, {write}) => {
+    write(path.node.name);
+};
+export const JSXMemberExpression = (path, {print}) => {
+    print('__object');
+    print('.');
+    print('__property');
+};
+export const JSXSpreadAttribute = (path, {print, maybe}) => {
+    const isNewline = isCoupleLines(path.parentPath);
+    maybe.indent.inc(isNewline);
+    maybe.print.breakline(isNewline);
+    print('{');
+    print('...');
+    print('__argument');
+    print('}');
+    maybe.indent.dec(isNewline);
+};
+export const JSXClosingElement = (path, {print}) => {
+    print('</');
+    print('__name');
+    print('>');
+};
+

package/lib/tokenize/jsx/jsx-attribute.js

@@ -1,8 +1,6 @@
-'use strict';
+import {isCoupleLines} from '../is.js';
 
-const {isCoupleLines} = require('../is');
-
-module.exports.JSXAttribute = {
+export const JSXAttribute = {
     condition(path) {
         return isCoupleLines(path.parentPath);
     },

package/lib/tokenize/jsx/jsx-element.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isJSXElement,
     isJSXExpressionContainer,
@@ -10,7 +9,7 @@ const {
 
 const isInsideArrow = ({parentPath}) => parentPath.isArrowFunctionExpression();
 
-module.exports.JSXElement = {
+export const JSXElement = {
     condition,
     before(path, {write, indent, maybe}) {
         const {leadingComments} = path.node;

package/lib/tokenize/jsx/jsx-fragment.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.JSXFragment = {
+export const JSXFragment = {
     condition,
     before(path, {write, indent}) {
         write('(');
@@ -19,11 +17,11 @@ module.exports.JSXFragment = {
     },
 };
 
-module.exports.JSXOpeningFragment = (path, {write}) => {
+export const JSXOpeningFragment = (path, {write}) => {
     write('<>');
 };
 
-module.exports.JSXClosingFragment = (path, {write}) => {
+export const JSXClosingFragment = (path, {write}) => {
     write('</>');
 };