@master/eslint-plugin-css 2.0.0-beta.186 → 2.0.0-beta.187

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+var f=Object.create;var t=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var n=Object.getPrototypeOf,s=Object.prototype.hasOwnProperty;var u=(o,p,r,m)=>{if(p&&typeof p=="object"||typeof p=="function")for(let i of l(p))!s.call(o,i)&&i!==r&&t(o,i,{get:()=>p[i],enumerable:!(m=g(p,i))||m.enumerable});return o};var x=(o,p,r)=>(r=o!=null?f(n(o)):{},u(p||!o||!o.__esModule?t(r,"default",{value:o,enumerable:!0}):r,o));var e=x(require("./plugin"));module.exports=e.default;

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+declare const plugin: {
+    rules: {
+        'class-collision': import("eslint").Rule.RuleModule;
+        'class-order': import("eslint").Rule.RuleModule;
+        'class-validation': import("eslint").Rule.RuleModule;
+    };
+};
+export default plugin;

package/dist/plugin.js

@@ -0,0 +1 @@
+var e=Object.create;var r=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var u=Object.getPrototypeOf,g=Object.prototype.hasOwnProperty;var v=(s,l)=>{for(var o in l)r(s,o,{get:l[o],enumerable:!0})},t=(s,l,o,c)=>{if(l&&typeof l=="object"||typeof l=="function")for(let i of f(l))!g.call(s,i)&&i!==o&&r(s,i,{get:()=>l[i],enumerable:!(c=p(l,i))||c.enumerable});return s};var a=(s,l,o)=>(o=s!=null?e(u(s)):{},t(l||!s||!s.__esModule?r(o,"default",{value:s,enumerable:!0}):o,s)),x=s=>t(r({},"__esModule",{value:!0}),s);var V={};v(V,{default:()=>O});module.exports=x(V);var m=a(require("./rules/class-collision")),n=a(require("./rules/class-order")),d=a(require("./rules/class-validation"));const C={rules:{"class-collision":m.default,"class-order":n.default,"class-validation":d.default}};var O=C;

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

@@ -0,0 +1,3 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;

package/dist/rules/class-collision.js

@@ -0,0 +1 @@
+var M=Object.create;var f=Object.defineProperty;var N=Object.getOwnPropertyDescriptor;var V=Object.getOwnPropertyNames;var q=Object.getPrototypeOf,A=Object.prototype.hasOwnProperty;var D=(e,o)=>{for(var s in o)f(e,s,{get:o[s],enumerable:!0})},R=(e,o,s,c)=>{if(o&&typeof o=="object"||typeof o=="function")for(let l of V(o))!A.call(e,l)&&l!==s&&f(e,l,{get:()=>o[l],enumerable:!(c=N(o,l))||c.enumerable});return e};var m=(e,o,s)=>(s=e!=null?M(q(e)):{},R(o||!e||!e.__esModule?f(s,"default",{value:e,enumerable:!0}):s,e)),K=e=>R(f({},"__esModule",{value:!0}),e);var U={};D(U,{default:()=>O});module.exports=K(U);var S=m(require("../utils/ast")),$=m(require("../utils/are-declarations-equal")),v=m(require("../utils/define-visitors")),x=m(require("../utils/resolve-context")),y=require("@master/css-validator"),O={meta:{docs:{description:"Avoid applying classes with the same CSS declaration",category:"Stylistic Issues",recommended:!1,url:"https://beta.css.master.co/docs/code-linting#class-collision-detection"},messages:{collisionClass:"{{message}}"},fixable:"code"},create(e){const{options:o,settings:s,config:c}=(0,x.default)(e);return(0,v.default)({context:e,options:o,settings:s,config:c},(E,L=null)=>{S.parseNodeRecursive(E,L,(n,C,T,b,j)=>{const k=e.sourceCode.lines,w=C.loc.start.line,I=C.loc.end.line,p={};console.log(n),n.forEach(i=>{p[i]=(0,y.createValidRules)(i,{config:c})[0]});for(let i=0;i<n.length;i++){const u=n[i],g=p[u],d=[];if(g)for(let a=0;a<n.length;a++){const r=n[a],t=p[r];i!==a&&t&&(0,$.default)(g.declarations,t.declarations)&&g.stateToken===t.stateToken&&d.push(r)}if(d.length>0){const a=d.map(t=>`"${t}"`).join(" and ");let r=T;for(const t of d){const h=t.replace(/(\\|\.|\(|\)|\[|\]|\{|\}|\+|\*|\?|\^|\$|\||\/)/g,"\\$1");r=r.replace(new RegExp(`\\s+${h}|${h}\\s+`),"")}e.report({loc:S.findLoc(u,k,w,I),messageId:"collisionClass",data:{message:`"${u}" applies the same CSS declarations as ${a}.`},fix:function(t){return t.replaceTextRange([b,j],r)}})}}},!1,!1,s.ignoredKeys,e)})}};

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

@@ -0,0 +1,3 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;

package/dist/rules/class-order.js

