eslint-plugin-turmag-special-rules 1.0.33 → 1.0.34

package/dist/add-vue-extension.d.ts

@@ -0,0 +1,37 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: {
+    meta: {
+        fixable: string;
+        type: string;
+        docs: {
+            description: string;
+        };
+        messages: {
+            proper: string;
+        };
+        schema: {
+            type: string;
+            properties: {
+                aliases: {
+                    type: string;
+                };
+            };
+        }[];
+    };
+    create(context: {
+        options: {
+            aliases: {
+                [key: string]: string;
+            } | ArrayLike<string>;
+        }[];
+        getFilename: () => string;
+        report: (arg0: {
+            node: unknown;
+            messageId: string;
+            fix: (fixer: any) => any;
+        }) => void;
+    }): {
+        ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    };
+};
+export default _default;

package/dist/add-vue-extension.js

@@ -0,0 +1,52 @@
+const path = require('node:path');
+const fs = require('node:fs');
+export default {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: {
+            description: 'Require .vue in vue files',
+        },
+        messages: {
+            proper: 'Use proper import of vue files',
+        },
+        schema: [{
+                type: 'object',
+                properties: { aliases: { type: 'object' } },
+            }],
+    },
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const aliases = Object.entries(context.options[0].aliases);
+                if (!aliases.length)
+                    return;
+                const basedir = path.dirname(path.resolve(context.getFilename()));
+                let nodeName = node.source.value;
+                aliases.every(([key, value]) => {
+                    if (nodeName.includes(key))
+                        nodeName = nodeName.replace(key, value);
+                    else
+                        return nodeName === node.source.value;
+                });
+                const filePath = path.resolve(basedir, nodeName);
+                const vueExt = '.vue';
+                const findRealExtension = (filePath) => {
+                    let realExt = fs.existsSync(filePath) ? path.extname(filePath) : null;
+                    if (realExt === null)
+                        realExt = fs.existsSync(`${filePath}${vueExt}`) ? path.extname(`${filePath}${vueExt}`) : null;
+                    return realExt;
+                };
+                const nodeNameExt = path.extname(nodeName);
+                const realExt = findRealExtension(filePath);
+                if (realExt === vueExt && realExt !== nodeNameExt) {
+                    context.report({
+                        node,
+                        messageId: 'proper',
+                        fix: fixer => fixer.replaceText(node, node.specifiers.map(specifier => `import ${specifier.local.name} from '${node.source.value}${realExt}';`).join('\n')),
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/import-entities-by-column-or-line.d.ts

@@ -0,0 +1,26 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: {
+    meta: {
+        fixable: string;
+        type: string;
+        docs: {
+            description: string;
+        };
+        messages: {
+            column: string;
+            line: string;
+        };
+        schema: {
+            type: string;
+            properties: {
+                minProperties: {
+                    type: string;
+                };
+            };
+        }[];
+    };
+    create(context: any): {
+        ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    };
+};
+export default _default;

package/dist/import-entities-by-column-or-line.js

@@ -0,0 +1,81 @@
+export default {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: {
+            description: 'Prefered column or line import',
+        },
+        messages: {
+            column: 'Use column import',
+            line: 'Use line import',
+        },
+        schema: [{
+                type: 'object',
+                properties: { minProperties: { type: 'number' } },
+            }],
+    },
+    // @ts-expect-error context type
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (!node.specifiers[0])
+                    return;
+                if (node.specifiers[0].type === 'ImportDefaultSpecifier')
+                    return;
+                const minProperties = context.options[0].minProperties;
+                const isTypedNode = node.importKind === 'type';
+                let areSmallAttributesInColumn = false;
+                let areLinesRepeated = false;
+                if (node.specifiers.length < minProperties) {
+                    if (node.specifiers[0].loc.start.line !== node.specifiers[0].parent.loc.start.line)
+                        areSmallAttributesInColumn = true;
+                }
+                else {
+                    node.specifiers.every((specifier, i) => {
+                        if (i === 0)
+                            return true;
+                        if (specifier.loc.start.line === specifier.loc.end.line && node.specifiers[i - 1].loc.start.line === specifier.loc.start.line)
+                            areLinesRepeated = true;
+                        else
+                            return !areLinesRepeated;
+                    });
+                }
+                const getSpecifiersArr = (specifiers) => {
+                    const specifiersArr = [];
+                    specifiers.forEach(specifier => {
+                        const localName = specifier.local.name;
+                        let resultName = localName;
+                        if (specifier.imported.name !== localName) {
+                            resultName = `${specifier.imported.name} as ${localName}`;
+                        }
+                        const name = specifier.importKind === 'type' ? `type ${resultName}` : resultName;
+                        specifiersArr.push(name);
+                    });
+                    return specifiersArr;
+                };
+                if (areLinesRepeated) {
+                    context.report({
+                        node,
+                        messageId: 'column',
+                        fix: (fixer) => {
+                            const specifiersArr = getSpecifiersArr(node.specifiers);
+                            const replaceShiftSign = '\n    ';
+                            return fixer.replaceText(node, `import ${isTypedNode ? 'type ' : ''}{${replaceShiftSign}${specifiersArr.join(`,${replaceShiftSign}`)},\n} from '${node.source.value}';`);
+                        },
+                    });
+                }
+                else if (areSmallAttributesInColumn) {
+                    context.report({
+                        node,
+                        messageId: 'line',
+                        fix: (fixer) => {
+                            const specifiersArr = getSpecifiersArr(node.specifiers);
+                            const replaceShiftSign = ' ';
+                            return fixer.replaceText(node, `import ${isTypedNode ? 'type ' : ''}{${replaceShiftSign}${specifiersArr.join(`,${replaceShiftSign}`)} } from '${node.source.value}';`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,253 @@
+export declare const rules: {
+    'add-vue-extension': {
+        meta: {
+            fixable: string;
+            type: string;
+            docs: {
+                description: string;
+            };
+            messages: {
+                proper: string;
+            };
+            schema: {
+                type: string;
+                properties: {
+                    aliases: {
+                        type: string;
+                    };
+                };
+            }[];
+        };
+        create(context: {
+            options: {
+                aliases: {
+                    [key: string]: string;
+                } | ArrayLike<string>;
+            }[];
+            getFilename: () => string;
+            report: (arg0: {
+                node: unknown;
+                messageId: string;
+                fix: (fixer: any) => any;
+            }) => void;
+        }): {
+            ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+        };
+    };
+    'import-entities-by-column-or-line': {
+        meta: {
+            fixable: string;
+            type: string;
+            docs: {
+                description: string;
+            };
+            messages: {
+                column: string;
+                line: string;
+            };
+            schema: {
+                type: string;
+                properties: {
+                    minProperties: {
+                        type: string;
+                    };
+                };
+            }[];
+        };
+        create(context: any): {
+            ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+        };
+    };
+    'prefer-true-attribute-shorthand': {
+        meta: {
+            fixable: string;
+            type: string;
+            docs: {
+                description: string;
+            };
+            messages: {
+                shortHand: string;
+                longHand: string;
+            };
+            schema: {
+                enum: string[];
+            }[];
+        };
+        create(context: any): any;
+    };
+    'use-shortest-alias': {
+        meta: {
+            fixable: string;
+            type: string;
+            docs: {
+                description: string;
+            };
+            messages: {
+                shortest: string;
+            };
+            schema: {
+                type: string;
+                properties: {
+                    aliases: {
+                        type: string;
+                    };
+                };
+            }[];
+        };
+        create(context: any): {
+            ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+        };
+    };
+    'variable-entities-by-column-or-line': {
+        meta: {
+            fixable: string;
+            type: string;
+            docs: {
+                description: string;
+            };
+            messages: {
+                column: string;
+                line: string;
+            };
+            schema: {
+                type: string;
+                properties: {
+                    minProperties: {
+                        type: string;
+                    };
+                };
+            }[];
+        };
+        create(context: any): {
+            VariableDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").VariableDeclaration): void;
+        };
+    };
+};
+declare const _default: {
+    rules: {
+        'add-vue-extension': {
+            meta: {
+                fixable: string;
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    proper: string;
+                };
+                schema: {
+                    type: string;
+                    properties: {
+                        aliases: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+            create(context: {
+                options: {
+                    aliases: {
+                        [key: string]: string;
+                    } | ArrayLike<string>;
+                }[];
+                getFilename: () => string;
+                report: (arg0: {
+                    node: unknown;
+                    messageId: string;
+                    fix: (fixer: any) => any;
+                }) => void;
+            }): {
+                ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+            };
+        };
+        'import-entities-by-column-or-line': {
+            meta: {
+                fixable: string;
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    column: string;
+                    line: string;
+                };
+                schema: {
+                    type: string;
+                    properties: {
+                        minProperties: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+            create(context: any): {
+                ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+            };
+        };
+        'prefer-true-attribute-shorthand': {
+            meta: {
+                fixable: string;
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    shortHand: string;
+                    longHand: string;
+                };
+                schema: {
+                    enum: string[];
+                }[];
+            };
+            create(context: any): any;
+        };
+        'use-shortest-alias': {
+            meta: {
+                fixable: string;
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    shortest: string;
+                };
+                schema: {
+                    type: string;
+                    properties: {
+                        aliases: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+            create(context: any): {
+                ImportDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").ImportDeclaration): void;
+            };
+        };
+        'variable-entities-by-column-or-line': {
+            meta: {
+                fixable: string;
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    column: string;
+                    line: string;
+                };
+                schema: {
+                    type: string;
+                    properties: {
+                        minProperties: {
+                            type: string;
+                        };
+                    };
+                }[];
+            };
+            create(context: any): {
+                VariableDeclaration(node: import("@typescript-eslint/types/dist/generated/ast-spec.js").VariableDeclaration): void;
+            };
+        };
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,13 @@
+import addVueExtension from './add-vue-extension.js';
+import importEntitesByColumnOrLine from './import-entities-by-column-or-line.js';
+import preferTrueAttributeShorthand from './prefer-true-attribute-shorthand.js';
+import useShortestAlias from './use-shortest-alias.js';
+import variableEntitiesByColumnOrLine from './variable-entities-by-column-or-line.js';
+export const rules = {
+    'add-vue-extension': addVueExtension,
+    'import-entities-by-column-or-line': importEntitesByColumnOrLine,
+    'prefer-true-attribute-shorthand': preferTrueAttributeShorthand,
+    'use-shortest-alias': useShortestAlias,
+    'variable-entities-by-column-or-line': variableEntitiesByColumnOrLine,
+};
+export default { rules };

package/dist/prefer-true-attribute-shorthand.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    meta: {
+        fixable: string;
+        type: string;
+        docs: {
+            description: string;
+        };
+        messages: {
+            shortHand: string;
+            longHand: string;
+        };
+        schema: {
+            enum: string[];
+        }[];
+    };
+    create(context: any): any;
+};
+export default _default;

package/dist/prefer-true-attribute-shorthand.js

@@ -0,0 +1,47 @@
+export default {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: {
+            description: 'Require shorthand form attribute when `v-bind` value is `true`',
+        },
+        messages: {
+            shortHand: 'Boolean prop with \'true\' value should be written in shorthand form',
+            longHand: 'Boolean prop with \'true\' value should be written in longhand form',
+        },
+        schema: [{ enum: ['always', 'never'] }],
+    },
+    // @ts-expect-error create type
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        return sourceCode.parserServices?.defineTemplateBodyVisitor
+            ? sourceCode.parserServices.defineTemplateBodyVisitor({
+                VAttribute(node) {
+                    const option = context.options[0] || 'always';
+                    if (option === 'never' && !node.directive && !node.value) {
+                        context.report({
+                            node,
+                            messageId: 'longHand',
+                            fix: (fixer) => fixer.replaceText(node, `:${node.key.rawName}="true"`),
+                        });
+                    }
+                    if (option !== 'always')
+                        return;
+                    if (node.directive && node.key.name !== 'bind' && node.value?.expression?.value && node.value.expression.value === Boolean(node.value.expression.value)) {
+                        const { argument } = node.key;
+                        if (!argument)
+                            return;
+                        context.report({
+                            node,
+                            messageId: 'shortHand',
+                            fix: (fixer) => {
+                                const sourceCode = context.getSourceCode();
+                                return fixer.replaceText(node, sourceCode.getText(argument));
+                            },
+                        });
+                    }
+                },
+            })
+            : {};
+    },
+};

package/dist/use-shortest-alias.d.ts

@@ -0,0 +1,25 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: {
+    meta: {
+        fixable: string;
+        type: string;
+        docs: {
+            description: string;
+        };
+        messages: {
+            shortest: string;
+        };
+        schema: {
+            type: string;
+            properties: {
+                aliases: {
+                    type: string;
+                };
+            };
+        }[];
+    };
+    create(context: any): {
+        ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    };
+};
+export default _default;

package/dist/use-shortest-alias.js

@@ -0,0 +1,62 @@
+export default {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: {
+            description: 'There are can be used shortest alias',
+        },
+        messages: {
+            shortest: 'Use shortest alias',
+        },
+        schema: [{
+                type: 'object',
+                properties: { aliases: { type: 'object' } },
+            }],
+    },
+    // @ts-expect-error context type
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const aliases = Object.entries(context.options[0].aliases);
+                if (!aliases.length)
+                    return;
+                const nodeName = node.source.value;
+                let nodeNameWithoutAlias = nodeName;
+                let resultNodeName = nodeName;
+                aliases.every(([key, value]) => {
+                    if (nodeNameWithoutAlias.includes(key))
+                        nodeNameWithoutAlias = nodeNameWithoutAlias.replace(key, value);
+                    else
+                        return nodeNameWithoutAlias === nodeName;
+                });
+                nodeNameWithoutAlias = nodeNameWithoutAlias.replace(/\\/ig, '/');
+                aliases.every(([key, value]) => {
+                    value = value.replace(/\\/ig, '/');
+                    if (nodeNameWithoutAlias.includes(value))
+                        resultNodeName = nodeNameWithoutAlias.replace(value, key).replace(/\\/ig, '/');
+                    else
+                        return resultNodeName === nodeName;
+                });
+                if (nodeName !== resultNodeName) {
+                    context.report({
+                        node,
+                        messageId: 'shortest',
+                        fix: (fixer) => {
+                            let replaceText = '';
+                            if (node.specifiers[0].type === 'ImportDefaultSpecifier')
+                                replaceText = `import ${node.specifiers[0].local.name} from '${resultNodeName}';`;
+                            else {
+                                const specifiersArr = [];
+                                node.specifiers.forEach(specifier => specifiersArr.push(specifier.local.name));
+                                const replaceSign = specifiersArr.length > 2 ? '\n' : ' ';
+                                const replaceShiftSign = specifiersArr.length > 2 ? '\n    ' : ' ';
+                                replaceText = `import {${replaceShiftSign}${specifiersArr.join(`,${replaceShiftSign}`)}${specifiersArr.length > 2 ? ',' : ''}${replaceSign}} from '${resultNodeName}';`;
+                            }
+                            return fixer.replaceText(node, replaceText);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/variable-entities-by-column-or-line.d.ts

@@ -0,0 +1,26 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: {
+    meta: {
+        fixable: string;
+        type: string;
+        docs: {
+            description: string;
+        };
+        messages: {
+            column: string;
+            line: string;
+        };
+        schema: {
+            type: string;
+            properties: {
+                minProperties: {
+                    type: string;
+                };
+            };
+        }[];
+    };
+    create(context: any): {
+        VariableDeclaration(node: TSESTree.VariableDeclaration): void;
+    };
+};
+export default _default;

package/dist/variable-entities-by-column-or-line.js

@@ -0,0 +1,105 @@
+export default {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: { description: 'Prefered column or line destructuring' },
+        messages: {
+            column: 'Use column destructuring',
+            line: 'Use line destructuring',
+        },
+        schema: [{
+                type: 'object',
+                properties: { minProperties: { type: 'number' } },
+            }],
+    },
+    // @ts-expect-error context type
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                if (!node.declarations[0])
+                    return;
+                if (node.declarations[0].id.type !== 'ObjectPattern')
+                    return;
+                if (!node.declarations[0].init)
+                    return;
+                const minProperties = context.options[0].minProperties;
+                const kind = node.kind;
+                const declaration = node.declarations[0];
+                // @ts-expect-error properties type
+                const properties = declaration.id.properties;
+                const sourceCode = context.sourceCode;
+                const rightSideText = sourceCode.getText(declaration.init);
+                let areSmallAttributesInColumn = false;
+                let areLinesRepeated = false;
+                let isObjectDestructured = false;
+                // @ts-expect-error property type
+                properties.forEach(property => {
+                    if (property.value?.type === 'ObjectPattern')
+                        isObjectDestructured = true;
+                });
+                if (isObjectDestructured)
+                    return;
+                if (properties.length < minProperties) {
+                    if (properties[0].loc.start.line !== properties[0].parent.loc.start.line)
+                        areSmallAttributesInColumn = true;
+                }
+                else {
+                    // @ts-expect-error property type
+                    properties.every((property, i) => {
+                        if (i === 0)
+                            return true;
+                        if (property.loc.start.line === property.loc.end.line && properties[i - 1].loc.start.line === property.loc.start.line)
+                            areLinesRepeated = true;
+                        else
+                            return !areLinesRepeated;
+                    });
+                }
+                // @ts-expect-error properties type
+                const getPropertiesArr = properties => {
+                    const propertiesArr = [];
+                    // @ts-expect-error property type
+                    properties.forEach(property => {
+                        if (property.type === 'RestElement') {
+                            propertiesArr.push(`...${property.argument.name}`);
+                            return;
+                        }
+                        const key = property.key.name;
+                        let value = property.value.name;
+                        let name = key === value ? value : `${key}: ${value}`;
+                        if (!value && property.value.left && property.value.right) {
+                            value = property.value.left.name;
+                            const rightValue = property.value.right.value;
+                            name = key === value ? `${value} = ${rightValue}` : `${key}: ${value} = ${rightValue}`;
+                        }
+                        propertiesArr.push(name);
+                    });
+                    return propertiesArr;
+                };
+                if (areLinesRepeated) {
+                    context.report({
+                        node,
+                        messageId: 'column',
+                        fix: (fixer) => {
+                            const propertiesArr = getPropertiesArr(properties);
+                            const replaceShiftSign = '\n    ';
+                            // @ts-expect-error node type
+                            return fixer.replaceText(node, `${kind} {${replaceShiftSign}${propertiesArr.join(`,${replaceShiftSign}`)},\n} = ${rightSideText};`);
+                        },
+                    });
+                }
+                else if (areSmallAttributesInColumn) {
+                    context.report({
+                        node,
+                        messageId: 'line',
+                        fix: (fixer) => {
+                            const propertiesArr = getPropertiesArr(properties);
+                            const replaceShiftSign = ' ';
+                            // @ts-expect-error node type
+                            return fixer.replaceText(node, `${kind} {${replaceShiftSign}${propertiesArr.join(`,${replaceShiftSign}`)} } = ${rightSideText};`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-turmag-special-rules",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "type": "module",
   "description": "Special eslint rules for your awesome projects",
   "keywords": [
@@ -9,10 +9,11 @@
     "eslint-plugin"
   ],
   "author": "Pavel",
-  "main": "./lib/index.ts",
+  "main": "./lib/rules/index.ts",
   "exports": "./dist/index.js",
   "files": [
-    "lib"
+    "lib",
+    "dist"
   ],
   "scripts": {
     "lint": "npm-run-all \"lint:*\"",