@master/eslint-plugin-css 2.0.0-rc.70 → 2.0.0-rc.72

package/dist/rules/class-collision.d.ts

@@ -1,4 +0,0 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
-};
-export default _default;

package/dist/rules/class-collision.mjs

@@ -1,74 +0,0 @@
-import defineVisitors from '../utils/define-visitors.mjs';
-import resolveContext from '../utils/resolve-context.mjs';
-import filterCollisionClasses from '../functions/filter-collision-classes.mjs';
-import createRule from '../create-rule.mjs';
-import settingsSchema from '../settings-schema.mjs';
-
-var classCollision = createRule({
-    name: 'class-collision-detection',
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Avoid applying classes with the same declarations'
-        },
-        messages: {
-            collisionClass: '{{message}}'
-        },
-        fixable: 'code',
-        schema: [
-            settingsSchema
-        ]
-    },
-    defaultOptions: [],
-    create (context) {
-        const { settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (node, { raw, start, end, nodes, classNodes, classValues })=>{
-            const collisionClassesRecord = filterCollisionClasses(classValues, css);
-            for(const className in collisionClassesRecord){
-                const collisionClasses = collisionClassesRecord[className];
-                const collisionClassNamesMsg = collisionClasses.map((x)=>`"${x}"`).join(' and ');
-                const classNode = classNodes.find((node)=>node.value === className);
-                const fixedNodes = [
-                    ...nodes
-                ];
-                const removeCollision = (removedClassNode)=>{
-                    for(let i = 0; i < fixedNodes.length; i++){
-                        const fixedNode = fixedNodes[i];
-                        const target = fixedNode === removedClassNode;
-                        if (target) {
-                            const prev = fixedNodes[i - 1];
-                            const isSpaceBefore = prev && prev.type === 'space';
-                            fixedNodes.splice(i, 1);
-                            if (isSpaceBefore) {
-                                fixedNodes.splice(i - 1, 1);
-                            }
-                        }
-                    }
-                };
-                collisionClasses.forEach((collisionClass)=>{
-                    const collisionNode = classNodes.find((node)=>node.value === collisionClass);
-                    removeCollision(collisionNode);
-                });
-                const fixedRaw = fixedNodes.map((node)=>node.raw).join('');
-                context.report({
-                    loc: classNode.loc,
-                    messageId: 'collisionClass',
-                    data: {
-                        message: `"${className}" applies the same declarations as ${collisionClassNamesMsg}.`
-                    },
-                    fix: function(fixer) {
-                        return fixer.replaceTextRange([
-                            start,
-                            end
-                        ], fixedRaw);
-                    }
-                });
-            }
-        });
-    }
-});
-
-export { classCollision as default };

package/dist/rules/class-validation.cjs

@@ -1,60 +0,0 @@
-'use strict';
-
-var defineVisitors = require('../utils/define-visitors.cjs');
-var resolveContext = require('../utils/resolve-context.cjs');
-var createRule = require('../create-rule.cjs');
-var settingsSchema = require('../settings-schema.cjs');
-var cssValidator = require('@master/css-validator');
-
-var classValidation = createRule({
-    name: 'syntax-error-checks',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Detect syntax errors early when writing classes'
-        },
-        messages: {
-            invalidClass: '{{message}}',
-            disallowUnknownClass: '{{message}}'
-        },
-        fixable: null,
-        schema: [
-            settingsSchema
-        ]
-    },
-    defaultOptions: [],
-    create: function(context) {
-        const { options, settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { classNodes })=>{
-            for (const node of classNodes){
-                const { matched, errors } = cssValidator.validate(node.value, css);
-                if (errors.length > 0) {
-                    for (const error of errors){
-                        if (matched) {
-                            context.report({
-                                node,
-                                messageId: 'invalidClass',
-                                data: {
-                                    message: error.message + '.'
-                                }
-                            });
-                        } else if (options.disallowUnknownClass) {
-                            context.report({
-                                node,
-                                messageId: 'disallowUnknownClass',
-                                data: {
-                                    message: `"${node.raw}" is not a valid or known class.`
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        });
-    }
-});
-
-module.exports = classValidation;

package/dist/rules/class-validation.mjs

@@ -1,58 +0,0 @@
-import defineVisitors from '../utils/define-visitors.mjs';
-import resolveContext from '../utils/resolve-context.mjs';
-import createRule from '../create-rule.mjs';
-import settingsSchema from '../settings-schema.mjs';
-import { validate } from '@master/css-validator';
-
-var classValidation = createRule({
-    name: 'syntax-error-checks',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Detect syntax errors early when writing classes'
-        },
-        messages: {
-            invalidClass: '{{message}}',
-            disallowUnknownClass: '{{message}}'
-        },
-        fixable: null,
-        schema: [
-            settingsSchema
-        ]
-    },
-    defaultOptions: [],
-    create: function(context) {
-        const { options, settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { classNodes })=>{
-            for (const node of classNodes){
-                const { matched, errors } = validate(node.value, css);
-                if (errors.length > 0) {
-                    for (const error of errors){
-                        if (matched) {
-                            context.report({
-                                node,
-                                messageId: 'invalidClass',
-                                data: {
-                                    message: error.message + '.'
-                                }
-                            });
-                        } else if (options.disallowUnknownClass) {
-                            context.report({
-                                node,
-                                messageId: 'disallowUnknownClass',
-                                data: {
-                                    message: `"${node.raw}" is not a valid or known class.`
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        });
-    }
-});
-
-export { classValidation as default };