@@ -0,0 +1 @@
+var $=Object.create;var y=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var O=Object.getPrototypeOf,P=Object.prototype.hasOwnProperty;var q=(e,a)=>{for(var n in a)y(e,n,{get:a[n],enumerable:!0})},T=(e,a,n,C)=>{if(a&&typeof a=="object"||typeof a=="function")for(let r of I(a))!P.call(e,r)&&r!==n&&y(e,r,{get:()=>a[r],enumerable:!(C=F(a,r))||C.enumerable});return e};var N=(e,a,n)=>(n=e!=null?$(O(e)):{},T(a||!e||!e.__esModule?y(n,"default",{value:e,enumerable:!0}):n,e)),A=e=>T(y({},"__esModule",{value:!0}),e);var U={};q(U,{default:()=>B});module.exports=A(U);var m=N(require("../utils/ast")),V=N(require("../utils/define-visitors")),R=N(require("../utils/resolve-context")),S=require("@master/css"),B={meta:{docs:{description:"Enforce a consistent and logical order of classes",category:"Stylistic Issues",recommended:!1,url:"https://beta.css.master.co/docs/code-linting#consistent-class-order"},messages:{invalidClassOrder:"No consistent class order followed."},fixable:"code"},create:function(e){const{options:a,settings:n,config:C}=(0,R.default)(e),r=(l,s=null)=>{let i=null,p=null,d=null,E="",v="";if(s===null){i=m.extractValueFromNode(l);const t=m.extractRangeFromNode(l);l.type==="TextAttribute"?(p=t[0],d=t[1]):(p=t[0]+1,d=t[1]-1)}else switch(s.type){case"Identifier":return;case"TemplateLiteral":s.expressions.forEach(o=>{r(l,o)}),s.quasis.forEach(o=>{r(l,o)});return;case"ConditionalExpression":r(l,s.consequent),r(l,s.alternate);return;case"LogicalExpression":r(l,s.right);return;case"ArrayExpression":s.elements.forEach(o=>{r(l,o)});return;case"ObjectExpression":const t=l.callee&&l.callee.name==="classnames",x=l.key&&l.key.type==="VDirectiveKey";s.properties.forEach(o=>{const b=t||x?o.key:o.value;r(l,b)});return;case"Property":r(l,s.key);break;case"Literal":i=s.value,p=s.range[0]+1,d=s.range[1]-1;break;case"SvelteLiteral":if(i=s.value,i==="")return;p=s.range[0],d=s.range[1];break;case"TemplateElement":if(i=s.value.raw,i==="")return;p=s.range[0],d=s.range[1];const c=e.sourceCode.getText(s);E=m.getTemplateElementPrefix(c,i),v=m.getTemplateElementSuffix(c,i),i=m.getTemplateElementBody(c,E,v);break}const{classNames:h,whitespaces:g,headSpace:k,tailSpace:L}=m.extractClassnamesFromValue(i);if(h.length<=1)return;let f=(0,S.reorderForReadableClasses)(h,C).filter(t=>h.includes(t));f=h.filter(t=>!f.includes(t)).concat(f).filter(t=>t.trim()!=="");let u="";for(let t=0;t<f.length;t++){const x=g[t]??"",c=f[t];u+=k?`${x}${c}`:`${c}${x}`,c&&(!L&&t===f.length-1&&(u=u.replace(/\s+$/,"")),k&&L&&t===f.length-1&&(u+=g[g.length-1]??""))}if(i!==u){u=E+u+v;const x=e.sourceCode.lines,c=l.loc.start.line,o=l.loc.end.line,b={loc:m.findLoc(i,x,c,o),messageId:"invalidClassOrder",fix:function(w){return w.replaceTextRange([p,d],u)}};e.report(b)}};return(0,V.default)({context:e,options:a,settings:n,config:C},r)}};

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

@@ -0,0 +1,3 @@
+import { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;

package/dist/rules/class-validation.js

@@ -0,0 +1 @@
+var N=Object.create;var n=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var U=Object.getPrototypeOf,I=Object.prototype.hasOwnProperty;var b=(s,e)=>{for(var o in e)n(s,o,{get:e[o],enumerable:!0})},g=(s,e,o,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of S(e))!I.call(s,r)&&r!==o&&n(s,r,{get:()=>e[r],enumerable:!(a=R(e,r))||a.enumerable});return s};var l=(s,e,o)=>(o=s!=null?N(U(s)):{},g(e||!s||!s.__esModule?n(o,"default",{value:s,enumerable:!0}):o,s)),M=s=>g(n({},"__esModule",{value:!0}),s);var E={};b(E,{default:()=>D});module.exports=M(E);var t=l(require("../utils/ast")),p=l(require("../utils/define-visitors")),C=l(require("../utils/resolve-context")),w=require("@master/css-validator"),D={meta:{docs:{description:"Detect syntax errors early when writing classes",category:"Stylistic Issues",recommended:!1,url:"https://beta.css.master.co/docs/code-linting#syntax-error-checks"},messages:{invalidClass:"{{message}}",disallowUnknownClass:"{{message}}"},fixable:null},create:function(s){const{options:e,settings:o,config:a}=(0,C.default)(s);return(0,p.default)({context:s,options:e,settings:o,config:a},(v,y=null)=>{t.parseNodeRecursive(v,y,(k,c)=>{const d=s.sourceCode.lines,m=c.loc.start.line,f=c.loc.end.line;for(const i of k){const{isMasterCSS:L,errors:u}=(0,w.validate)(i,{config:a});if(u.length>0)for(const h of u)L?s.report({loc:t.findLoc(i,d,m,f),messageId:"invalidClass",data:{message:h.message+"."}}):e.disallowUnknownClass&&s.report({loc:t.findLoc(i,d,m,f),messageId:"disallowUnknownClass",data:{message:`"${i}" is not a valid or known class.`}})}},!1,!1,o.ignoredKeys,s)})}};

package/dist/settings.d.ts

@@ -0,0 +1,7 @@
+declare const settings: {
+    calleeMatching: string;
+    classMatching: string;
+    ignoredKeys: string[];
+    config: string;
+};
+export default settings;

package/dist/settings.js

@@ -0,0 +1 @@
+var e=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var o=Object.prototype.hasOwnProperty;var r=(a,s)=>{for(var t in s)e(a,t,{get:s[t],enumerable:!0})},d=(a,s,t,l)=>{if(s&&typeof s=="object"||typeof s=="function")for(let c of i(s))!o.call(a,c)&&c!==t&&e(a,c,{get:()=>s[c],enumerable:!(l=n(s,c))||l.enumerable});return a};var g=a=>d(e({},"__esModule",{value:!0}),a);var u={};r(u,{default:()=>f});module.exports=g(u);const m={calleeMatching:"^(classnames|clsx|ctl|cva|cv|classVariant|styled(?:\\.\\w+)?)",classMatching:"^class(Name)?$",ignoredKeys:["compoundVariants","defaultVariants"],config:"master.css.*"};var f=m;

package/dist/utils/are-declarations-equal.d.ts

@@ -0,0 +1 @@
+export default function areDeclarationsEqual(aDeclarations: any, bDeclarations: any): boolean;

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

