@putout/plugin-printer 8.24.0 → 9.0.0

package/lib/add-missing-colon-to-type-checker/index.js

@@ -1,65 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const {setLiteralValue} = operator;
-
-export const report = ({path, where}) => {
-    const {value} = path.node;
-    const withColon = addColon(value, where);
-    
-    return `Add missing colon: '${value}' -> '${withColon}'`;
-};
-
-export const fix = ({path, where}) => {
-    const {value} = path.node;
-    setLiteralValue(path, addColon(value, where));
-};
-export const traverse = ({push}) => ({
-    StringLiteral(path) {
-        const call = path.find(isCallExpression);
-        
-        if (!call)
-            return;
-        
-        if (!isIdentifier(call.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const {value} = path.node;
-        const where = createWhere(value);
-        
-        if (where.length)
-            push({
-                path,
-                where,
-            });
-    },
-});
-
-function createWhere(value) {
-    const where = [];
-    
-    if (value.length === 1)
-        return where;
-    
-    if (value.startsWith('+') && !value.includes(':'))
-        where.push('after-plus');
-    
-    if (value.startsWith('-') && !value.includes('-:'))
-        where.push('after-minus');
-    
-    return where;
-}
-
-function addColon(value, where) {
-    if (where.includes('after-plus'))
-        value = value.replace('+', '+:');
-    
-    if (where.includes('after-minus'))
-        value = value.replace('-', '-:');
-    
-    return value;
-}

package/lib/add-missing-spaces-to-type-checker/index.js

@@ -1,93 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const {setLiteralValue} = operator;
-
-export const report = ({path, where}) => {
-    const {value} = path.node;
-    const withSpaces = addSpaces(value, where);
-    
-    return `Add missing spaces: '${value}' -> '${withSpaces}'`;
-};
-
-export const fix = ({path, where}) => {
-    const {value} = path.node;
-    setLiteralValue(path, addSpaces(value, where));
-};
-export const traverse = ({push}) => ({
-    StringLiteral(path) {
-        const call = path.find(isCallExpression);
-        
-        if (!call)
-            return;
-        
-        if (!isIdentifier(call.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const {value} = path.node;
-        const where = createWhere(value);
-        
-        if (where.length)
-            push({
-                path,
-                where,
-            });
-    },
-});
-
-function createWhere(value) {
-    const where = [];
-    const includes = value.includes.bind(value);
-    const endsWith = value.endsWith.bind(value);
-    const push = where.push.bind(where);
-    
-    const tools = {
-        push,
-        includes,
-        endsWith,
-    };
-    
-    if (includes('->'))
-        traceArrow(tools);
-    
-    if (includes(':'))
-        traceColon(tools);
-    
-    return where;
-}
-
-function traceColon({push, includes, endsWith}) {
-    if (endsWith(':'))
-        return;
-    
-    if (includes(': '))
-        return;
-    
-    if (!includes(':->'))
-        push('after-colon');
-}
-
-function traceArrow({includes, endsWith, push}) {
-    if (!includes(' ->'))
-        push('before-arrow');
-    
-    if (!includes('-> ') && !endsWith('->'))
-        push('after-arrow');
-}
-
-function addSpaces(value, where) {
-    if (where.includes('before-arrow'))
-        value = value.replace('->', ' ->');
-    
-    if (where.includes('after-arrow'))
-        value = value.replace('->', '-> ');
-    
-    if (where.includes('after-colon'))
-        value = value.replace(':', ': ');
-    
-    return value;
-}

package/lib/add-missing-tuples-to-type-checker/index.js

@@ -1,94 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    isArrayExpression,
-    isIdentifier,
-    isCallExpression,
-    isStringLiteral,
-    arrayExpression,
-    stringLiteral,
-} = types;
-
-const {
-    replaceWith,
-    createTypeChecker,
-} = operator;
-
-const hasResult = (value) => /^[+-]/.test(value);
-
-const isDsl = createTypeChecker([
-    ['-: -> !StringLiteral'],
-    ['+: node.value ->', hasResult],
-]);
-
-const isSimple = createTypeChecker([
-    ['+: -> Identifier'],
-    ['+: -> CallExpression'],
-    ['-: -> !StringLiteral'],
-    ['+: node.value -> !', hasResult],
-]);
-
-export const report = (path) => {
-    return `Add missing tuple around: ${path}`;
-};
-
-export const fix = (path) => {
-    const {node} = path;
-    
-    if (isIdentifier(path) || isCallExpression(path)) {
-        replaceWith(path, arrayExpression([
-            stringLiteral('+'),
-            node,
-        ]));
-        return;
-    }
-    
-    const {value} = node;
-    
-    if (isStringLiteral(path) && !/^[+-]/.test(value)) {
-        replaceWith(path, arrayExpression([
-            stringLiteral(`+: -> ${value}`),
-        ]));
-        return;
-    }
-    
-    replaceWith(path, arrayExpression([node]));
-};
-
-export const traverse = ({push}) => ({
-    ArrayExpression(path) {
-        const {parentPath} = path;
-        
-        if (!isCallExpression(parentPath))
-            return;
-        
-        if (!isIdentifier(parentPath.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const elements = path.get('elements');
-        
-        if (isConsistent(elements))
-            return;
-        
-        for (const element of elements) {
-            if (!isArrayExpression(element))
-                push(element);
-        }
-    },
-});
-
-function isConsistent(elements) {
-    const arraysCount = elements.filter(isArrayExpression).length;
-    
-    if (elements.length === arraysCount)
-        return true;
-    
-    const simplesCount = elements.filter(isSimple).length;
-    
-    if (elements.length === simplesCount)
-        return true;
-    
-    const dslCount = elements.filter(isDsl).length;
-    
-    return elements.length === dslCount;
-}

package/lib/apply-boolean-operator-to-type-checker/index.js

@@ -1,60 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    compare,
-    setLiteralValue,
-} = operator;
-
-const {
-    isArrayExpression,
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-export const report = ({operator}) => `Apply boolean operator: '${operator}'`;
-
-export const fix = ({path, operator}) => {
-    const [first] = path.node.elements;
-    const {value} = first;
-    
-    setLiteralValue(first, `${value} -> ${operator}`);
-    path.node.elements.pop();
-};
-
-export const traverse = ({push}) => ({
-    ArrayExpression(path) {
-        const {parentPath} = path;
-        
-        if (!isCallExpression(parentPath))
-            return;
-        
-        const {callee} = parentPath.node;
-        
-        if (!isIdentifier(callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const elements = path.get('elements');
-        
-        for (const element of elements) {
-            if (!isArrayExpression(element))
-                continue;
-            
-            const [, checker] = element.get('elements');
-            
-            if (!checker)
-                return;
-            
-            if (isIdentifier(checker.node, {name: 'Boolean'}))
-                push({
-                    operator: '+',
-                    path: element,
-                });
-            
-            if (compare(checker.node, 'not(Boolean)'))
-                push({
-                    operator: '-',
-                    path: element,
-                });
-        }
-    },
-});

package/lib/check-if-success-possible-in-type-checker/index.js

@@ -1,51 +0,0 @@
-import {types} from 'putout';
-
-const {
-    isArrayExpression,
-    isStringLiteral,
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-export const report = () => `Success path ('+') is absent in Type Checker, all branches routes to fail ('-')`;
-
-export const fix = () => {};
-
-export const traverse = ({push}) => ({
-    ArrayExpression(path) {
-        const {parentPath} = path;
-        
-        if (!isCallExpression(parentPath))
-            return;
-        
-        const {callee} = parentPath.node;
-        
-        if (!isIdentifier(callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const {elements} = path.node;
-        const results = elements.map(getResult);
-        const successes = results.filter(Boolean);
-        
-        if (!successes.length)
-            push(path);
-    },
-});
-
-const getResult = (a) => {
-    if (isStringLiteral(a)) {
-        const {value} = a;
-        
-        if (value.startsWith('-'))
-            return false;
-    }
-    
-    if (isArrayExpression(a)) {
-        const {value} = a.elements[0];
-        
-        if (value.startsWith('-'))
-            return false;
-    }
-    
-    return true;
-};

package/lib/check-type-passed-to-type-checker/index.js

@@ -1,97 +0,0 @@
-import {types, operator} from 'putout';
-import {isTypeExists} from '#types';
-
-const {createTypeChecker} = operator;
-const addQuotes = (a) => `'${a}'`;
-
-const {
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const ARROW = ' -> ';
-const ARROW_NOT = ' -> !';
-const ARROW_LENGTH = ARROW.length;
-const ARROW_NOT_LENGTH = ARROW_NOT.length;
-const NOT = '!';
-
-const INSTEAD = new Map([
-    ['ExportDeclaration', [
-        'ExportAllDeclaration',
-        'ExportDefaultDeclaration',
-        'ExportNamedDeclaration',
-    ]],
-]);
-
-export const report = ({type}) => {
-    if (!INSTEAD.has(type))
-        return `Unknown type detected: '${type}'`;
-    
-    const instead = INSTEAD.get(type).map(addQuotes)
-        .join(', ');
-    
-    return `Unknown type detected: '${type}'. Use ${instead} instead`;
-};
-
-const isWrongTuple = createTypeChecker([
-    ['-: parentPath.parentPath -> !ArrayExpression'],
-    ['+: parentPath.node.elements.length', '=', 3],
-]);
-
-export const fix = () => {};
-
-export const traverse = ({push}) => ({
-    StringLiteral(path) {
-        const call = path.find(isCallExpression);
-        
-        if (!call)
-            return;
-        
-        if (!isIdentifier(call.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const {value} = path.node;
-        
-        if (isWrongTuple(path))
-            return;
-        
-        if (!value.includes(ARROW)) {
-            if (/^[a-zA-Z].+/.test(value) && !isTypeExists(value))
-                push({
-                    path,
-                    type: value,
-                });
-            
-            return;
-        }
-        
-        if (value.includes(NOT)) {
-            const arrowNotIndex = value.indexOf(ARROW_NOT);
-            const typeNotIndex = arrowNotIndex + ARROW_NOT_LENGTH;
-            
-            const type = value.slice(typeNotIndex, value.length);
-            
-            if (!type)
-                return;
-            
-            if (!isTypeExists(type))
-                push({
-                    path,
-                    type,
-                });
-            
-            return;
-        }
-        
-        const arrowIndex = value.indexOf(ARROW);
-        const typeIndex = arrowIndex + ARROW_LENGTH;
-        
-        const type = value.slice(typeIndex, value.length);
-        
-        if (!isTypeExists(type))
-            push({
-                path,
-                type,
-            });
-    },
-});

package/lib/merge-tuples-of-type-checkers/index.js

@@ -1,96 +0,0 @@
-import {types, operator} from 'putout';
-import {isTypeExists} from '#types';
-
-const {
-    isArrayExpression,
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const {setLiteralValue} = operator;
-const cutIS = (a) => a.slice(2);
-
-const prepareValue = (a) => {
-    if (/^[+-]$/.test(a))
-        return `${a}: `;
-    
-    if (a.endsWith('!'))
-        return a;
-    
-    if (!a.endsWith('->'))
-        return `${a} -> `;
-    
-    return `${a} `;
-};
-
-export const report = () => `Merge tuple of type checker`;
-
-function prepareChecker(name, value) {
-    if (name === 'Boolean') {
-        if (value.endsWith('!'))
-            return `${value.slice(0, -1)}-`;
-        
-        if (value.endsWith('->'))
-            return `${value} +`;
-        
-        return `${value} -> +`;
-    }
-    
-    return `${prepareValue(value)}${name}`;
-}
-
-export const fix = ({path, name}) => {
-    const [first] = path.node.elements;
-    const {value} = first;
-    
-    setLiteralValue(first, prepareChecker(name, value));
-    path.node.elements.pop();
-};
-
-export const traverse = ({push}) => ({
-    ArrayExpression(path) {
-        const {parentPath} = path;
-        
-        if (!isCallExpression(parentPath))
-            return;
-        
-        const {callee} = parentPath.node;
-        
-        if (!isIdentifier(callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const elements = path.get('elements');
-        
-        for (const element of elements) {
-            if (!isArrayExpression(element))
-                continue;
-            
-            const [, checker] = element.get('elements');
-            
-            if (!isIdentifier(checker))
-                continue;
-            
-            const checkerName = checker.node.name;
-            
-            if (checkerName === 'Boolean')
-                push({
-                    path: element,
-                    name: 'Boolean',
-                });
-            
-            if (!checkerName.startsWith('is'))
-                continue;
-            
-            const name = cutIS(checkerName);
-            
-            if (!name)
-                continue;
-            
-            if (isTypeExists(name))
-                push({
-                    path: element,
-                    name,
-                });
-        }
-    },
-});

package/lib/remove-trailing-spaces-from-type-checker/index.js

@@ -1,35 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const {setLiteralValue} = operator;
-
-export const report = (path) => {
-    const {value} = path.node;
-    const trimmed = value.trim();
-    
-    return `Avoid trailing spaces: '${value}' -> '${trimmed}'`;
-};
-
-export const fix = (path) => {
-    setLiteralValue(path, path.node.value.trim());
-};
-export const traverse = ({push}) => ({
-    StringLiteral(path) {
-        const call = path.find(isCallExpression);
-        
-        if (!call)
-            return;
-        
-        if (!isIdentifier(call.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const {value} = path.node;
-        
-        if (value.endsWith(' '))
-            push(path);
-    },
-});

package/lib/remove-useless-arrow-from-type-checker/index.js

@@ -1,71 +0,0 @@
-import {operator, types} from 'putout';
-
-const {
-    isIdentifier,
-    isCallExpression,
-    isArrayExpression,
-} = types;
-
-const {setLiteralValue} = operator;
-
-export const report = ({path, where}) => {
-    const {value} = path.node;
-    const withSpaces = removeArrow(value, where);
-    
-    return `Remove useless arrow: '${value}' -> '${withSpaces}'`;
-};
-
-export const fix = ({path, where}) => {
-    const {value} = path.node;
-    setLiteralValue(path, removeArrow(value, where));
-};
-export const traverse = ({push}) => ({
-    StringLiteral(path) {
-        const call = path.find(isCallExpression);
-        
-        if (!call)
-            return;
-        
-        if (!isIdentifier(call.node.callee, {name: 'createTypeChecker'}))
-            return;
-        
-        const where = createWhere(path);
-        
-        if (where.length)
-            push({
-                path,
-                where,
-            });
-    },
-});
-
-function createWhere(path) {
-    const {value} = path.node;
-    const where = [];
-    const hasNot = value.includes('!');
-    
-    if (value.includes('-> ->'))
-        where.push('duplicate');
-    
-    if (!hasNot && isInsideCompareTuple(path) && value.includes(' -> '))
-        where.push('useless');
-    
-    return where;
-}
-
-function removeArrow(value, where) {
-    if (where.includes('duplicate'))
-        value = value.replace('-> ->', '->');
-    
-    if (where.includes('useless'))
-        value = value.replace(' -> ', '');
-    
-    return value;
-}
-
-function isInsideCompareTuple({parentPath}) {
-    if (!isArrayExpression(parentPath.parentPath))
-        return false;
-    
-    return parentPath.node.elements.length === 3;
-}