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

package/dist/rules/no-unapproved-raw-values.mjs

@@ -0,0 +1,75 @@
+import defineVisitors from '../utils/define-visitors.mjs';
+import resolveContext from '../utils/resolve-context.mjs';
+import createRule from '../create-rule.mjs';
+import { findUnapprovedRawValueClasses } from '@master/css-lint';
+
+var noUnapprovedRawValues = createRule({
+    name: 'no-unapproved-raw-values',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow unapproved raw values in token-backed Master CSS classes'
+        },
+        messages: {
+            unapprovedRawValue: 'Unexpected raw value "{{value}}" in "{{className}}". Use a token or allow it explicitly.'
+        },
+        fixable: null,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowRawValues: {
+                        type: 'boolean'
+                    },
+                    allowProperties: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        uniqueItems: true
+                    },
+                    allowedPatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        uniqueItems: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    defaultOptions: [
+        {
+            allowRawValues: false,
+            allowProperties: [],
+            allowedPatterns: []
+        }
+    ],
+    create (context) {
+        const { settings, css } = resolveContext(context);
+        const options = context.options[0] || {};
+        return defineVisitors({
+            context,
+            settings
+        }, (node, { classNodes, classValues })=>{
+            const issues = findUnapprovedRawValueClasses(classValues, css, options);
+            for (const issue of issues){
+                const classNode = classNodes.find((node)=>node.value === issue.className);
+                if (!classNode) continue;
+                context.report({
+                    node,
+                    loc: classNode.loc,
+                    messageId: 'unapprovedRawValue',
+                    data: {
+                        className: issue.className,
+                        value: issue.value
+                    }
+                });
+            }
+        });
+    }
+});
+
+export { noUnapprovedRawValues as default };

package/dist/rules/prefer-canonical-classes.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+var defineVisitors = require('../utils/define-visitors.cjs');
+var resolveContext = require('../utils/resolve-context.cjs');
+var createRule = require('../create-rule.cjs');
+var cssLint = require('@master/css-lint');
+
+var preferCanonicalClasses = createRule({
+    name: 'prefer-canonical-classes',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer canonical Master CSS classes'
+        },
+        messages: {
+            preferClass: 'Prefer "{{recommended}}" over "{{actual}}".'
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    preferStaticUtilities: {
+                        type: 'boolean'
+                    },
+                    preferThemeTokens: {
+                        type: 'boolean'
+                    },
+                    preferPropertyAliases: {
+                        type: 'boolean'
+                    },
+                    preferVariableReferences: {
+                        type: 'boolean'
+                    },
+                    preferMultiValueTokens: {
+                        type: 'boolean'
+                    },
+                    preferCompositionUtilities: {
+                        type: 'boolean'
+                    },
+                    preferConditionOrder: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    defaultOptions: [
+        cssLint.defaultCanonicalClassNameOptions
+    ],
+    create (context) {
+        const { settings, css } = resolveContext(context);
+        const options = {
+            ...cssLint.defaultCanonicalClassNameOptions,
+            ...context.options[0] || {}
+        };
+        return defineVisitors({
+            context,
+            settings
+        }, (node, { raw, start, end, unescape, classNodes, classValues })=>{
+            const groupSuggestions = cssLint.suggestCanonicalClassGroups(classValues, css, options);
+            const coveredClassNames = new Set(groupSuggestions.flatMap((suggestion)=>suggestion.classNames));
+            const reports = [];
+            let fixedRaw = raw;
+            for (const suggestion of groupSuggestions){
+                const firstClassNode = classNodes.find((node)=>node.value === suggestion.classNames[0]);
+                if (!firstClassNode) continue;
+                fixedRaw = cssLint.replaceClassGroupInClassList(fixedRaw, suggestion.classNames, suggestion.recommended, {
+                    unescape
+                });
+                reports.push({
+                    loc: firstClassNode.loc,
+                    actual: suggestion.classNames.join(' '),
+                    recommended: suggestion.recommended
+                });
+            }
+            for (const classNode of classNodes){
+                if (coveredClassNames.has(classNode.value)) continue;
+                const recommended = cssLint.suggestCanonicalClassName(classNode.value, css, options);
+                if (!recommended) continue;
+                fixedRaw = cssLint.replaceClassNameInClassList(fixedRaw, classNode.value, recommended, {
+                    unescape
+                });
+                reports.push({
+                    loc: classNode.loc,
+                    actual: classNode.value,
+                    recommended
+                });
+            }
+            for (const report of reports){
+                context.report({
+                    node,
+                    loc: report.loc,
+                    messageId: 'preferClass',
+                    data: {
+                        actual: report.actual,
+                        recommended: report.recommended
+                    },
+                    fix (fixer) {
+                        return fixer.replaceTextRange([
+                            start,
+                            end
+                        ], fixedRaw);
+                    }
+                });
+            }
+        });
+    }
+});
+
+module.exports = preferCanonicalClasses;