@@ -0,0 +1 @@
+var s=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var u=(t,e)=>{for(var r in e)s(t,r,{get:e[r],enumerable:!0})},y=(t,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of f(e))!l.call(t,n)&&n!==r&&s(t,n,{get:()=>e[n],enumerable:!(o=c(e,n))||o.enumerable});return t};var p=t=>y(s({},"__esModule",{value:!0}),t);var O={};u(O,{default:()=>a});module.exports=p(O);function a(t,e){const r=Object.keys(t),o=Object.keys(e);if(r.length!==o.length)return!1;for(const n of r)if(!Object.prototype.hasOwnProperty.call(e,n))return!1;return!0}

package/dist/utils/ast.d.ts

@@ -0,0 +1,31 @@
+import { Rule } from 'eslint';
+export declare function extractRangeFromNode(node: any): any;
+export declare function extractValueFromNode(node: any): any;
+export declare function extractClassnamesFromValue(classStr: any): {
+    classNames: string[];
+    whitespaces: string[];
+    headSpace: boolean;
+    tailSpace: boolean;
+};
+/**
+ * Inspect and parse an abstract syntax node and run a callback function
+ *
+ * @param {ASTNode} rootNode The current root node being parsed by eslint
+ * @param {ASTNode} childNode The AST node child argument being checked
+ * @param {Function} cb The callback function
+ * @param {Boolean} skipConditional Optional, indicate distinct parsing for conditional nodes
+ * @param {Boolean} isolate Optional, set internally to isolate parsing and validation on conditional children
+ * @param {Array} ignoredKeys Optional, set object keys which should not be parsed e.g. for `cva`
+ * @returns {void}
+ */
+export declare function parseNodeRecursive(rootNode: any, childNode: any, cb: any, skipConditional?: boolean, isolate?: boolean, ignoredKeys?: any[], context?: Rule.RuleContext): void;
+export declare function getTemplateElementPrefix(text: any, raw: any): any;
+export declare function getTemplateElementSuffix(text: any, raw: any): any;
+export declare function getTemplateElementBody(text: any, prefix: any, suffix: any): any;
+export declare function findLoc(text: any, lines: any, startLine: any, endLine: any): {
+    start: any;
+    end: {
+        line: any;
+        column: any;
+    };
+};

package/dist/utils/ast.js

@@ -0,0 +1 @@
+var E=Object.defineProperty;var O=Object.getOwnPropertyDescriptor;var j=Object.getOwnPropertyNames;var V=Object.prototype.hasOwnProperty;var F=(e,t)=>{for(var r in t)E(e,r,{get:t[r],enumerable:!0})},P=(e,t,r,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of j(t))!V.call(e,u)&&u!==r&&E(e,u,{get:()=>t[u],enumerable:!(s=O(t,u))||s.enumerable});return e};var q=e=>P(E({},"__esModule",{value:!0}),e);var J={};F(J,{extractClassnamesFromValue:()=>y,extractRangeFromNode:()=>L,extractValueFromNode:()=>w,findLoc:()=>I,getTemplateElementBody:()=>B,getTemplateElementPrefix:()=>h,getTemplateElementSuffix:()=>R,parseNodeRecursive:()=>x});module.exports=q(J);const S=/([\t\n\f\r ]+)/;function L(e){if(e.type==="TextAttribute"&&e.name==="class")return[e.valueSpan.fullStart.offset,e.valueSpan.end.offset];switch(e.value.type){case"JSXExpressionContainer":return e.value.expression.range;default:return e.value.range}}function w(e){if(e.type==="TextAttribute"&&e.name==="class")return e.value;switch(e.value.type){case"JSXExpressionContainer":return e.value.expression.value;case"VExpressionContainer":switch(e.value.expression.type){case"ArrayExpression":return e.value.expression.elements;case"ObjectExpression":return e.value.expression.properties}return e.value.expression.value;default:return e.value.value}}function y(e){if(typeof e!="string")return{classNames:[],whitespaces:[],headSpace:!1,tailSpace:!1};const t=e.split(S);t[0]===""&&t.shift(),t[t.length-1]===""&&t.pop();const r=S.test(t[0]),s=S.test(t[t.length-1]),u=(a,f)=>r?f%2!==0:f%2===0,n=(a,f)=>r?f%2===0:f%2!==0,m=t.filter(u),l=t.filter(n);return{classNames:m,whitespaces:l,headSpace:r,tailSpace:s}}function x(e,t,r,s=!1,u=!1,n=[],m=null){let l,a,f=null,i=null,g="",v="";if(t===null){if(l=w(e),{classNames:a}=y(l),a=[...new Set(a)],a.length===0)return;const c=L(e);e.type==="TextAttribute"?(f=c[0],i=c[1]):(f=c[0]+1,i=c[1]-1),r(a,e,l,f,i,g,v)}else{if(t===void 0)return;{const c=s?!0:u;let A=!1;switch(t.type){case"TemplateLiteral":t.expressions.forEach(p=>{x(e,p,r,s,c,n)}),t.quasis.forEach(p=>{x(e,p,r,s,u,n)});return;case"ConditionalExpression":x(e,t.consequent,r,s,c,n),x(e,t.alternate,r,s,c,n);return;case"LogicalExpression":x(e,t.right,r,s,c,n);return;case"ArrayExpression":t.elements.forEach(p=>{x(e,p,r,s,c,n)});return;case"ObjectExpression":t.properties.forEach(p=>{const C=e.callee&&e.callee.name==="classnames";p.type!=="SpreadElement"&&(p.key.type==="Identifier"&&n.includes(p.key.name)||x(e,C?p.key:p.value,r,s,c,n))});return;case"Property":x(e,t.key,r,s,c,n);return;case"Literal":A=!0,l=t.value,f=t.range[0]+1,i=t.range[1]-1;break;case"SvelteLiteral":l=t.value,f=t.range[0],i=t.range[1];break;case"TemplateElement":l=t.value.raw,f=t.range[0],i=t.range[1];const T=m?.sourceCode.getText(t)??"";g=h(T,l),v=R(T,l);break}if({classNames:a}=y(l),a=[...new Set(a)],a.length===0)return;r(a,u?null:e,l,f,i,g,v)}}}function h(e,t){return e.indexOf(t)===0?"":e.split(t).shift()}function R(e,t){return e.indexOf(t)===-1?"":e.split(t).pop()}function B(e,t,r){let s=e.split(t);return s.shift(),s=s.join(t).split(r),s.pop(),s.join(r)}function I(e,t,r,s){const u=e.match(/.+(?:\r\n|\n)?/g);let n=0,m=null,l=!1;for(let a=r;a<=s;a++){const i=t[a-1].indexOf(u[n].replace(/\r\n|\n/,""));if(i!==-1){if(n===0&&(m={line:a,column:i}),n===u.length-1)return{start:m,end:{line:a,column:i+e.length}};l=!0,n++}else l&&(l=!1,n=0,m=null)}return null}

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

