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

package/dist/rules/class-order.cjs

@@ -0,0 +1,64 @@
+'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 masterCss = require('../utils/master-css.cjs');
+
+var classOrder = createRule({
+    name: 'consistent-class-order',
+    meta: {
+        type: 'layout',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce a consistent and logical order of classes'
+        },
+        messages: {
+            invalidClassOrder: 'No consistent class order followed.'
+        },
+        schema: [
+            settingsSchema
+        ]
+    },
+    defaultOptions: [],
+    create: function(context) {
+        const { settings, css } = resolveContext(context);
+        const { sourceCode } = context;
+        return defineVisitors({
+            context,
+            settings
+        }, (node, { raw, start, end, nodes, classValueRawMap, classValues })=>{
+            if (nodes.length <= 1) return;
+            let orderedClasses = masterCss.sortReadableClasses(classValues, css);
+            let orderedRaw = nodes.map((eachNode, i)=>{
+                if (eachNode.type === 'class') {
+                    const value = orderedClasses.shift();
+                    return classValueRawMap.get(value);
+                }
+                if (eachNode.type === 'space' && (orderedClasses.length !== 0 || i === nodes.length - 1)) {
+                    return eachNode.raw;
+                }
+                return '';
+            }).join('');
+            if (raw !== orderedRaw) {
+                context.report({
+                    node,
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end)
+                    },
+                    messageId: 'invalidClassOrder',
+                    fix: function(fixer) {
+                        return fixer.replaceTextRange([
+                            start,
+                            end
+                        ], orderedRaw);
+                    }
+                });
+            }
+        });
+    }
+});
+
+module.exports = classOrder;

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

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

package/dist/rules/class-order.mjs

@@ -1 +1,62 @@
-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 createRule from '../create-rule.mjs';
+import settingsSchema from '../settings-schema.mjs';
+import { sortReadableClasses } from '../utils/master-css.mjs';
+
+var classOrder = createRule({
+    name: 'consistent-class-order',
+    meta: {
+        type: 'layout',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce a consistent and logical order of classes'
+        },
+        messages: {
+            invalidClassOrder: 'No consistent class order followed.'
+        },
+        schema: [
+            settingsSchema
+        ]
+    },
+    defaultOptions: [],
+    create: function(context) {
+        const { settings, css } = resolveContext(context);
+        const { sourceCode } = context;
+        return defineVisitors({
+            context,
+            settings
+        }, (node, { raw, start, end, nodes, classValueRawMap, classValues })=>{
+            if (nodes.length <= 1) return;
+            let orderedClasses = sortReadableClasses(classValues, css);
+            let orderedRaw = nodes.map((eachNode, i)=>{
+                if (eachNode.type === 'class') {
+                    const value = orderedClasses.shift();
+                    return classValueRawMap.get(value);
+                }
+                if (eachNode.type === 'space' && (orderedClasses.length !== 0 || i === nodes.length - 1)) {
+                    return eachNode.raw;
+                }
+                return '';
+            }).join('');
+            if (raw !== orderedRaw) {
+                context.report({
+                    node,
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end)
+                    },
+                    messageId: 'invalidClassOrder',
+                    fix: function(fixer) {
+                        return fixer.replaceTextRange([
+                            start,
+                            end
+                        ], orderedRaw);
+                    }
+                });
+            }
+        });
+    }
+});
+
+export { classOrder as default };

package/dist/rules/class-validation.cjs

@@ -0,0 +1,60 @@
+'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.d.ts

@@ -1,3 +1,4 @@
-import { Rule } from 'eslint';
-declare const _default: Rule.RuleModule;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
 export default _default;

package/dist/rules/class-validation.mjs

@@ -1 +1,58 @@
-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 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 };

package/dist/settings-schema.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+const settingsSchema = {
+    type: 'object',
+    properties: {
+        classAttributes: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        classFunctions: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        ignoredKeys: {
+            type: 'array',
+            items: {
+                type: 'string',
+                minLength: 0
+            },
+            uniqueItems: true
+        },
+        manifest: {
+            type: 'object'
+        }
+    }
+};
+
+module.exports = settingsSchema;