package/dist/rules/prefer-canonical-classes.d.ts

@@ -0,0 +1,5 @@
+import { type CanonicalClassNameOptions } from '@master/css-lint';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferClass", [Required<CanonicalClassNameOptions>], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/prefer-canonical-classes.mjs

@@ -0,0 +1,110 @@
+import defineVisitors from '../utils/define-visitors.mjs';
+import resolveContext from '../utils/resolve-context.mjs';
+import createRule from '../create-rule.mjs';
+import { defaultCanonicalClassNameOptions, suggestCanonicalClassGroups, replaceClassGroupInClassList, suggestCanonicalClassName, replaceClassNameInClassList } from '@master/css-lint';
+
+var preferCanonicalClasses = createRule({
+    name: 'prefer-canonical-classes',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer canonical Master CSS classes'
+        },
+        messages: {
+            preferClass: 'Prefer "{{recommended}}" over "{{actual}}".'
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    preferStaticUtilities: {
+                        type: 'boolean'
+                    },
+                    preferThemeTokens: {
+                        type: 'boolean'
+                    },
+                    preferPropertyAliases: {
+                        type: 'boolean'
+                    },
+                    preferVariableReferences: {
+                        type: 'boolean'
+                    },
+                    preferMultiValueTokens: {
+                        type: 'boolean'
+                    },
+                    preferCompositionUtilities: {
+                        type: 'boolean'
+                    },
+                    preferConditionOrder: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    defaultOptions: [
+        defaultCanonicalClassNameOptions
+    ],
+    create (context) {
+        const { settings, css } = resolveContext(context);
+        const options = {
+            ...defaultCanonicalClassNameOptions,
+            ...context.options[0] || {}
+        };
+        return defineVisitors({
+            context,
+            settings
+        }, (node, { raw, start, end, unescape, classNodes, classValues })=>{
+            const groupSuggestions = suggestCanonicalClassGroups(classValues, css, options);
+            const coveredClassNames = new Set(groupSuggestions.flatMap((suggestion)=>suggestion.classNames));
+            const reports = [];
+            let fixedRaw = raw;
+            for (const suggestion of groupSuggestions){
+                const firstClassNode = classNodes.find((node)=>node.value === suggestion.classNames[0]);
+                if (!firstClassNode) continue;
+                fixedRaw = replaceClassGroupInClassList(fixedRaw, suggestion.classNames, suggestion.recommended, {
+                    unescape
+                });
+                reports.push({
+                    loc: firstClassNode.loc,
+                    actual: suggestion.classNames.join(' '),
+                    recommended: suggestion.recommended
+                });
+            }
+            for (const classNode of classNodes){
+                if (coveredClassNames.has(classNode.value)) continue;
+                const recommended = suggestCanonicalClassName(classNode.value, css, options);
+                if (!recommended) continue;
+                fixedRaw = replaceClassNameInClassList(fixedRaw, classNode.value, recommended, {
+                    unescape
+                });
+                reports.push({
+                    loc: classNode.loc,
+                    actual: classNode.value,
+                    recommended
+                });
+            }
+            for (const report of reports){
+                context.report({
+                    node,
+                    loc: report.loc,
+                    messageId: 'preferClass',
+                    data: {
+                        actual: report.actual,
+                        recommended: report.recommended
+                    },
+                    fix (fixer) {
+                        return fixer.replaceTextRange([
+                            start,
+                            end
+                        ], fixedRaw);
+                    }
+                });
+            }
+        });
+    }
+});
+
+export { preferCanonicalClasses as default };