@@ -0,0 +1,5 @@
+import { Rule } from 'eslint';
+export default function defineVisitors({ context, settings }: {
+    context: Rule.RuleContext;
+    settings: any;
+}, visitNode: any): any;

package/dist/utils/define-visitors.js

@@ -0,0 +1 @@
+var p=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var E=(s,r)=>{for(var t in r)p(s,t,{get:r[t],enumerable:!0})},v=(s,r,t,l)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of o(r))!x.call(s,i)&&i!==t&&p(s,i,{get:()=>r[i],enumerable:!(l=m(r,i))||l.enumerable});return s};var g=s=>v(p({},"__esModule",{value:!0}),s);var V={};E(V,{default:()=>f});module.exports=g(V);function f({context:s,settings:r},t){const l=e=>{let a="";const n=e.callee||e.tag;return n.type==="Identifier"&&(a=n.name),n.type==="MemberExpression"&&(a=`${n.object.name}.${n.property.name}`),new RegExp(r.calleeMatching).test(a)},i=function(e){l(e)&&e.arguments.forEach(a=>{t(e,a)})},u=new RegExp(r.classMatching),c={CallExpression:i,JSXAttribute:function(e){!e.name||!u.test(e.name.name)||(e.value&&e.value.type==="Literal"?t(e):e.value&&e.value.type==="JSXExpressionContainer"&&t(e,e.value.expression))},SvelteAttribute:function(e){if(!(!e.key?.name||!u.test(e.key.name)))for(const a of e.value)t(e,a)},TextAttribute:function(e){!e.name||!u.test(e.name)||t(e)},TaggedTemplateExpression:function(e){if(l(e)){t(e,e.quasi);return}}},y={CallExpression:i,VAttribute:function(e){e.value&&e.value.type==="VLiteral"?t(e):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ArrayExpression"?e.value.expression.elements.forEach(a=>{t(e,a)}):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ObjectExpression"&&e.value.expression.properties.forEach(a=>{t(e,a)})}};return s.sourceCode.parserServices==null||s.sourceCode.parserServices.defineTemplateBodyVisitor==null?c:s.sourceCode.parserServices.defineTemplateBodyVisitor(y,c)}

package/dist/utils/resolve-context.d.ts

@@ -0,0 +1,5 @@
+export default function resolveContext(context: any): {
+    settings: any;
+    options: any;
+    config: any;
+};

package/dist/utils/resolve-context.js

@@ -0,0 +1 @@
+var m=Object.create;var n=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var u=Object.getPrototypeOf,b=Object.prototype.hasOwnProperty;var d=(o,t)=>{for(var s in t)n(o,s,{get:t[s],enumerable:!0})},r=(o,t,s,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of a(t))!b.call(o,e)&&e!==s&&n(o,e,{get:()=>t[e],enumerable:!(i=l(t,e))||i.enumerable});return o};var f=(o,t,s)=>(s=o!=null?m(u(o)):{},r(t||!o||!o.__esModule?n(s,"default",{value:o,enumerable:!0}):s,o)),j=o=>r(n({},"__esModule",{value:!0}),o);var v={};d(v,{default:()=>p});module.exports=j(v);var g=f(require("../settings")),c=f(require("explore-config"));function p(o){const t=Object.assign(g.default,o.settings?.["@master/css"]),s=t?.config;return{settings:t,options:o.options[0]||{},config:typeof s=="object"?s:(0,c.default)(t?.config||"")}}

package/package.json

@@ -1 +1 @@
-{"name":"@master/eslint-plugin-css","scripts":{"test":"mocha tests --recursive --timeout 10000","test:file":"mocha tests"},"keywords":["mastercss","eslint","eslintplugin"],"license":"MIT","description":"Master CSS ESLint Plugin","author":"Aoyue Design LLC.","funding":"https://css.master.co/docs/donate","homepage":"https://css.master.co","bugs":{"url":"https://github.com/master-co/css/issues"},"repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/eslint-plugin"},"sideEffects":false,"main":"./lib/index.js","exports":"./lib/index.js","publishConfig":{"access":"public"},"dependencies":{"@master/css":"^2.0.0-beta.186","@master/css-validator":"^2.0.0-beta.186","explore-config":"^2.2.10","requireindex":"^1.2.0"},"devDependencies":{"@angular-eslint/template-parser":"^16.2.0","@types/node":"^20.6.0","@typescript-eslint/parser":"^5.50.0","eslint":"^7.1.0","mocha":"^10.2.0","svelte-eslint-parser":"^0.33.1","vue-eslint-parser":"^9.3.1"},"version":"2.0.0-beta.186"}
+{"name":"@master/eslint-plugin-css","scripts":{"build":"techor pack 'src/**/*.ts' --format cjs","dev":"pnpm run build --watch --no-declare","test":"jest","type-check":"tsc --noEmit","lint":"eslint src"},"keywords":["mastercss","eslint","eslintplugin"],"license":"MIT","description":"Master CSS ESLint Plugin","author":"Aoyue Design LLC.","funding":"https://css.master.co/docs/donate","homepage":"https://css.master.co","bugs":{"url":"https://github.com/master-co/css/issues"},"repository":{"type":"git","url":"https://github.com/master-co/css.git","directory":"packages/eslint-plugin"},"sideEffects":false,"main":"./dist/index.js","types":"./dist/index.d.ts","exports":"./dist/index.js","files":["dist"],"publishConfig":{"access":"public"},"dependencies":{"@master/css":"^2.0.0-beta.187","@master/css-validator":"^2.0.0-beta.187","explore-config":"^2.2.10"},"devDependencies":{"@angular-eslint/template-parser":"^16.2.0","@types/node":"^20.6.0","@typescript-eslint/parser":"^5.50.0","@typescript-eslint/utils":"^6.9.0","eslint":"^8.0.0","svelte-eslint-parser":"^0.33.1","vue-eslint-parser":"^9.3.1"},"version":"2.0.0-beta.187"}