package/dist/settings-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
+declare const settingsSchema: JSONSchema4;
+export default settingsSchema;

package/dist/settings-schema.mjs

@@ -0,0 +1,30 @@
+const settingsSchema = {
+    type: 'object',
+    properties: {
+        classAttributes: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        classFunctions: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        ignoredKeys: {
+            type: 'array',
+            items: {
+                type: 'string',
+                minLength: 0
+            },
+            uniqueItems: true
+        },
+        manifest: {
+            type: 'object'
+        }
+    }
+};
+
+export { settingsSchema as default };

package/dist/settings.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var masterCss = require('./utils/master-css.cjs');
+
+const settings = {
+    classAttributes: masterCss.CLASS_ATTRIBUTES,
+    classFunctions: masterCss.CLASS_FUNCTIONS,
+    classDeclarations: masterCss.CLASS_DECLARATIONS,
+    ignoredKeys: [
+        'compoundVariants',
+        'defaultVariants'
+    ],
+    manifest: undefined
+};
+
+module.exports = settings;

package/dist/settings.d.ts

@@ -1,7 +1,16 @@
+import { type MasterCSSManifest } from './utils/master-css';
 declare const settings: {
-    calleeMatching: string;
-    classMatching: string;
+    classAttributes: string[];
+    classFunctions: string[];
+    classDeclarations: string[];
     ignoredKeys: string[];
-    config: string;
+    manifest: any;
 };
 export default settings;
+export interface Settings {
+    classAttributes?: string[];
+    classFunctions?: string[];
+    classDeclarations?: string[];
+    ignoredKeys: string[];
+    manifest?: MasterCSSManifest;
+}

package/dist/settings.mjs

@@ -1 +1,14 @@
-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};
+import { CLASS_DECLARATIONS, CLASS_FUNCTIONS, CLASS_ATTRIBUTES } from './utils/master-css.mjs';
+
+const settings = {
+    classAttributes: CLASS_ATTRIBUTES,
+    classFunctions: CLASS_FUNCTIONS,
+    classDeclarations: CLASS_DECLARATIONS,
+    ignoredKeys: [
+        'compoundVariants',
+        'defaultVariants'
+    ],
+    manifest: undefined
+};
+
+export { settings as default };