package/dist/rules/{class-order.cjs → sort-classes.cjs}

@@ -3,23 +3,20 @@
 var defineVisitors = require('../utils/define-visitors.cjs');
 var resolveContext = require('../utils/resolve-context.cjs');
 var createRule = require('../create-rule.cjs');
-var settingsSchema = require('../settings-schema.cjs');
-var masterCss = require('../utils/master-css.cjs');
+var cssLint = require('@master/css-lint');
 
-var classOrder = createRule({
-    name: 'consistent-class-order',
+var sortClasses = createRule({
+    name: 'sort-classes',
     meta: {
         type: 'layout',
         fixable: 'code',
         docs: {
-            description: 'Enforce a consistent and logical order of classes'
+            description: 'Sort Master CSS classes'
         },
         messages: {
             invalidClassOrder: 'No consistent class order followed.'
         },
-        schema: [
-            settingsSchema
-        ]
+        schema: []
     },
     defaultOptions: [],
     create: function(context) {
@@ -28,19 +25,11 @@ var classOrder = createRule({
         return defineVisitors({
             context,
             settings
-        }, (node, { raw, start, end, nodes, classValueRawMap, classValues })=>{
+        }, (node, { raw, start, end, nodes, unescape })=>{
             if (nodes.length <= 1) return;
-            let orderedClasses = masterCss.sortReadableClasses(classValues, css);
-            let orderedRaw = nodes.map((eachNode, i)=>{
-                if (eachNode.type === 'class') {
-                    const value = orderedClasses.shift();
-                    return classValueRawMap.get(value);
-                }
-                if (eachNode.type === 'space' && (orderedClasses.length !== 0 || i === nodes.length - 1)) {
-                    return eachNode.raw;
-                }
-                return '';
-            }).join('');
+            const orderedRaw = cssLint.sortClassList(raw, css, {
+                unescape
+            });
             if (raw !== orderedRaw) {
                 context.report({
                     node,
@@ -61,4 +50,4 @@ var classOrder = createRule({
     }
 });
 
-module.exports = classOrder;
+module.exports = sortClasses;

package/dist/rules/{class-order.mjs → sort-classes.mjs}

@@ -1,23 +1,20 @@
 import defineVisitors from '../utils/define-visitors.mjs';
 import resolveContext from '../utils/resolve-context.mjs';
 import createRule from '../create-rule.mjs';
-import settingsSchema from '../settings-schema.mjs';
-import { sortReadableClasses } from '../utils/master-css.mjs';
+import { sortClassList } from '@master/css-lint';
 
-var classOrder = createRule({
-    name: 'consistent-class-order',
+var sortClasses = createRule({
+    name: 'sort-classes',
     meta: {
         type: 'layout',
         fixable: 'code',
         docs: {
-            description: 'Enforce a consistent and logical order of classes'
+            description: 'Sort Master CSS classes'
         },
         messages: {
             invalidClassOrder: 'No consistent class order followed.'
         },
-        schema: [
-            settingsSchema
-        ]
+        schema: []
     },
     defaultOptions: [],
     create: function(context) {
@@ -26,19 +23,11 @@ var classOrder = createRule({
         return defineVisitors({
             context,
             settings
-        }, (node, { raw, start, end, nodes, classValueRawMap, classValues })=>{
+        }, (node, { raw, start, end, nodes, unescape })=>{
             if (nodes.length <= 1) return;
-            let orderedClasses = sortReadableClasses(classValues, css);
-            let orderedRaw = nodes.map((eachNode, i)=>{
-                if (eachNode.type === 'class') {
-                    const value = orderedClasses.shift();
-                    return classValueRawMap.get(value);
-                }
-                if (eachNode.type === 'space' && (orderedClasses.length !== 0 || i === nodes.length - 1)) {
-                    return eachNode.raw;
-                }
-                return '';
-            }).join('');
+            const orderedRaw = sortClassList(raw, css, {
+                unescape
+            });
             if (raw !== orderedRaw) {
                 context.report({
                     node,
@@ -59,4 +48,4 @@ var classOrder = createRule({
     }
 });
 
-export { classOrder as default };
+export { sortClasses as default };

package/dist/settings-schema.cjs

@@ -1,32 +1,38 @@
 'use strict';
 
-const settingsSchema = {
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const sourceMatcherSchema = {
+    type: 'array',
+    items: {
+        type: 'string',
+        minLength: 1
+    },
+    uniqueItems: true
+};
+const masterCSSSettingsSchema = {
     type: 'object',
     properties: {
-        classAttributes: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
-        },
-        classFunctions: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
-        },
-        ignoredKeys: {
-            type: 'array',
-            items: {
-                type: 'string',
-                minLength: 0
-            },
-            uniqueItems: true
-        },
+        classAttributes: sourceMatcherSchema,
+        classFunctions: sourceMatcherSchema,
+        classDeclarations: sourceMatcherSchema,
+        ignoredKeys: sourceMatcherSchema,
         manifest: {
             type: 'object'
         }
-    }
+    },
+    additionalProperties: false
+};
+const noInvalidClassesOptionsSchema = {
+    type: 'object',
+    properties: {
+        disallowUnknownClass: {
+            type: 'boolean'
+        }
+    },
+    additionalProperties: false
 };
 
-module.exports = settingsSchema;
+exports.default = masterCSSSettingsSchema;
+exports.masterCSSSettingsSchema = masterCSSSettingsSchema;
+exports.noInvalidClassesOptionsSchema = noInvalidClassesOptionsSchema;

package/dist/settings-schema.d.ts

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

package/dist/settings-schema.mjs

@@ -1,30 +1,32 @@
-const settingsSchema = {
+const sourceMatcherSchema = {
+    type: 'array',
+    items: {
+        type: 'string',
+        minLength: 1
+    },
+    uniqueItems: true
+};
+const masterCSSSettingsSchema = {
     type: 'object',
     properties: {
-        classAttributes: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
-        },
-        classFunctions: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
-        },
-        ignoredKeys: {
-            type: 'array',
-            items: {
-                type: 'string',
-                minLength: 0
-            },
-            uniqueItems: true
-        },
+        classAttributes: sourceMatcherSchema,
+        classFunctions: sourceMatcherSchema,
+        classDeclarations: sourceMatcherSchema,
+        ignoredKeys: sourceMatcherSchema,
         manifest: {
             type: 'object'
         }
-    }
+    },
+    additionalProperties: false
+};
+const noInvalidClassesOptionsSchema = {
+    type: 'object',
+    properties: {
+        disallowUnknownClass: {
+            type: 'boolean'
+        }
+    },
+    additionalProperties: false
 };
 
-export { settingsSchema as default };
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings.cjs

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

package/dist/settings.d.ts

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

package/dist/settings.mjs

@@ -1,13 +1,7 @@
-import { CLASS_DECLARATIONS, CLASS_FUNCTIONS, CLASS_ATTRIBUTES } from './utils/master-css.mjs';
+import { defaultClassLintSettings } from '@master/css-lint';
 
 const settings = {
-    classAttributes: CLASS_ATTRIBUTES,
-    classFunctions: CLASS_FUNCTIONS,
-    classDeclarations: CLASS_DECLARATIONS,
-    ignoredKeys: [
-        'compoundVariants',
-        'defaultVariants'
-    ],
+    ...defaultClassLintSettings,
     manifest: undefined
 };
 

package/dist/utils/define-visitors.cjs

@@ -4,7 +4,7 @@ var withVisitClassNode = require('./with-visit-class-node.cjs');
 
 function defineVisitors({ context, settings }, visitNode) {
     const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join('|')})$`);
-    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})`);
+    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})$`);
     const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join('|')})$`);
     const visitClassNode = withVisitClassNode(visitNode, context);
     const getStaticName = (node)=>{

package/dist/utils/define-visitors.mjs

@@ -2,7 +2,7 @@ import withVisitClassNode from './with-visit-class-node.mjs';
 
 function defineVisitors({ context, settings }, visitNode) {
     const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join('|')})$`);
-    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})`);
+    const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join('|')})$`);
     const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join('|')})$`);
     const visitClassNode = withVisitClassNode(visitNode, context);
     const getStaticName = (node)=>{