@master/eslint-plugin-css 2.0.0-beta.185 → 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.185","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.185"}
+{"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,19 +0,0 @@
-/**
- * @fileoverview Rules enforcing best practices while using Master CSS
- * @author Miles
- */
-'use strict'
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const requireIndex = require('requireindex')
-
-//------------------------------------------------------------------------------
-// Plugin Definition
-//------------------------------------------------------------------------------
-
-
-// import all rules in lib/rules
-module.exports.rules = requireIndex(__dirname + '/rules')

package/lib/rules/class-order.js

@@ -1,282 +0,0 @@
-/* eslint-disable no-case-declarations */
-/**
- * @fileoverview Use a consistent orders for the Master CSS classnames, based on property then on variants
- * @author Miles
- */
-'use strict'
-
-// Modified from https://github.com/francoismassart/eslint-plugin-tailwindcss
-
-const astUtil = require('../util/ast')
-const removeDuplicatesFromClassnamesAndWhitespaces = require('../util/removeDuplicatesFromClassnamesAndWhitespaces')
-const getOption = require('../util/settings')
-const parserUtil = require('../util/parser')
-
-const { reorderForReadableClasses } = require('@master/css')
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-// Predefine message for use in context.report conditional.
-// messageId will still be usable in tests.
-const INVALID_CLASSNAMES_ORDER_MSG = 'No consistent class order followed.'
-
-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: {
-            invalidOrder: INVALID_CLASSNAMES_ORDER_MSG,
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    callees: {
-                        type: 'array',
-                        items: { type: 'string', minLength: 0 },
-                        uniqueItems: true,
-                    },
-                    ignoredKeys: {
-                        type: 'array',
-                        items: { type: 'string', minLength: 0 },
-                        uniqueItems: true,
-                    },
-                    config: {
-                        // returned from `loadConfig()` utility
-                        type: ['string', 'object'],
-                    },
-                    removeDuplicates: {
-                        // default: true,
-                        type: 'boolean',
-                    },
-                    tags: {
-                        type: 'array',
-                        items: { type: 'string', minLength: 0 },
-                        uniqueItems: true,
-                    },
-                },
-            },
-        ],
-    },
-
-    create: function (context) {
-        const callees = getOption(context, 'callees')
-        const skipClassAttribute = getOption(context, 'skipClassAttribute')
-        const tags = getOption(context, 'tags')
-        const masterCssConfig = getOption(context, 'config')
-        const classRegex = getOption(context, 'classRegex')
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-        /**
-         * Recursive function crawling into child nodes
-         * @param {ASTNode} node The root node of the current parsing
-         * @param {ASTNode} arg The child node of node
-         * @returns {void}
-         */
-        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, masterCssConfig)
-                .filter(eachOrderedClassName => classNames.includes(eachOrderedClassName))
-
-            orderedClassNames = orderedClassNames.concat(classNames.filter(x => !orderedClassNames.includes(x)))
-
-            removeDuplicatesFromClassnamesAndWhitespaces(orderedClassNames, whitespaces, headSpace, tailSpace)
-
-            // 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: 'invalidOrder',
-                    fix: function (fixer) {
-                        return fixer.replaceTextRange([start, end], validatedClassNamesValue)
-                    },
-                })
-            }
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        const attributeVisitor = function (node) {
-            if (!astUtil.isClassAttribute(node, classRegex) || skipClassAttribute) {
-                return
-            }
-            if (astUtil.isLiteralAttributeValue(node)) {
-                sortNodeArgumentValue(node)
-            } else if (node.value && node.value.type === 'JSXExpressionContainer') {
-                sortNodeArgumentValue(node, node.value.expression)
-            }
-        }
-
-        const callExpressionVisitor = function (node) {
-            const calleeStr = astUtil.calleeToString(node.callee)
-            if (callees.findIndex((name) => calleeStr === name) === -1) {
-                return
-            }
-
-            node.arguments.forEach((arg) => {
-                sortNodeArgumentValue(node, arg)
-            })
-        }
-
-        const scriptVisitor = {
-            JSXAttribute: attributeVisitor,
-            SvelteAttribute: function (node) {
-                if (!node.key?.name) return
-                if (!new RegExp(classRegex).test(node.key.name) || skipClassAttribute) {
-                    return
-                }
-                for (const eachValue of node.value) {
-                    sortNodeArgumentValue(node, eachValue)
-                }
-            },
-            TextAttribute: attributeVisitor,
-            CallExpression: callExpressionVisitor,
-            TaggedTemplateExpression: function (node) {
-                if (!tags.includes(node.tag.name)) {
-                    return
-                }
-
-                sortNodeArgumentValue(node, node.quasi)
-            },
-        }
-        const templateVisitor = {
-            CallExpression: callExpressionVisitor,
-            /*
-            Tagged templates inside data bindings
-            https://github.com/vuejs/vue/issues/9721
-            */
-            VAttribute: function (node) {
-                switch (true) {
-                    case !astUtil.isValidVueAttribute(node, classRegex):
-                        return
-                    case astUtil.isVLiteralValue(node):
-                        sortNodeArgumentValue(node, null)
-                        break
-                    case astUtil.isArrayExpression(node):
-                        node.value.expression.elements.forEach((arg) => {
-                            sortNodeArgumentValue(node, arg)
-                        })
-                        break
-                    case astUtil.isObjectExpression(node):
-                        node.value.expression.properties.forEach((prop) => {
-                            sortNodeArgumentValue(node, prop)
-                        })
-                        break
-                }
-            },
-        }
-
-        return parserUtil.defineTemplateBodyVisitor(context, templateVisitor, scriptVisitor)
-    },
-}