package/lib/index.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const requireIndex = require('requireindex')
-
-module.exports.rules = requireIndex(__dirname + '/rules')

package/lib/rules/class-order.js

@@ -1,202 +0,0 @@
-'use strict'
-
-const astUtil = require('../utils/ast')
-const resolveContext = require('../utils/resolve-context')
-const { reorderForReadableClasses } = require('@master/css')
-
-module.exports = {
-    meta: {
-        docs: {
-            description: 'Enforce a consistent and logical order of classes',
-            category: 'Stylistic Issues',
-            recommended: false,
-            url: 'https://beta.css.master.co/docs/code-linting#enforce-a-consistent-and-logical-order-of-classes',
-        },
-        messages: {
-            invalidClassOrder: 'No consistent class order followed.',
-        },
-        fixable: 'code'
-    },
-    create: function (context) {
-        const { options, settings, config } = resolveContext(context)
-        const sortNodeArgumentValue = (node, arg = null) => {
-            let originalClassNamesValue = null
-            let start = null
-            let end = null
-            let prefix = ''
-            let suffix = ''
-            if (arg === null) {
-                originalClassNamesValue = astUtil.extractValueFromNode(node)
-                const range = astUtil.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) => {
-                            sortNodeArgumentValue(node, exp)
-                        })
-                        arg.quasis.forEach((quasis) => {
-                            sortNodeArgumentValue(node, quasis)
-                        })
-                        return
-                    case 'ConditionalExpression':
-                        sortNodeArgumentValue(node, arg.consequent)
-                        sortNodeArgumentValue(node, arg.alternate)
-                        return
-                    case 'LogicalExpression':
-                        sortNodeArgumentValue(node, arg.right)
-                        return
-                    case 'ArrayExpression':
-                        arg.elements.forEach((el) => {
-                            sortNodeArgumentValue(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
-                            sortNodeArgumentValue(node, propVal)
-                        })
-                        return
-                    case 'Property':
-                        sortNodeArgumentValue(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.getSourceCode().getText(arg)
-                        prefix = astUtil.getTemplateElementPrefix(txt, originalClassNamesValue)
-                        suffix = astUtil.getTemplateElementSuffix(txt, originalClassNamesValue)
-                        originalClassNamesValue = astUtil.getTemplateElementBody(txt, prefix, suffix)
-                        break
-                }
-            }
-
-            let { classNames, whitespaces, headSpace, tailSpace } =
-                astUtil.extractClassnamesFromValue(originalClassNamesValue)
-
-            if (classNames.length <= 1) {
-                // Don't run sorting for a single or empty className
-                return
-            }
-
-            let orderedClassNames = reorderForReadableClasses(classNames, config)
-                .filter(eachOrderedClassName => classNames.includes(eachOrderedClassName))
-
-            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 (headSpace && tailSpace && i === orderedClassNames.length - 1) {
-                    validatedClassNamesValue += whitespaces[whitespaces.length - 1] ?? ''
-                }
-            }
-
-            if (originalClassNamesValue !== validatedClassNamesValue) {
-                validatedClassNamesValue = prefix + validatedClassNamesValue + suffix
-                context.report({
-                    node: node,
-                    messageId: 'invalidClassOrder',
-                    fix: function (fixer) {
-                        return fixer.replaceTextRange([start, end], validatedClassNamesValue)
-                    },
-                })
-            }
-        }
-
-        const callExpressionVisitor = function (node) {
-            const calleeStr = astUtil.calleeToString(node.callee)
-            if (settings.callees.findIndex((name) => calleeStr === name) === -1) {
-                return
-            }
-
-            node.arguments.forEach((arg) => {
-                sortNodeArgumentValue(node, arg)
-            })
-        }
-
-        const scriptVisitor = {
-            CallExpression: callExpressionVisitor,
-            JSXAttribute: function (node) {
-                if (!node.name || !new RegExp(settings.classMatching).test(node.name.name)) return
-                if (node.value && node.value.type === 'Literal') {
-                    sortNodeArgumentValue(node)
-                } else if (node.value && node.value.type === 'JSXExpressionContainer') {
-                    sortNodeArgumentValue(node, node.value.expression)
-                }
-            },
-            SvelteAttribute: function (node) {
-                if (!node.key?.name || !new RegExp(settings.classMatching).test(node.key.name)) return
-                for (const eachValue of node.value) {
-                    sortNodeArgumentValue(node, eachValue)
-                }
-            },
-            TextAttribute: function (node) {
-                if (!node.name || !new RegExp(settings.classMatching).test(node.name)) return
-                sortNodeArgumentValue(node)
-            },
-            TaggedTemplateExpression: function (node) {
-                if (!settings.tags.includes(node.tag.name)) {
-                    return
-                }
-                sortNodeArgumentValue(node, node.quasi)
-            },
-        }
-        const templateBodyVisitor = {
-            CallExpression: callExpressionVisitor,
-            VAttribute: function (node) {
-                if (node.value && node.value.type === 'VLiteral') {
-                    sortNodeArgumentValue(node)
-                } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ArrayExpression') {
-                    node.value.expression.elements.forEach((arg) => {
-                        sortNodeArgumentValue(node, arg)
-                    })
-                } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ObjectExpression') {
-                    sortNodeArgumentValue(node, prop)
-                }
-            },
-        }
-
-        if (context.parserServices == null || context.parserServices.defineTemplateBodyVisitor == null) {
-            return scriptVisitor
-        } else {
-            return context.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor)
-        }
-    },
-}

package/lib/rules/class-validation.js

