@master/eslint-plugin-css 2.0.0-rc.15 → 2.0.0-rc.16

package/dist/rules/class-order.mjs

@@ -1 +1,194 @@
-import T from"../utils/define-visitors.mjs";import b from"../utils/resolve-context.mjs";import v from"../utils/get-template-element-body.mjs";import R from"../utils/get-template-element-suffix.mjs";import I from"../utils/get-template-element-prefix.mjs";import k from"../utils/extract-value-from-node.mjs";import L from"../utils/extract-range-from-node.mjs";import V from"../utils/extract-classnames-from-value.mjs";import _ from"../utils/find-loc.mjs";import $ from"../utils/reorder-valid-classes-action.mjs";var D={meta:{docs:{description:"Enforce a consistent and logical order of classes",category:"Stylistic Issues",recommended:!1,url:"https://rc.css.master.co/docs/code-linting#consistent-class-order"},messages:{invalidClassOrder:"No consistent class order followed."},fixable:"code",schema:[{type:"object",properties:{calleeMatching:{type:"string"},classMatching:{type:"string"},ignoredKeys:{type:"array",items:{type:"string",minLength:0},uniqueItems:!0},config:{type:["string","object"]}}}]},create:function(u){const{options:M,settings:x}=b(u),N=u.sourceCode,a=(r,t=null)=>{let s=null,o=null,c=null,d="",g="",p=[];if(t===null){s=k(r);const e=L(r);r.type==="TextAttribute"?(o=e[0],c=e[1]):(o=e[0]+1,c=e[1]-1)}else switch(t.type){case"Identifier":return;case"TemplateLiteral":t.expressions.forEach(l=>{a(r,l)}),s=N.getText(t),s=s.substring(1,s.length-1),p=s.match(/\$\{(?:(?<!\\\\)(['"`]).*?(?<!\\\\)\1|[^}])*?\}/g)??[];for(let l=0;l<p.length;l++)s=s.replace(p[l],`EXPRESSION_STRING_NUM_${l}`);o=t.range[0]+1,c=t.range[1]-1;break;case"ConditionalExpression":a(r,t.consequent),a(r,t.alternate);return;case"LogicalExpression":a(r,t.right);return;case"ArrayExpression":t.elements.forEach(l=>{a(r,l)});return;case"ObjectExpression":const e=r.callee&&r.callee.name==="classnames",f=r.key&&r.key.type==="VDirectiveKey";t.properties.forEach(l=>{const E=e||f?l.key:l.value;a(r,E)});return;case"Property":a(r,t.key);break;case"Literal":s=t.value,o=t.range[0]+1,c=t.range[1]-1;break;case"SvelteLiteral":if(s=t.value,s==="")return;o=t.range[0],c=t.range[1];break;case"TemplateElement":if(s=t.value.raw,s==="")return;o=t.range[0],c=t.range[1];const n=u.sourceCode.getText(t);d=I(n,s),g=R(n,s),s=v(n,d,g);break}const{classNames:y,whitespaces:h,headSpace:S,tailSpace:C}=V(s);if(y.length<=1)return;let m=$(y,x.config);m=y.filter(e=>!m.includes(e)).concat(m).filter(e=>e.trim()!=="");let i="";for(let e=0;e<m.length;e++){const f=h[e]??"",n=m[e];i+=S?`${f}${n}`:`${n}${f}`,n&&(!C&&e===m.length-1&&(i=i.replace(/\s+$/,"")),S&&C&&e===m.length-1&&(i+=h[h.length-1]??""))}for(let e=0;e<p.length;e++)s=s.replace(`EXPRESSION_STRING_NUM_${e}`,p[e]),i=i.replace(`EXPRESSION_STRING_NUM_${e}`,p[e]);if(s!==i){i=d+i+g;const e=N.lines,f=r.loc.start.line,n=r.loc.end.line,l={loc:_(s,e,f,n),messageId:"invalidClassOrder",fix:function(E){return E.replaceTextRange([o,c],i)}};u.report(l)}};return T({context:u,settings:x},a)}};export{D as default};
+import defineVisitors from '../utils/define-visitors.mjs';
+import resolveContext from '../utils/resolve-context.mjs';
+import getTemplateElementBody from '../utils/get-template-element-body.mjs';
+import getTemplateElementSuffix from '../utils/get-template-element-suffix.mjs';
+import getTemplateElementPrefix from '../utils/get-template-element-prefix.mjs';
+import extractValueFromNode from '../utils/extract-value-from-node.mjs';
+import extractRangeFromNode from '../utils/extract-range-from-node.mjs';
+import extractClassnamesFromValue from '../utils/extract-classnames-from-value.mjs';
+import findLoc from '../utils/find-loc.mjs';
+import reorderValidClassesAction from '../utils/reorder-valid-classes-action.mjs';
+
+var classOrder = {
+    meta: {
+        docs: {
+            description: 'Enforce a consistent and logical order of classes',
+            category: 'Stylistic Issues',
+            recommended: false,
+            url: 'https://rc.css.master.co/docs/code-linting#consistent-class-order'
+        },
+        messages: {
+            invalidClassOrder: 'No consistent class order followed.'
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    calleeMatching: {
+                        type: 'string'
+                    },
+                    classMatching: {
+                        type: 'string'
+                    },
+                    ignoredKeys: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            minLength: 0
+                        },
+                        uniqueItems: true
+                    },
+                    config: {
+                        type: [
+                            'string',
+                            'object'
+                        ]
+                    }
+                }
+            }
+        ]
+    },
+    create: function(context) {
+        const { options, settings } = resolveContext(context);
+        const sourceCode = context.sourceCode;
+        const visitNode = (node, arg = null)=>{
+            let originalClassNamesValue = null;
+            let start = null;
+            let end = null;
+            let prefix = '';
+            let suffix = '';
+            let expStrings = [];
+            if (arg === null) {
+                originalClassNamesValue = extractValueFromNode(node);
+                const range = extractRangeFromNode(node);
+                if (node.type === 'TextAttribute') {
+                    start = range[0];
+                    end = range[1];
+                } else {
+                    start = range[0] + 1;
+                    end = range[1] - 1;
+                }
+            } else {
+                switch(arg.type){
+                    case 'Identifier':
+                        return;
+                    case 'TemplateLiteral':
+                        arg.expressions.forEach((exp)=>{
+                            visitNode(node, exp);
+                        });
+                        originalClassNamesValue = sourceCode.getText(arg);
+                        originalClassNamesValue = originalClassNamesValue.substring(1, originalClassNamesValue.length - 1);
+                        expStrings = originalClassNamesValue.match(/\$\{(?:(?<!\\\\)(['"`]).*?(?<!\\\\)\1|[^}])*?\}/g) ?? [];
+                        for(let i = 0; i < expStrings.length; i++){
+                            originalClassNamesValue = originalClassNamesValue.replace(expStrings[i], `EXPRESSION_STRING_NUM_${i}`);
+                        }
+                        start = arg.range[0] + 1;
+                        end = arg.range[1] - 1;
+                        break;
+                    case 'ConditionalExpression':
+                        visitNode(node, arg.consequent);
+                        visitNode(node, arg.alternate);
+                        return;
+                    case 'LogicalExpression':
+                        visitNode(node, arg.right);
+                        return;
+                    case 'ArrayExpression':
+                        arg.elements.forEach((el)=>{
+                            visitNode(node, el);
+                        });
+                        return;
+                    case 'ObjectExpression':
+                        const isUsedByClassNamesPlugin = node.callee && node.callee.name === 'classnames';
+                        const isVue = node.key && node.key.type === 'VDirectiveKey';
+                        arg.properties.forEach((prop)=>{
+                            const propVal = isUsedByClassNamesPlugin || isVue ? prop.key : prop.value;
+                            visitNode(node, propVal);
+                        });
+                        return;
+                    case 'Property':
+                        visitNode(node, arg.key);
+                        break;
+                    case 'Literal':
+                        originalClassNamesValue = arg.value;
+                        start = arg.range[0] + 1;
+                        end = arg.range[1] - 1;
+                        break;
+                    case 'SvelteLiteral':
+                        originalClassNamesValue = arg.value;
+                        if (originalClassNamesValue === '') {
+                            return;
+                        }
+                        start = arg.range[0];
+                        end = arg.range[1];
+                        break;
+                    case 'TemplateElement':
+                        originalClassNamesValue = arg.value.raw;
+                        if (originalClassNamesValue === '') {
+                            return;
+                        }
+                        start = arg.range[0];
+                        end = arg.range[1];
+                        // https://github.com/eslint/eslint/issues/13360
+                        // The problem is that range computation includes the backticks (`test`)
+                        // but value.raw does not include them, so there is a mismatch.
+                        // start/end does not include the backticks, therefore it matches value.raw.
+                        const txt = context.sourceCode.getText(arg);
+                        prefix = getTemplateElementPrefix(txt, originalClassNamesValue);
+                        suffix = getTemplateElementSuffix(txt, originalClassNamesValue);
+                        originalClassNamesValue = getTemplateElementBody(txt, prefix, suffix);
+                        break;
+                }
+            }
+            const { classNames, whitespaces, headSpace, tailSpace } = extractClassnamesFromValue(originalClassNamesValue);
+            if (classNames.length <= 1) {
+                // Don't run sorting for a single or empty className
+                return;
+            }
+            let orderedClassNames = reorderValidClassesAction(classNames, settings.config);
+            orderedClassNames = classNames.filter((x)=>!orderedClassNames.includes(x)).concat(orderedClassNames).filter((x)=>x.trim() !== '');
+            // Generates the validated/sorted attribute value
+            let validatedClassNamesValue = '';
+            for(let i = 0; i < orderedClassNames.length; i++){
+                const w = whitespaces[i] ?? '';
+                const cls = orderedClassNames[i];
+                validatedClassNamesValue += headSpace ? `${w}${cls}` : `${cls}${w}`;
+                if (cls) {
+                    if (!tailSpace && i === orderedClassNames.length - 1) {
+                        validatedClassNamesValue = validatedClassNamesValue.replace(/\s+$/, '');
+                    }
+                    if (headSpace && tailSpace && i === orderedClassNames.length - 1) {
+                        validatedClassNamesValue += whitespaces[whitespaces.length - 1] ?? '';
+                    }
+                }
+            }
+            for(let i = 0; i < expStrings.length; i++){
+                originalClassNamesValue = originalClassNamesValue.replace(`EXPRESSION_STRING_NUM_${i}`, expStrings[i]);
+                validatedClassNamesValue = validatedClassNamesValue.replace(`EXPRESSION_STRING_NUM_${i}`, expStrings[i]);
+            }
+            if (originalClassNamesValue !== validatedClassNamesValue) {
+                validatedClassNamesValue = prefix + validatedClassNamesValue + suffix;
+                const sourceCodeLines = sourceCode.lines;
+                const nodeStartLine = node.loc.start.line;
+                const nodeEndLine = node.loc.end.line;
+                const descriptor = {
+                    loc: findLoc(originalClassNamesValue, sourceCodeLines, nodeStartLine, nodeEndLine),
+                    messageId: 'invalidClassOrder',
+                    fix: function(fixer) {
+                        return fixer.replaceTextRange([
+                            start,
+                            end
+                        ], validatedClassNamesValue);
+                    }
+                };
+                context.report(descriptor);
+            }
+        };
+        return defineVisitors({
+            context,
+            settings
+        }, visitNode);
+    }
+};
+
+export { classOrder as default };

package/dist/rules/class-validation.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var defineVisitors = require('../utils/define-visitors.cjs');
+var resolveContext = require('../utils/resolve-context.cjs');
+var findLoc = require('../utils/find-loc.cjs');
+var parseNodeRecursive = require('../utils/parse-node-recursive.cjs');
+var validateAction = require('../utils/validate-action.cjs');
+
+var classValidation = {
+    meta: {
+        docs: {
+            description: 'Detect syntax errors early when writing classes',
+            category: 'Stylistic Issues',
+            recommended: false,
+            url: 'https://rc.css.master.co/docs/code-linting#syntax-error-checks'
+        },
+        messages: {
+            invalidClass: '{{message}}',
+            disallowUnknownClass: '{{message}}'
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    calleeMatching: {
+                        type: 'string'
+                    },
+                    classMatching: {
+                        type: 'string'
+                    },
+                    ignoredKeys: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            minLength: 0
+                        },
+                        uniqueItems: true
+                    },
+                    config: {
+                        type: [
+                            'string',
+                            'object'
+                        ]
+                    }
+                }
+            }
+        ]
+    },
+    create: function(context) {
+        const { options, settings } = resolveContext(context);
+        const visitNode = (node, arg = null)=>{
+            parseNodeRecursive.parseNodeRecursive(node, arg, (classNames, node)=>{
+                const sourceCode = context.sourceCode;
+                const sourceCodeLines = sourceCode.lines;
+                const nodeStartLine = node.loc.start.line;
+                const nodeEndLine = node.loc.end.line;
+                for (const className of classNames){
+                    const { isMasterCSS, errors } = validateAction(className, settings.config);
+                    if (errors.length > 0) {
+                        for (const error of errors){
+                            if (isMasterCSS) {
+                                context.report({
+                                    loc: findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
+                                    messageId: 'invalidClass',
+                                    data: {
+                                        message: error.message + '.'
+                                    }
+                                });
+                            } else if (options.disallowUnknownClass) {
+                                context.report({
+                                    loc: findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
+                                    messageId: 'disallowUnknownClass',
+                                    data: {
+                                        message: `"${className}" is not a valid or known class.`
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            }, false, false, settings.ignoredKeys, context);
+        };
+        return defineVisitors({
+            context,
+            settings
+        }, visitNode);
+    }
+};
+
+module.exports = classValidation;

package/dist/rules/class-validation.mjs

@@ -1 +1,89 @@
-import u from"../utils/define-visitors.mjs";import y from"../utils/resolve-context.mjs";import l from"../utils/find-loc.mjs";import{parseNodeRecursive as C}from"../utils/parse-node-recursive.mjs";import w from"../utils/validate-action.mjs";var b={meta:{docs:{description:"Detect syntax errors early when writing classes",category:"Stylistic Issues",recommended:!1,url:"https://rc.css.master.co/docs/code-linting#syntax-error-checks"},messages:{invalidClass:"{{message}}",disallowUnknownClass:"{{message}}"},fixable:null,schema:[{type:"object",properties:{calleeMatching:{type:"string"},classMatching:{type:"string"},ignoredKeys:{type:"array",items:{type:"string",minLength:0},uniqueItems:!0},config:{type:["string","object"]}}}]},create:function(e){const{options:c,settings:o}=y(e);return u({context:e,settings:o},(d,m=null)=>{C(d,m,(g,r)=>{const t=e.sourceCode.lines,i=r.loc.start.line,n=r.loc.end.line;for(const s of g){const{isMasterCSS:f,errors:a}=w(s,o.config);if(a.length>0)for(const p of a)f?e.report({loc:l(s,t,i,n),messageId:"invalidClass",data:{message:p.message+"."}}):c.disallowUnknownClass&&e.report({loc:l(s,t,i,n),messageId:"disallowUnknownClass",data:{message:`"${s}" is not a valid or known class.`}})}},!1,!1,o.ignoredKeys,e)})}};export{b as default};
+import defineVisitors from '../utils/define-visitors.mjs';
+import resolveContext from '../utils/resolve-context.mjs';
+import findLoc from '../utils/find-loc.mjs';
+import { parseNodeRecursive } from '../utils/parse-node-recursive.mjs';
+import validateAction from '../utils/validate-action.mjs';
+
+var classValidation = {
+    meta: {
+        docs: {
+            description: 'Detect syntax errors early when writing classes',
+            category: 'Stylistic Issues',
+            recommended: false,
+            url: 'https://rc.css.master.co/docs/code-linting#syntax-error-checks'
+        },
+        messages: {
+            invalidClass: '{{message}}',
+            disallowUnknownClass: '{{message}}'
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    calleeMatching: {
+                        type: 'string'
+                    },
+                    classMatching: {
+                        type: 'string'
+                    },
+                    ignoredKeys: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            minLength: 0
+                        },
+                        uniqueItems: true
+                    },
+                    config: {
+                        type: [
+                            'string',
+                            'object'
+                        ]
+                    }
+                }
+            }
+        ]
+    },
+    create: function(context) {
+        const { options, settings } = resolveContext(context);
+        const visitNode = (node, arg = null)=>{
+            parseNodeRecursive(node, arg, (classNames, node)=>{
+                const sourceCode = context.sourceCode;
+                const sourceCodeLines = sourceCode.lines;
+                const nodeStartLine = node.loc.start.line;
+                const nodeEndLine = node.loc.end.line;
+                for (const className of classNames){
+                    const { isMasterCSS, errors } = validateAction(className, settings.config);
+                    if (errors.length > 0) {
+                        for (const error of errors){
+                            if (isMasterCSS) {
+                                context.report({
+                                    loc: findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
+                                    messageId: 'invalidClass',
+                                    data: {
+                                        message: error.message + '.'
+                                    }
+                                });
+                            } else if (options.disallowUnknownClass) {
+                                context.report({
+                                    loc: findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
+                                    messageId: 'disallowUnknownClass',
+                                    data: {
+                                        message: `"${className}" is not a valid or known class.`
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            }, false, false, settings.ignoredKeys, context);
+        };
+        return defineVisitors({
+            context,
+            settings
+        }, visitNode);
+    }
+};
+
+export { classValidation as default };

package/dist/settings.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const settings = {
+    calleeMatching: '^(classnames|clsx|ctl|cva|cv|classVariant|styled(?:\\.\\w+)?)',
+    classMatching: '^class(Name)?$',
+    ignoredKeys: [
+        'compoundVariants',
+        'defaultVariants'
+    ],
+    config: 'master.css'
+};
+
+module.exports = settings;

package/dist/settings.mjs

@@ -1 +1,11 @@
-const s={calleeMatching:"^(classnames|clsx|ctl|cva|cv|classVariant|styled(?:\\.\\w+)?)",classMatching:"^class(Name)?$",ignoredKeys:["compoundVariants","defaultVariants"],config:"master.css.*"};var a=s;export{a as default};
+const settings = {
+    calleeMatching: '^(classnames|clsx|ctl|cva|cv|classVariant|styled(?:\\.\\w+)?)',
+    classMatching: '^class(Name)?$',
+    ignoredKeys: [
+        'compoundVariants',
+        'defaultVariants'
+    ],
+    config: 'master.css'
+};
+
+export { settings as default };

package/dist/utils/are-declarations-equal.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+function areDeclarationsEqual(aDeclarations, bDeclarations) {
+    // 获取对象A和B的所有属性名
+    const aKeys = Object.keys(aDeclarations);
+    const bKeys = Object.keys(bDeclarations);
+    // 如果属性数量不相等，返回false
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    // 检查对象A的属性是否都存在于对象B中
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bDeclarations, key)) {
+            return false;
+        }
+    }
+    // 如果所有属性都匹配，返回true
+    return true;
+}
+
+module.exports = areDeclarationsEqual;

package/dist/utils/are-declarations-equal.mjs

@@ -1 +1,19 @@
-function s(r,e){const t=Object.keys(r),n=Object.keys(e);if(t.length!==n.length)return!1;for(const o of t)if(!Object.prototype.hasOwnProperty.call(e,o))return!1;return!0}export{s as default};
+function areDeclarationsEqual(aDeclarations, bDeclarations) {
+    // 获取对象A和B的所有属性名
+    const aKeys = Object.keys(aDeclarations);
+    const bKeys = Object.keys(bDeclarations);
+    // 如果属性数量不相等，返回false
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    // 检查对象A的属性是否都存在于对象B中
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bDeclarations, key)) {
+            return false;
+        }
+    }
+    // 如果所有属性都匹配，返回true
+    return true;
+}
+
+export { areDeclarationsEqual as default };

package/dist/utils/define-visitors.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+function defineVisitors({ context, settings }, visitNode) {
+    const isFnNode = (node)=>{
+        let calleeName = '';
+        const calleeNode = node.callee || node.tag;
+        if (calleeNode.type === 'Identifier') {
+            calleeName = calleeNode.name;
+        }
+        if (calleeNode.type === 'MemberExpression') {
+            calleeName = `${calleeNode.object.name}.${calleeNode.property.name}`;
+        }
+        return new RegExp(settings.calleeMatching).test(calleeName);
+    };
+    const CallExpression = function(node) {
+        if (!isFnNode(node)) {
+            return;
+        }
+        node.arguments.forEach((arg)=>{
+            visitNode(node, arg);
+        });
+    };
+    const classMatchingRegex = new RegExp(settings.classMatching);
+    const scriptVisitor = {
+        CallExpression,
+        JSXAttribute: function(node) {
+            if (!node.name || !classMatchingRegex.test(node.name.name)) return;
+            if (node.value && node.value.type === 'Literal') {
+                visitNode(node);
+            } else if (node.value && node.value.type === 'JSXExpressionContainer') {
+                visitNode(node, node.value.expression);
+            }
+        },
+        SvelteAttribute: function(node) {
+            if (!node.key?.name || !classMatchingRegex.test(node.key.name)) return;
+            for (const eachValue of node.value){
+                visitNode(node, eachValue);
+            }
+        },
+        TextAttribute: function(node) {
+            if (!node.name || !classMatchingRegex.test(node.name)) return;
+            visitNode(node);
+        },
+        TaggedTemplateExpression: function(node) {
+            if (isFnNode(node)) {
+                visitNode(node, node.quasi);
+                return;
+            }
+        }
+    };
+    const templateBodyVisitor = {
+        CallExpression,
+        VAttribute: function(node) {
+            if (node.value && node.value.type === 'VLiteral') {
+                visitNode(node);
+            } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ArrayExpression') {
+                node.value.expression.elements.forEach((arg)=>{
+                    visitNode(node, arg);
+                });
+            } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ObjectExpression') {
+                node.value.expression.properties.forEach((prop)=>{
+                    visitNode(node, prop);
+                });
+            }
+        }
+    };
+    if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) {
+        return scriptVisitor;
+    } else {
+        return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+    }
+}
+
+module.exports = defineVisitors;

package/dist/utils/define-visitors.mjs

@@ -1 +1,72 @@
-function f({context:a,settings:l},r){const n=e=>{let t="";const s=e.callee||e.tag;return s.type==="Identifier"&&(t=s.name),s.type==="MemberExpression"&&(t=`${s.object.name}.${s.property.name}`),new RegExp(l.calleeMatching).test(t)},u=function(e){n(e)&&e.arguments.forEach(t=>{r(e,t)})},i=new RegExp(l.classMatching),p={CallExpression:u,JSXAttribute:function(e){!e.name||!i.test(e.name.name)||(e.value&&e.value.type==="Literal"?r(e):e.value&&e.value.type==="JSXExpressionContainer"&&r(e,e.value.expression))},SvelteAttribute:function(e){if(!(!e.key?.name||!i.test(e.key.name)))for(const t of e.value)r(e,t)},TextAttribute:function(e){!e.name||!i.test(e.name)||r(e)},TaggedTemplateExpression:function(e){if(n(e)){r(e,e.quasi);return}}},c={CallExpression:u,VAttribute:function(e){e.value&&e.value.type==="VLiteral"?r(e):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ArrayExpression"?e.value.expression.elements.forEach(t=>{r(e,t)}):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ObjectExpression"&&e.value.expression.properties.forEach(t=>{r(e,t)})}};return a.sourceCode.parserServices==null||a.sourceCode.parserServices.defineTemplateBodyVisitor==null?p:a.sourceCode.parserServices.defineTemplateBodyVisitor(c,p)}export{f as default};
+function defineVisitors({ context, settings }, visitNode) {
+    const isFnNode = (node)=>{
+        let calleeName = '';
+        const calleeNode = node.callee || node.tag;
+        if (calleeNode.type === 'Identifier') {
+            calleeName = calleeNode.name;
+        }
+        if (calleeNode.type === 'MemberExpression') {
+            calleeName = `${calleeNode.object.name}.${calleeNode.property.name}`;
+        }
+        return new RegExp(settings.calleeMatching).test(calleeName);
+    };
+    const CallExpression = function(node) {
+        if (!isFnNode(node)) {
+            return;
+        }
+        node.arguments.forEach((arg)=>{
+            visitNode(node, arg);
+        });
+    };
+    const classMatchingRegex = new RegExp(settings.classMatching);
+    const scriptVisitor = {
+        CallExpression,
+        JSXAttribute: function(node) {
+            if (!node.name || !classMatchingRegex.test(node.name.name)) return;
+            if (node.value && node.value.type === 'Literal') {
+                visitNode(node);
+            } else if (node.value && node.value.type === 'JSXExpressionContainer') {
+                visitNode(node, node.value.expression);
+            }
+        },
+        SvelteAttribute: function(node) {
+            if (!node.key?.name || !classMatchingRegex.test(node.key.name)) return;
+            for (const eachValue of node.value){
+                visitNode(node, eachValue);
+            }
+        },
+        TextAttribute: function(node) {
+            if (!node.name || !classMatchingRegex.test(node.name)) return;
+            visitNode(node);
+        },
+        TaggedTemplateExpression: function(node) {
+            if (isFnNode(node)) {
+                visitNode(node, node.quasi);
+                return;
+            }
+        }
+    };
+    const templateBodyVisitor = {
+        CallExpression,
+        VAttribute: function(node) {
+            if (node.value && node.value.type === 'VLiteral') {
+                visitNode(node);
+            } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ArrayExpression') {
+                node.value.expression.elements.forEach((arg)=>{
+                    visitNode(node, arg);
+                });
+            } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ObjectExpression') {
+                node.value.expression.properties.forEach((prop)=>{
+                    visitNode(node, prop);
+                });
+            }
+        }
+    };
+    if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) {
+        return scriptVisitor;
+    } else {
+        return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+    }
+}
+
+export { defineVisitors as default };

package/dist/utils/extract-classnames-from-value.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const separatorRegEx = /([\t\n\f\r ]+)/;
+function extractClassnamesFromValue(classStr) {
+    if (typeof classStr !== 'string') {
+        return {
+            classNames: [],
+            whitespaces: [],
+            headSpace: false,
+            tailSpace: false
+        };
+    }
+    const parts = classStr.split(separatorRegEx);
+    if (parts[0] === '') {
+        parts.shift();
+    }
+    if (parts[parts.length - 1] === '') {
+        parts.pop();
+    }
+    const headSpace = separatorRegEx.test(parts[0]);
+    const tailSpace = separatorRegEx.test(parts[parts.length - 1]);
+    const isClass = (_, i)=>headSpace ? i % 2 !== 0 : i % 2 === 0;
+    const isNotClass = (_, i)=>headSpace ? i % 2 === 0 : i % 2 !== 0;
+    const classNames = parts.filter(isClass);
+    const whitespaces = parts.filter(isNotClass);
+    return {
+        classNames: classNames,
+        whitespaces: whitespaces,
+        headSpace: headSpace,
+        tailSpace: tailSpace
+    };
+}
+
+module.exports = extractClassnamesFromValue;