package/lib/util/ast.js

@@ -1,370 +0,0 @@
-/**
- * @fileoverview Utility functions for AST
- */
-
-'use strict'
-
-const { separatorRegEx } = require('./regex')
-// context.parserPath
-// /.../eslint-plugin-tailwindcss/node_modules/espree/espree.js
-// /.../eslint-plugin-tailwindcss/node_modules/@angular-eslint/template-parser/dist/index.js
-
-const removeDuplicatesFromArray = require('./removeDuplicatesFromArray')
-
-function calleeToString(calleeNode) {
-  if (calleeNode.type === 'Identifier') {
-    return calleeNode.name
-  }
-  if (calleeNode.type === 'MemberExpression') {
-    return `${calleeNode.object.name}.${calleeNode.property.name}`
-  }
-}
-
-/**
- * Find out if node is `class` or `className`
- *
- * @param {ASTNode} node The AST node being checked
- * @param {String} classRegex Regex to test the attribute that is being checked against
- * @returns {Boolean}
- */
-function isClassAttribute(node, classRegex) {
-  if (!node.name) {
-    return false
-  }
-  let name = ''
-  switch (node.type) {
-    case 'TextAttribute':
-      name = node.name
-      break
-    default:
-      name = node.name.name
-  }
-  return new RegExp(classRegex).test(name)
-}
-
-/**
- * Find out if node is `class`
- *
- * @param {ASTNode} node The AST node being checked
- * @param {String} classRegex Regex to test the attribute that is being checked against
- * @returns {Boolean}
- */
-function isVueClassAttribute(node, classRegex) {
-  const re = new RegExp(classRegex)
-  let name = ''
-  switch (true) {
-    case node.key && node.key.name && re.test(node.key.name):
-      // class="vue-classes-as-litteral"
-      return true
-    case node.key &&
-      node.key.name &&
-      node.key.name.name &&
-      node.key.argument &&
-      node.key.argument.name &&
-      /^bind$/.test(node.key.name.name) &&
-      re.test(node.key.argument.name):
-      // v-bind:class="vue-classes-as-bind"
-      // :class="vue-classes-as-bind"
-      return true
-    default:
-      return false
-  }
-}
-
-/**
- * Find out if node's value attribute is just simple text
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {Boolean}
- */
-function isVLiteralValue(node) {
-  return node.value && node.value.type === 'VLiteral'
-}
-
-/**
- * Find out if node's value attribute is an ArrayExpression
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {Boolean}
- */
-function isArrayExpression(node) {
-  return node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ArrayExpression'
-}
-
-/**
- * Find out if node's value attribute is an ObjectExpression
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {Boolean}
- */
-function isObjectExpression(node) {
-  return node.value && node.value.type === 'VExpressionContainer' && node.value.expression.type === 'ObjectExpression'
-}
-
-/**
- * Find out if node's value attribute is just simple text
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {Boolean}
- */
-function isVueValidAttributeValue(node) {
-  switch (true) {
-    case isVLiteralValue(node): // Simple string
-    case isArrayExpression(node): // ['tw-unknown-class']
-    case isObjectExpression(node): // {'tw-unknown-class': true}
-      return true
-    default:
-      return false
-  }
-}
-
-/**
- * Find out if node's value attribute is just simple text
- *
- * @param {ASTNode} node The AST node being checked
- * @returns {Boolean}
- */
-function isLiteralAttributeValue(node) {
-  if (node.type === 'TextAttribute' && node.name === 'class' && typeof node.value === 'string') {
-    return true
-  }
-  if (node.value) {
-    switch (node.value.type) {
-      case 'Literal':
-        return true
-      case 'JSXExpressionContainer':
-        // className={"..."}
-        return node.value.expression.type === 'Literal'
-    }
-  }
-  return false
-}
-
-/**
- * Find out if the node is a valid candidate for our rules
- *
- * @param {ASTNode} node The AST node being checked
- * @param {String} classRegex Regex to test the attribute that is being checked against
- * @returns {Boolean}
- */
-function isValidJSXAttribute(node, classRegex) {
-  if (!isClassAttribute(node, classRegex)) {
-    // Only run for class[Name] attributes
-    return false
-  }
-  if (!isLiteralAttributeValue(node)) {
-    // No support for dynamic or conditional classnames
-    return false
-  }
-  return true
-}
-
-/**
- * Find out if the node is a valid candidate for our rules
- *
- * @param {ASTNode} node The AST node being checked
- * @param {String} classRegex Regex to test the attribute that is being checked against
- * @returns {Boolean}
- */
-function isValidVueAttribute(node, classRegex) {
-  if (!isVueClassAttribute(node, classRegex)) {
-    // Only run for class attributes
-    return false
-  }
-  if (!isVueValidAttributeValue(node)) {
-    // No support for dynamic or conditional classnames
-    return false
-  }
-  return true
-}
-
-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 = removeDuplicatesFromArray(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)
-}
-
-module.exports = {
-  calleeToString,
-  extractRangeFromNode,
-  extractValueFromNode,
-  extractClassnamesFromValue,
-  isClassAttribute,
-  isLiteralAttributeValue,
-  isArrayExpression,
-  isObjectExpression,
-  isValidJSXAttribute,
-  isValidVueAttribute,
-  isVLiteralValue,
-  parseNodeRecursive,
-  getTemplateElementPrefix,
-  getTemplateElementSuffix,
-  getTemplateElementBody,
-}