@@ -1,123 +0,0 @@
-'use strict'
-
-const astUtil = require('../utils/ast')
-const resolveContext = require('../utils/resolve-context')
-const { validate } = require('@master/css-validator')
-
-module.exports = {
-    meta: {
-        docs: {
-            description: 'Check the validity of classes with your configuration',
-            category: 'Stylistic Issues',
-            recommended: false,
-            url: 'https://beta.css.master.co/docs/code-linting#check-the-validity-of-classes-with-your-configuration',
-        },
-        messages: {
-            invalidClass: '{{message}}',
-            disallowTraditionalClass: '{{message}}',
-        },
-        fixable: null
-    },
-    create: function (context) {
-        const { options, settings, config } = resolveContext(context)
-        const checkNodeArgumentValue = (node, arg = null) => {
-            astUtil.parseNodeRecursive(
-                node,
-                arg,
-                (classNames, node) => {
-                    const sourceCode = context.getSourceCode()
-                    const sourceCodeLines = sourceCode.lines
-                    const nodeStartLine = node.loc.start.line
-                    const nodeEndLine = node.loc.end.line
-                    for (const className of classNames) {
-                        const { isMasterCSS, errors } = validate(className, { config })
-                        if (errors.length > 0) {
-                            for (const error of errors) {
-                                if (isMasterCSS) {
-                                    context.report({
-                                        loc: astUtil.findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
-                                        messageId: 'invalidClass',
-                                        data: {
-                                            message: error.message + '.',
-                                        }
-                                    })
-                                } else if (!isMasterCSS && options.disallowTraditionalClass) {
-                                    context.report({
-                                        loc: astUtil.findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
-                                        messageId: 'disallowTraditionalClass',
-                                        data: {
-                                            message: `Disallow a traditional class \`${className}\`.`,
-                                        }
-                                    })
-                                }
-                            }
-                        }
-                    }
-                },
-                false,
-                false,
-                settings.ignoredKeys
-            )
-        }
-
-        const callExpressionVisitor = function (node) {
-            const calleeStr = astUtil.calleeToString(node.callee)
-            if (settings.callees.findIndex((name) => calleeStr === name) === -1) {
-                return
-            }
-
-            node.arguments.forEach((arg) => {
-                checkNodeArgumentValue(node, arg)
-            })
-        }
-
-        const scriptVisitor = {
-            CallExpression: callExpressionVisitor,
-            JSXAttribute: function (node) {
-                if (!node.name || !new RegExp(settings.classMatching).test(node.name.name)) return
-                if (node.value && node.value.type === 'Literal') {
-                    checkNodeArgumentValue(node)
-                } else if (node.value && node.value.type === 'JSXExpressionContainer') {
-                    checkNodeArgumentValue(node, node.value.expression)
-                }
-            },
-            SvelteAttribute: function (node) {
-                if (!node.key?.name || !new RegExp(settings.classMatching).test(node.key.name)) return
-                for (const eachValue of node.value) {
-                    checkNodeArgumentValue(node, eachValue)
-                }
-            },
-            TextAttribute: function (node) {
-                if (!node.name || !new RegExp(settings.classMatching).test(node.name)) return
-                checkNodeArgumentValue(node)
-            },
-            TaggedTemplateExpression: function (node) {
-                if (!settings.tags.includes(node.tag.name)) {
-                    return
-                }
-                checkNodeArgumentValue(node, node.quasi)
-            },
-        }
-
-        const templateBodyVisitor = {
-            CallExpression: callExpressionVisitor,
-            VAttribute: function (node) {
-                if (node.value && node.value.type === 'VLiteral') {
-                    checkNodeArgumentValue(node)
-                } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ArrayExpression') {
-                    node.value.expression.elements.forEach((arg) => {
-                        checkNodeArgumentValue(node, arg)
-                    })
-                } else if (node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ObjectExpression') {
-                    checkNodeArgumentValue(node, prop)
-                }
-            },
-        }
-
-        if (context.parserServices == null || context.parserServices.defineTemplateBodyVisitor == null) {
-            return scriptVisitor
-        } else {
-            return context.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor)
-        }
-    },
-}

package/lib/utils/ast.js