package/dist/utils/define-visitors.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+var withVisitClassNode = require('./with-visit-class-node.cjs');
+
+function defineVisitors({ context, settings }, visitNode) {
+    const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join('|')})$`);
+    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})`);
+    const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join('|')})$`);
+    const visitClassNode = withVisitClassNode(visitNode, context);
+    const getStaticName = (node)=>{
+        if (!node) return;
+        if (node.type === 'Identifier') return node.name;
+        if (node.type === 'Literal' && typeof node.value === 'string') return node.value;
+    };
+    const getMemberExpressionName = (node)=>{
+        if (!node || node.type !== 'MemberExpression') return;
+        const objectName = getStaticName(node.object);
+        const propertyName = getStaticName(node.property);
+        if (!objectName || !propertyName) return;
+        return `${objectName}.${propertyName}`;
+    };
+    const getCalleeName = (node)=>{
+        const calleeNode = node.callee || node.tag;
+        return getStaticName(calleeNode) || getMemberExpressionName(calleeNode);
+    };
+    const allowCalleeNode = (node)=>{
+        const calleeName = getCalleeName(node);
+        return calleeName ? classFunctionsRegex.test(calleeName) : false;
+    };
+    const getPropertyName = (prop)=>getStaticName(prop.key);
+    const visitUtilityDefinitions = (node)=>{
+        if (!node) return;
+        if (node.type === 'ArrayExpression') {
+            node.elements.forEach((element)=>{
+                if (!element || element.type === 'ObjectExpression') return;
+                visitClassNode(element);
+            });
+            return;
+        }
+        if (node.type !== 'ObjectExpression') {
+            visitClassNode(node);
+            return;
+        }
+    };
+    const visitClassDeclarationNode = (name, node)=>{
+        if (name !== 'utilities') {
+            visitClassNode(node);
+            return;
+        }
+        visitUtilityDefinitions(node);
+    };
+    const CallExpression = function(node) {
+        if (!allowCalleeNode(node)) return;
+        node.arguments.forEach((node)=>{
+            visitClassNode(node);
+        });
+    };
+    const scriptVisitor = {
+        CallExpression,
+        JSXAttribute: function(node) {
+            if (!node.name || !classAttributeRegex.test(node.name.name)) return;
+            if (node.value) {
+                visitClassNode(node.value);
+            }
+        },
+        SvelteAttribute: function(node) {
+            if (!node.key?.name || !classAttributeRegex.test(node.key.name)) return;
+            for (const eachValue of node.value){
+                visitClassNode(eachValue);
+            }
+        },
+        TextAttribute: function(node) {
+            if (!node.name || !classAttributeRegex.test(node.name)) return;
+            visitClassNode(node);
+        },
+        TaggedTemplateExpression: function(node) {
+            if (allowCalleeNode(node)) {
+                visitClassNode(node.quasi);
+                return;
+            }
+        },
+        VariableDeclaration: function(node) {
+            node.declarations.forEach((decl)=>{
+                if (decl.id.type === 'Identifier' && classDeclarationsRegex.test(decl.id.name)) {
+                    visitClassDeclarationNode(decl.id.name, decl.init);
+                }
+            });
+        },
+        ObjectExpression: function(node) {
+            node.properties.forEach((prop)=>{
+                if (prop.type === 'Property') {
+                    const propName = getPropertyName(prop);
+                    if (typeof propName === 'string' && classDeclarationsRegex.test(propName)) {
+                        visitClassDeclarationNode(propName, prop.value);
+                    }
+                }
+            });
+        }
+    };
+    const templateBodyVisitor = {
+        CallExpression,
+        VAttribute: function(node) {
+            const name = node.key?.argument?.name || node.key?.name;
+            if (!name || !classAttributeRegex.test(name)) return;
+            if (node.value && node.value.type === 'VLiteral') {
+                visitClassNode(node.value);
+            } else if (node.value) {
+                if (node.value.type === 'VExpressionContainer') {
+                    if (node.value.expression?.type === 'ArrayExpression' || node.value.expression?.type === 'ObjectExpression') {
+                        visitClassNode(node.value.expression);
+                    }
+                }
+            }
+        }
+    };
+    // @ts-expect-error defineTemplateBodyVisitor
+    if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) {
+        return scriptVisitor;
+    } else {
+        // @ts-expect-error defineTemplateBodyVisitor
+        return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+    }
+}
+
+module.exports = defineVisitors;

package/dist/utils/define-visitors.d.ts

@@ -1,5 +1,8 @@
-import { Rule } from 'eslint';
+import { TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext, RuleListener } from '@typescript-eslint/utils/ts-eslint';
+import { Settings } from '../settings';
+import resolveClassNode from './resolve-class-node';
 export default function defineVisitors({ context, settings }: {
-    context: Rule.RuleContext;
-    settings: any;
-}, visitNode: any): any;
+    context: RuleContext<any, any[]>;
+    settings: Settings;
+}, visitNode: (node: TSESTree.Node, resolved: ReturnType<typeof resolveClassNode>) => void): RuleListener;

package/dist/utils/define-visitors.mjs

@@ -1 +1,123 @@
-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};
+import withVisitClassNode from './with-visit-class-node.mjs';
+
+function defineVisitors({ context, settings }, visitNode) {
+    const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join('|')})$`);
+    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})`);
+    const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join('|')})$`);
+    const visitClassNode = withVisitClassNode(visitNode, context);
+    const getStaticName = (node)=>{
+        if (!node) return;
+        if (node.type === 'Identifier') return node.name;
+        if (node.type === 'Literal' && typeof node.value === 'string') return node.value;
+    };
+    const getMemberExpressionName = (node)=>{
+        if (!node || node.type !== 'MemberExpression') return;
+        const objectName = getStaticName(node.object);
+        const propertyName = getStaticName(node.property);
+        if (!objectName || !propertyName) return;
+        return `${objectName}.${propertyName}`;
+    };
+    const getCalleeName = (node)=>{
+        const calleeNode = node.callee || node.tag;
+        return getStaticName(calleeNode) || getMemberExpressionName(calleeNode);
+    };
+    const allowCalleeNode = (node)=>{
+        const calleeName = getCalleeName(node);
+        return calleeName ? classFunctionsRegex.test(calleeName) : false;
+    };
+    const getPropertyName = (prop)=>getStaticName(prop.key);
+    const visitUtilityDefinitions = (node)=>{
+        if (!node) return;
+        if (node.type === 'ArrayExpression') {
+            node.elements.forEach((element)=>{
+                if (!element || element.type === 'ObjectExpression') return;
+                visitClassNode(element);
+            });
+            return;
+        }
+        if (node.type !== 'ObjectExpression') {
+            visitClassNode(node);
+            return;
+        }
+    };
+    const visitClassDeclarationNode = (name, node)=>{
+        if (name !== 'utilities') {
+            visitClassNode(node);
+            return;
+        }
+        visitUtilityDefinitions(node);
+    };
+    const CallExpression = function(node) {
+        if (!allowCalleeNode(node)) return;
+        node.arguments.forEach((node)=>{
+            visitClassNode(node);
+        });
+    };
+    const scriptVisitor = {
+        CallExpression,
+        JSXAttribute: function(node) {
+            if (!node.name || !classAttributeRegex.test(node.name.name)) return;
+            if (node.value) {
+                visitClassNode(node.value);
+            }
+        },
+        SvelteAttribute: function(node) {
+            if (!node.key?.name || !classAttributeRegex.test(node.key.name)) return;
+            for (const eachValue of node.value){
+                visitClassNode(eachValue);
+            }
+        },
+        TextAttribute: function(node) {
+            if (!node.name || !classAttributeRegex.test(node.name)) return;
+            visitClassNode(node);
+        },
+        TaggedTemplateExpression: function(node) {
+            if (allowCalleeNode(node)) {
+                visitClassNode(node.quasi);
+                return;
+            }
+        },
+        VariableDeclaration: function(node) {
+            node.declarations.forEach((decl)=>{
+                if (decl.id.type === 'Identifier' && classDeclarationsRegex.test(decl.id.name)) {
+                    visitClassDeclarationNode(decl.id.name, decl.init);
+                }
+            });
+        },
+        ObjectExpression: function(node) {
+            node.properties.forEach((prop)=>{
+                if (prop.type === 'Property') {
+                    const propName = getPropertyName(prop);
+                    if (typeof propName === 'string' && classDeclarationsRegex.test(propName)) {
+                        visitClassDeclarationNode(propName, prop.value);
+                    }
+                }
+            });
+        }
+    };
+    const templateBodyVisitor = {
+        CallExpression,
+        VAttribute: function(node) {
+            const name = node.key?.argument?.name || node.key?.name;
+            if (!name || !classAttributeRegex.test(name)) return;
+            if (node.value && node.value.type === 'VLiteral') {
+                visitClassNode(node.value);
+            } else if (node.value) {
+                if (node.value.type === 'VExpressionContainer') {
+                    if (node.value.expression?.type === 'ArrayExpression' || node.value.expression?.type === 'ObjectExpression') {
+                        visitClassNode(node.value.expression);
+                    }
+                }
+            }
+        }
+    };
+    // @ts-expect-error defineTemplateBodyVisitor
+    if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) {
+        return scriptVisitor;
+    } else {
+        // @ts-expect-error defineTemplateBodyVisitor
+        return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+    }
+}
+
+export { defineVisitors as default };

package/dist/utils/is-same-or-child-path.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var path = require('node:path');
+
+function isSameOrChildPath(parentPath, childPath) {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || !!relativePath && relativePath !== '..' && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+
+module.exports = isSameOrChildPath;