package/lib/util/parser.js

@@ -1,21 +0,0 @@
-/**
- * @see parserServices https://eslint.org/docs/developer-guide/working-with-rules#the-context-object
- * @param {Object} context
- * @param {Function} templateBodyVisitor
- * @param {Function} scriptVisitor
- * @returns
- */
-function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor) {
-  if (context.parserServices == null || context.parserServices.defineTemplateBodyVisitor == null) {
-    // Default parser
-    return scriptVisitor
-  }
-
-  // Using "vue-eslint-parser" requires this setup
-  // @see https://eslint.org/docs/developer-guide/working-with-rules#the-context-object
-  return context.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor)
-}
-
-module.exports = {
-  defineTemplateBodyVisitor,
-}

package/lib/util/regex.js

@@ -1,16 +0,0 @@
-/**
- * Escapes a string to be used in a regular expression
- * Copied from https://stackoverflow.com/a/3561711.
- * @param {string} input
- * @returns {string}
- */
-function escapeRegex(input) {
-  return input.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&')
-}
-
-const separatorRegEx = /([\t\n\f\r ]+)/
-
-module.exports = {
-  escapeRegex,
-  separatorRegEx,
-}

package/lib/util/removeDuplicatesFromArray.js

@@ -1,7 +0,0 @@
-'use strict'
-
-function removeDuplicatesFromArray(arr) {
-  return [...new Set(arr)]
-}
-
-module.exports = removeDuplicatesFromArray

package/lib/util/removeDuplicatesFromClassnamesAndWhitespaces.js