@@ -1,218 +0,0 @@
-'use strict'
-
-const separatorRegEx = /([\t\n\f\r ]+)/
-
-function calleeToString(calleeNode) {
-    if (calleeNode.type === 'Identifier') {
-        return calleeNode.name
-    }
-    if (calleeNode.type === 'MemberExpression') {
-        return `${calleeNode.object.name}.${calleeNode.property.name}`
-    }
-}
-
-function extractRangeFromNode(node) {
-    if (node.type === 'TextAttribute' && node.name === 'class') {
-        return [node.valueSpan.fullStart.offset, node.valueSpan.end.offset]
-    }
-    switch (node.value.type) {
-        case 'JSXExpressionContainer':
-            return node.value.expression.range
-        default:
-            return node.value.range
-    }
-}
-
-function extractValueFromNode(node) {
-    if (node.type === 'TextAttribute' && node.name === 'class') {
-        return node.value
-    }
-    switch (node.value.type) {
-        case 'JSXExpressionContainer':
-            return node.value.expression.value
-        case 'VExpressionContainer':
-            switch (node.value.expression.type) {
-                case 'ArrayExpression':
-                    return node.value.expression.elements
-                case 'ObjectExpression':
-                    return node.value.expression.properties
-            }
-            return node.value.expression.value
-        default:
-            return node.value.value
-    }
-}
-
-function extractClassnamesFromValue(classStr) {
-    if (typeof classStr !== 'string') {
-        return { classNames: [], whitespaces: [], headSpace: false, tailSpace: false }
-    }
-    let parts = classStr.split(separatorRegEx)
-    if (parts[0] === '') {
-        parts.shift()
-    }
-    if (parts[parts.length - 1] === '') {
-        parts.pop()
-    }
-    let headSpace = separatorRegEx.test(parts[0])
-    let 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)
-    let classNames = parts.filter(isClass)
-    let whitespaces = parts.filter(isNotClass)
-    return { classNames: classNames, whitespaces: whitespaces, headSpace: headSpace, tailSpace: tailSpace }
-}
-
-
-/**
- * Inspect and parse an abstract syntax node and run a callback function
- *
- * @param {ASTNode} rootNode The current root node being parsed by eslint
- * @param {ASTNode} childNode The AST node child argument being checked
- * @param {Function} cb The callback function
- * @param {Boolean} skipConditional Optional, indicate distinct parsing for conditional nodes
- * @param {Boolean} isolate Optional, set internally to isolate parsing and validation on conditional children
- * @param {Array} ignoredKeys Optional, set object keys which should not be parsed e.g. for `cva`
- * @returns {void}
- */
-function parseNodeRecursive(rootNode, childNode, cb, skipConditional = false, isolate = false, ignoredKeys = []) {
-    // TODO allow vue non litteral
-    let originalClassNamesValue
-    let classNames
-    if (childNode === null) {
-        originalClassNamesValue = extractValueFromNode(rootNode);
-        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue))
-        classNames = [... new Set(classNames)]
-        if (classNames.length === 0) {
-            // Don't run for empty className
-            return
-        }
-        cb(classNames, rootNode)
-    } else if (childNode === undefined) {
-        // Ignore invalid child candidates (probably inside complex TemplateLiteral)
-        return
-    } else {
-        const forceIsolation = skipConditional ? true : isolate
-        let trim = false
-        switch (childNode.type) {
-            case 'TemplateLiteral':
-                childNode.expressions.forEach((exp) => {
-                    parseNodeRecursive(rootNode, exp, cb, skipConditional, forceIsolation, ignoredKeys)
-                })
-                childNode.quasis.forEach((quasis) => {
-                    parseNodeRecursive(rootNode, quasis, cb, skipConditional, isolate, ignoredKeys)
-                })
-                return
-            case 'ConditionalExpression':
-                parseNodeRecursive(rootNode, childNode.consequent, cb, skipConditional, forceIsolation, ignoredKeys)
-                parseNodeRecursive(rootNode, childNode.alternate, cb, skipConditional, forceIsolation, ignoredKeys)
-                return
-            case 'LogicalExpression':
-                parseNodeRecursive(rootNode, childNode.right, cb, skipConditional, forceIsolation, ignoredKeys)
-                return
-            case 'ArrayExpression':
-                childNode.elements.forEach((el) => {
-                    parseNodeRecursive(rootNode, el, cb, skipConditional, forceIsolation, ignoredKeys)
-                })
-                return
-            case 'ObjectExpression':
-                childNode.properties.forEach((prop) => {
-                    const isUsedByClassNamesPlugin = rootNode.callee && rootNode.callee.name === 'classnames'
-
-                    if (prop.type === 'SpreadElement') {
-                        // Ignore spread elements
-                        return
-                    }
-
-                    if (prop.key.type === 'Identifier' && ignoredKeys.includes(prop.key.name)) {
-                        // Ignore specific keys defined in settings
-                        return
-                    }
-
-                    parseNodeRecursive(
-                        rootNode,
-                        isUsedByClassNamesPlugin ? prop.key : prop.value,
-                        cb,
-                        skipConditional,
-                        forceIsolation,
-                        ignoredKeys
-                    )
-                })
-                return
-            case 'Property':
-                parseNodeRecursive(rootNode, childNode.key, cb, skipConditional, forceIsolation, ignoredKeys)
-                return
-            case 'Literal':
-                trim = true
-                originalClassNamesValue = childNode.value
-                break
-            case 'TemplateElement':
-                originalClassNamesValue = childNode.value.raw
-                break
-        }
-        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue))
-        classNames = removeDuplicatesFromArray(classNames)
-        if (classNames.length === 0) {
-            // Don't run for empty className
-            return
-        }
-        const targetNode = isolate ? null : rootNode
-        cb(classNames, targetNode)
-    }
-}
-
-function getTemplateElementPrefix(text, raw) {
-    const idx = text.indexOf(raw)
-    if (idx === 0) {
-        return ''
-    }
-    return text.split(raw).shift()
-}
-
-function getTemplateElementSuffix(text, raw) {
-    if (text.indexOf(raw) === -1) {
-        return ''
-    }
-    return text.split(raw).pop()
-}
-
-function getTemplateElementBody(text, prefix, suffix) {
-    let arr = text.split(prefix)
-    arr.shift()
-    let body = arr.join(prefix)
-    arr = body.split(suffix)
-    arr.pop()
-    return arr.join(suffix)
-}
-
-function findLoc(text, lines, startLine, endLine) {
-    for (let i = startLine; i <= endLine; i++) {
-        const sourceCodeLine = lines[i - 1]
-        const index = sourceCodeLine.indexOf(text)
-        if (index !== -1) {
-            return {
-                start: {
-                    line: i,
-                    column: index
-                },
-                end: {
-                    line: i,
-                    column: index + text.length
-                }
-            }
-        }
-    }
-    return null
-}
-
-module.exports = {
-    calleeToString,
-    extractRangeFromNode,
-    extractValueFromNode,
-    extractClassnamesFromValue,
-    getTemplateElementPrefix,
-    getTemplateElementSuffix,
-    getTemplateElementBody,
-    parseNodeRecursive,
-    findLoc
-}

package/lib/utils/resolve-context.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const exploreConfig = require('explore-config').default
-
-const resolveContext = function (context) {
-    const settings = Object.assign({
-        callees: ['classnames', 'clsx', 'ctl', 'cva', 'cv', 'classVariant', 'styled'],
-        ignoredKeys: ['compoundVariants', 'defaultVariants'],
-        classMatching: '^class(Name)?$',
-        config: 'master.css.*',
-        tags: []
-    }, context.settings?.['@master/css'])
-    const config = settings?.config
-    return {
-        settings,
-        options: context.options[0] || {},
-        config: typeof config === 'object' ? config : exploreConfig(settings?.config || '')
-    }
-}
-
-module.exports = resolveContext

package/tests/frameworks/react.js

@@ -1,55 +0,0 @@
-'use strict'
-
-const rule = require('../../lib/rules/class-order')
-const RuleTester = require('eslint').RuleTester
-const ruleTester = new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    }
-})
-
-ruleTester.run('class order', rule, {
-    valid: [
-        { code: '<h1 className={"bg:black fg:white f:24 m:8 p:8"}>Welcome {name}</h1>' }
-    ],
-    invalid: [
-        {
-            code: `
-                    export interface FakePropsInterface {
-                        readonly name?: string;
-                    }
-                    function Fake({
-                        name = 'yolo'
-                    }: FakeProps) {
-                        return (
-                        <>
-                            <h1 className={"m:8 bg:black p:8 fg:white f:24"}>Welcome {name}</h1>
-                            <p>Bye {name}</p>
-                        </>
-                        );
-                    }
-                    export default Fake;
-                `,
-            output: `
-                    export interface FakePropsInterface {
-                        readonly name?: string;
-                    }
-                    function Fake({
-                        name = 'yolo'
-                    }: FakeProps) {
-                        return (
-                        <>
-                            <h1 className={"bg:black fg:white f:24 m:8 p:8"}>Welcome {name}</h1>
-                            <p>Bye {name}</p>
-                        </>
-                        );
-                    }
-                    export default Fake;
-                `,
-            parser: require.resolve('@typescript-eslint/parser'),
-            errors: [{ messageId: 'invalidClassOrder' }],
-        },
-    ]
-})