@@ -1,18 +0,0 @@
-'use strict'
-
-function removeDuplicatesFromClassnamesAndWhitespaces(orderedClassNames, whitespaces, headSpace, tailSpace) {
-  let previous = orderedClassNames[0]
-  const offset = (!headSpace && !tailSpace) || tailSpace ? -1 : 0
-  for (let i = 1; i < orderedClassNames.length; i++) {
-    const cls = orderedClassNames[i]
-    // This function assumes that the list of classNames is ordered, so just comparing to the previous className is enough
-    if (cls === previous) {
-      orderedClassNames.splice(i, 1)
-      whitespaces.splice(i + offset, 1)
-      i--
-    }
-    previous = cls
-  }
-}
-
-module.exports = removeDuplicatesFromClassnamesAndWhitespaces

package/lib/util/settings.js

@@ -1,39 +0,0 @@
-'use strict'
-const exploreConfig = require('explore-config').default
-
-function getOption(context, name) {
-    // Options (defined at rule level)
-    const options = context.options[0] || {}
-    if (options[name] != undefined) {
-        return options[name]
-    }
-    // Settings (defined at plugin level, shared accross rules)
-    if (context.settings && context.settings.mastercss && context.settings.mastercss[name] != undefined) {
-        return context.settings.mastercss[name]
-    }
-    // Fallback to defaults
-    switch (name) {
-        case 'callees':
-            return ['classnames', 'clsx', 'ctl', 'cva']
-        case 'ignoredKeys':
-            return ['compoundVariants', 'defaultVariants']
-        case 'classRegex':
-            return '^class(Name)?$'
-        case 'config':
-            return exploreConfig('master.css.*', {})
-        case 'cssFiles':
-            return ['**/*.css', '!**/node_modules', '!**/.*', '!**/dist', '!**/build']
-        case 'cssFilesRefreshRate':
-            return 5_000
-        case 'removeDuplicates':
-            return true
-        case 'skipClassAttribute':
-            return false
-        case 'tags':
-            return []
-        case 'whitelist':
-            return []
-    }
-}
-
-module.exports = getOption

package/tests/class-order/core.js

@@ -1,112 +0,0 @@
-/**
- * @fileoverview Use a consistent orders for the Master CSS classnames, based on property then on variants
- * @author Miles
- */
-'use strict'
-
-// Modified from https://github.com/francoismassart/eslint-plugin-tailwindcss
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-var rule = require('../../lib/rules/class-order')
-var RuleTester = require('eslint').RuleTester
-var parserOptions = {
-    ecmaVersion: 2019,
-    sourceType: 'module',
-    ecmaFeatures: {
-        jsx: true,
-    },
-}
-
-var ruleTester = new RuleTester({ parserOptions })
-ruleTester.run('class order', rule, {
-    valid: [
-        {
-            code: `<div class="bg:black fg:white f:24 m:8 p:8">Simple, basic</div>`,
-        },
-        {
-            code: `<div test="bg:black fg:white f:24 m:8 p:8">Simple, using 'test' prop</div>`,
-            options: [
-                {
-                    classRegex: '^test$',
-                },
-            ],
-        },
-    ],
-    invalid: [
-        // jsx
-        {
-            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: 'invalidOrder' }],
-        },
-        {
-            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: 'invalidOrder' }],
-        },
-        // html, angular
-        {
-            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: 'invalidOrder' }],
-            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: 'invalidOrder' }],
-        }
-    ],
-})

package/tests/class-order/svelte.js

@@ -1,25 +0,0 @@
-'use strict'
-
-var rule = require('../../lib/rules/class-order')
-var RuleTester = require('eslint').RuleTester
-var parserOptions = {
-    ecmaVersion: 2019,
-    sourceType: 'module',
-    ecmaFeatures: {
-        jsx: true,
-    },
-}
-
-var ruleTester = new RuleTester({ parserOptions })
-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: 'invalidOrder' }],
-            filename: 'test.svelte',
-            parser: require.resolve('svelte-eslint-parser'),
-        },
-    ],
-})

package/tests/class-order/vue.js

@@ -1,25 +0,0 @@
-'use strict'
-
-var rule = require('../../lib/rules/class-order')
-var RuleTester = require('eslint').RuleTester
-var parserOptions = {
-    ecmaVersion: 2019,
-    sourceType: 'module',
-    ecmaFeatures: {
-        jsx: true,
-    },
-}
-
-var ruleTester = new RuleTester({ parserOptions })
-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: 'invalidOrder' }],
-            filename: 'test.vue',
-            parser: require.resolve('vue-eslint-parser'),
-        },
-    ],
-})