package/tests/frameworks/svelte.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const rule = require('../../lib/rules/class-order')
-const RuleTester = require('eslint').RuleTester
-const ruleTester = new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    }
-})
-
-ruleTester.run('svelte class order', rule, {
-    valid: [{ code: `<div class="bg:black fg:white f:24 m:8 p:8">Simple, basic</div>` }],
-    invalid: [
-        {
-            code: `<div class="m:8 bg:black p:8 fg:white f:24 {flipped ? 'flipped' : ''}">Enhancing readability</div>`,
-            output: `<div class="bg:black fg:white f:24 m:8 p:8 {flipped ? 'flipped' : ''}">Enhancing readability</div>`,
-            errors: [{ messageId: 'invalidClassOrder' }],
-            filename: 'test.svelte',
-            parser: require.resolve('svelte-eslint-parser'),
-        },
-    ],
-})

package/tests/frameworks/vue.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const rule = require('../../lib/rules/class-order')
-const RuleTester = require('eslint').RuleTester
-const ruleTester = new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        }
-    }
-})
-
-ruleTester.run('vue class order', rule, {
-    valid: [{ code: `<div class="bg:black fg:white f:24 m:8 p:8">Simple, basic</div>` }],
-    invalid: [
-        {
-            code: `<template><div class="m:8 bg:black p:8 fg:white f:24">Enhancing readability</div></template>`,
-            output: `<template><div class="bg:black fg:white f:24 m:8 p:8">Enhancing readability</div></template>`,
-            errors: [{ messageId: 'invalidClassOrder' }],
-            filename: 'test.vue',
-            parser: require.resolve('vue-eslint-parser'),
-        },
-    ],
-})

package/tests/order.js

@@ -1,66 +0,0 @@
-'use strict'
-
-const rule = require('../lib/rules/class-order')
-const RuleTester = require('eslint').RuleTester
-const ruleTester = new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    }
-})
-
-ruleTester.run('class order', rule, {
-    valid: [
-        {
-            code: `<div class="bg:black fg:white f:24 m:8 p:8">Simple, basic</div>`,
-        },
-        {
-            code: `<div class="card mt:20">Traditional class + syntax</div>`,
-        },
-        {
-            code: `<div test="bg:black fg:white f:24 m:8 p:8">Simple, using 'test' prop</div>`,
-            options: [
-                {
-                    classMatching: '^test$',
-                },
-            ],
-        },
-    ],
-    invalid: [
-        {
-            code: `<div class="fg:white f:24 m:8 p:8 bg:black">Classnames will be ordered</div>`,
-            output: `<div class="bg:black fg:white f:24 m:8 p:8">Classnames will be ordered</div>`,
-            errors: [{ messageId: 'invalidClassOrder' }],
-        },
-        {
-            code: `
-                    <div class="
-                        m:8
-                        bg:black
-                        p:8
-                        fg:white
-                        f:24
-                    ">
-                        :)
-                    </div>`,
-            output: `
-                    <div class="
-                        bg:black
-                        fg:white
-                        f:24
-                        m:8
-                        p:8
-                    ">
-                        :)
-                    </div>`,
-            errors: [{ messageId: 'invalidClassOrder' }],
-            parser: require.resolve('@angular-eslint/template-parser'),
-        },
-        {
-            code: `<div class="flex uppercase m:0 m:0>li text-decoration:none>li>a px:4>li align-items:baseline fg:gray-30>li>a gap-x:28 font:12 font:semibold pb:6>li pt:20 pt:10>li {bb:3|solid|black}>li:has(>.router-link-active) {fg:black}>li:has(>.router-link-active)>a fg:gray-10>li>a:hover box-shadow:none>li>a:focus">Group</div>`,
-            output: `<div class="flex uppercase align-items:baseline box-shadow:none>li>a:focus fg:gray-30>li>a fg:gray-10>li>a:hover gap-x:28 font:12 font:semibold {bb:3|solid|black}>li:has(>.router-link-active) {fg:black}>li:has(>.router-link-active)>a m:0 m:0>li pb:6>li pt:20 pt:10>li px:4>li text-decoration:none>li>a">Group</div>`,
-            errors: [{ messageId: 'invalidClassOrder' }],
-        }
-    ],
-})

package/tests/validation.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const rule = require('../lib/rules/class-validation')
-const RuleTester = require('eslint').RuleTester
-
-new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    }
-}).run('invalid', rule, {
-    valid: [
-        {
-            code: `<div class="bg:black fg:white f:24 m:8 p:8">Simple, basic</div>`,
-        }
-    ],
-    invalid: [
-        {
-            code: `<div class="bg:black m:mistake rrr">Simple, basic</div>`,
-            errors: [
-                { messageId: 'invalidClass' },
-                { messageId: 'disallowTraditionalClass' }
-            ],
-            options: [
-                {
-                    disallowTraditionalClass: true
-                }
-            ]
-        },
-        {
-            code: `<div class="bg:black m:mistake rrr">Simple, basic</div>`,
-            errors: [
-                { messageId: 'invalidClass' },
-            ]
-        }
-    ]
-})
-
-new RuleTester({
-    parserOptions: {
-        ecmaFeatures: {
-            jsx: true,
-        },
-    },
-    settings: {
-        '@master/css': {
-            config: {
-                styles: { btn: 'block' }
-            }
-        }
-    }
-}).run('invalid', rule, {
-    valid: [],
-    invalid: [
-        {
-            code: `<div class="bg:black m:mistake rrr btn">Simple, basic</div>`,
-            errors: [
-                { messageId: 'invalidClass' },
-                { messageId: 'disallowTraditionalClass' }
-            ],
-            options: [
-                {
-                    disallowTraditionalClass: true
-                }
-            ]
-        },
-    ],
-})