@master/eslint-plugin-css 2.0.0-rc.73 → 2.0.0-rc.74

package/dist/index.cjs

@@ -1,19 +0,0 @@
-'use strict';
-
-var settings = require('./settings.cjs');
-var legacy = require('./configs/legacy.cjs');
-var base = require('./configs/base.cjs');
-var recommended = require('./configs/recommended.cjs');
-var plugin = require('./plugin.cjs');
-
-const masterCSSPlugin = {
-    ...plugin,
-    configs: {
-        legacy,
-        base,
-        recommended
-    },
-    settings
-};
-
-module.exports = masterCSSPlugin;

package/dist/index.mjs

@@ -1,17 +0,0 @@
-import settings from './settings.mjs';
-import legacy from './configs/legacy.mjs';
-import base from './configs/base.mjs';
-import recommended from './configs/recommended.mjs';
-import plugin from './plugin.mjs';
-
-const masterCSSPlugin = {
-    ...plugin,
-    configs: {
-        legacy,
-        base,
-        recommended
-    },
-    settings
-};
-
-export { masterCSSPlugin as default };

package/dist/plugin.cjs

@@ -1,30 +0,0 @@
-'use strict';
-
-var noConflictingClasses = require('./rules/no-conflicting-classes.cjs');
-var noInvalidClasses = require('./rules/no-invalid-classes.cjs');
-var noUnapprovedRawValues = require('./rules/no-unapproved-raw-values.cjs');
-var preferCanonicalClasses = require('./rules/prefer-canonical-classes.cjs');
-var sortClasses = require('./rules/sort-classes.cjs');
-var fs = require('fs');
-var url = require('url');
-var path = require('path');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin.cjs', document.baseURI).href)));
-const __dirname$1 = path.dirname(__filename$1);
-const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname$1, '..', 'package.json'), 'utf-8'));
-const plugin = {
-    meta: {
-        name: pkg.name,
-        version: pkg.version
-    },
-    rules: {
-        'no-conflicting-classes': noConflictingClasses,
-        'no-invalid-classes': noInvalidClasses,
-        'no-unapproved-raw-values': noUnapprovedRawValues,
-        'prefer-canonical-classes': preferCanonicalClasses,
-        'sort-classes': sortClasses
-    }
-};
-
-module.exports = plugin;

package/dist/plugin.mjs

@@ -1,27 +0,0 @@
-import noConflictingClasses from './rules/no-conflicting-classes.mjs';
-import noInvalidClasses from './rules/no-invalid-classes.mjs';
-import noUnapprovedRawValues from './rules/no-unapproved-raw-values.mjs';
-import preferCanonicalClasses from './rules/prefer-canonical-classes.mjs';
-import sortClasses from './rules/sort-classes.mjs';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = dirname(__filename$1);
-const pkg = JSON.parse(readFileSync(resolve(__dirname$1, '..', 'package.json'), 'utf-8'));
-const plugin = {
-    meta: {
-        name: pkg.name,
-        version: pkg.version
-    },
-    rules: {
-        'no-conflicting-classes': noConflictingClasses,
-        'no-invalid-classes': noInvalidClasses,
-        'no-unapproved-raw-values': noUnapprovedRawValues,
-        'prefer-canonical-classes': preferCanonicalClasses,
-        'sort-classes': sortClasses
-    }
-};
-
-export { plugin as default };

package/dist/rules/no-conflicting-classes.cjs

@@ -1,101 +0,0 @@
-'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 noConflictingClasses = createRule({
-    name: 'no-conflicting-classes',
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Disallow conflicting Master CSS classes'
-        },
-        messages: {
-            collisionClass: '{{message}}',
-            partialCollisionClass: 'Prefer "{{replacement}}" over "{{actual}}" because "{{conflict}}" overrides part of it.'
-        },
-        fixable: 'code',
-        schema: []
-    },
-    defaultOptions: [],
-    create (context) {
-        const { settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { raw, start, end, unescape, classNodes, classValues })=>{
-            const conflicts = cssLint.findClassConflicts(classValues, css);
-            if (conflicts.length) {
-                const classNamesToRemove = conflicts.map(({ className })=>className);
-                const keptClassNames = [
-                    ...new Set(conflicts.flatMap(({ conflicts })=>conflicts))
-                ];
-                const formatClassName = (className)=>`"${className}"`;
-                const formatClassList = (classNames)=>{
-                    if (classNames.length <= 2) return classNames.map(formatClassName).join(' and ');
-                    return `${classNames.slice(0, -1).map(formatClassName).join(', ')}, and ${formatClassName(classNames[classNames.length - 1])}`;
-                };
-                const fixedRaw = cssLint.removeClassNamesFromClassList(raw, classNamesToRemove, {
-                    unescape
-                });
-                const firstClassNode = classNodes.find((node)=>node.value === classNamesToRemove[0]);
-                context.report({
-                    loc: firstClassNode.loc,
-                    messageId: 'collisionClass',
-                    data: {
-                        message: `${formatClassList(classNamesToRemove)} ${classNamesToRemove.length === 1 ? 'is' : 'are'} overridden by ${formatClassList(keptClassNames)}.`
-                    },
-                    fix: function(fixer) {
-                        return fixer.replaceTextRange([
-                            start,
-                            end
-                        ], fixedRaw);
-                    }
-                });
-                return;
-            }
-            const partialConflicts = cssLint.findPartialClassConflicts(classValues, css);
-            if (!partialConflicts.length) return;
-            let fixedRaw = raw;
-            for (const conflict of partialConflicts){
-                fixedRaw = cssLint.replaceClassNameInClassList(fixedRaw, conflict.className, conflict.replacement, {
-                    unescape
-                });
-            }
-            const classNodeQueues = new Map();
-            for (const classNode of classNodes){
-                const queue = classNodeQueues.get(classNode.value);
-                if (queue) {
-                    queue.push(classNode);
-                } else {
-                    classNodeQueues.set(classNode.value, [
-                        classNode
-                    ]);
-                }
-            }
-            for (const conflict of partialConflicts){
-                const classNode = classNodeQueues.get(conflict.className)?.shift();
-                if (!classNode) continue;
-                context.report({
-                    loc: classNode.loc,
-                    messageId: 'partialCollisionClass',
-                    data: {
-                        actual: conflict.className,
-                        replacement: conflict.replacement,
-                        conflict: conflict.conflict
-                    },
-                    fix (fixer) {
-                        return fixer.replaceTextRange([
-                            start,
-                            end
-                        ], fixedRaw);
-                    }
-                });
-            }
-        });
-    }
-});
-
-module.exports = noConflictingClasses;

package/dist/rules/no-conflicting-classes.mjs

@@ -1,99 +0,0 @@
-import defineVisitors from '../utils/define-visitors.mjs';
-import resolveContext from '../utils/resolve-context.mjs';
-import createRule from '../create-rule.mjs';
-import { findClassConflicts, removeClassNamesFromClassList, findPartialClassConflicts, replaceClassNameInClassList } from '@master/css-lint';
-
-var noConflictingClasses = createRule({
-    name: 'no-conflicting-classes',
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Disallow conflicting Master CSS classes'
-        },
-        messages: {
-            collisionClass: '{{message}}',
-            partialCollisionClass: 'Prefer "{{replacement}}" over "{{actual}}" because "{{conflict}}" overrides part of it.'
-        },
-        fixable: 'code',
-        schema: []
-    },
-    defaultOptions: [],
-    create (context) {
-        const { settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { raw, start, end, unescape, classNodes, classValues })=>{
-            const conflicts = findClassConflicts(classValues, css);
-            if (conflicts.length) {
-                const classNamesToRemove = conflicts.map(({ className })=>className);
-                const keptClassNames = [
-                    ...new Set(conflicts.flatMap(({ conflicts })=>conflicts))
-                ];
-                const formatClassName = (className)=>`"${className}"`;
-                const formatClassList = (classNames)=>{
-                    if (classNames.length <= 2) return classNames.map(formatClassName).join(' and ');
-                    return `${classNames.slice(0, -1).map(formatClassName).join(', ')}, and ${formatClassName(classNames[classNames.length - 1])}`;
-                };
-                const fixedRaw = removeClassNamesFromClassList(raw, classNamesToRemove, {
-                    unescape
-                });
-                const firstClassNode = classNodes.find((node)=>node.value === classNamesToRemove[0]);
-                context.report({
-                    loc: firstClassNode.loc,
-                    messageId: 'collisionClass',
-                    data: {
-                        message: `${formatClassList(classNamesToRemove)} ${classNamesToRemove.length === 1 ? 'is' : 'are'} overridden by ${formatClassList(keptClassNames)}.`
-                    },
-                    fix: function(fixer) {
-                        return fixer.replaceTextRange([
-                            start,
-                            end
-                        ], fixedRaw);
-                    }
-                });
-                return;
-            }
-            const partialConflicts = findPartialClassConflicts(classValues, css);
-            if (!partialConflicts.length) return;
-            let fixedRaw = raw;
-            for (const conflict of partialConflicts){
-                fixedRaw = replaceClassNameInClassList(fixedRaw, conflict.className, conflict.replacement, {
-                    unescape
-                });
-            }
-            const classNodeQueues = new Map();
-            for (const classNode of classNodes){
-                const queue = classNodeQueues.get(classNode.value);
-                if (queue) {
-                    queue.push(classNode);
-                } else {
-                    classNodeQueues.set(classNode.value, [
-                        classNode
-                    ]);
-                }
-            }
-            for (const conflict of partialConflicts){
-                const classNode = classNodeQueues.get(conflict.className)?.shift();
-                if (!classNode) continue;
-                context.report({
-                    loc: classNode.loc,
-                    messageId: 'partialCollisionClass',
-                    data: {
-                        actual: conflict.className,
-                        replacement: conflict.replacement,
-                        conflict: conflict.conflict
-                    },
-                    fix (fixer) {
-                        return fixer.replaceTextRange([
-                            start,
-                            end
-                        ], fixedRaw);
-                    }
-                });
-            }
-        });
-    }
-});
-
-export { noConflictingClasses as default };

package/dist/rules/no-invalid-classes.cjs

@@ -1,51 +0,0 @@
-'use strict';
-
-var defineVisitors = require('../utils/define-visitors.cjs');
-var resolveContext = require('../utils/resolve-context.cjs');
-var createRule = require('../create-rule.cjs');
-var settingsSchema = require('../settings-schema.cjs');
-var cssLint = require('@master/css-lint');
-
-var noInvalidClasses = createRule({
-    name: 'no-invalid-classes',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow invalid Master CSS classes'
-        },
-        messages: {
-            invalidClass: '{{message}}',
-            disallowUnknownClass: '{{message}}'
-        },
-        fixable: null,
-        schema: [
-            settingsSchema.noInvalidClassesOptionsSchema
-        ]
-    },
-    defaultOptions: [],
-    create: function(context) {
-        const { options, settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { classNodes })=>{
-            for (const node of classNodes){
-                const issues = cssLint.getClassValidationIssues(node.value, css, {
-                    disallowUnknownClass: options.disallowUnknownClass,
-                    displayClassName: node.raw
-                });
-                for (const issue of issues){
-                    context.report({
-                        loc: node.loc,
-                        messageId: issue.kind === 'invalid' ? 'invalidClass' : 'disallowUnknownClass',
-                        data: {
-                            message: issue.message
-                        }
-                    });
-                }
-            }
-        });
-    }
-});
-
-module.exports = noInvalidClasses;

package/dist/rules/no-invalid-classes.mjs

@@ -1,49 +0,0 @@
-import defineVisitors from '../utils/define-visitors.mjs';
-import resolveContext from '../utils/resolve-context.mjs';
-import createRule from '../create-rule.mjs';
-import { noInvalidClassesOptionsSchema } from '../settings-schema.mjs';
-import { getClassValidationIssues } from '@master/css-lint';
-
-var noInvalidClasses = createRule({
-    name: 'no-invalid-classes',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow invalid Master CSS classes'
-        },
-        messages: {
-            invalidClass: '{{message}}',
-            disallowUnknownClass: '{{message}}'
-        },
-        fixable: null,
-        schema: [
-            noInvalidClassesOptionsSchema
-        ]
-    },
-    defaultOptions: [],
-    create: function(context) {
-        const { options, settings, css } = resolveContext(context);
-        return defineVisitors({
-            context,
-            settings
-        }, (_, { classNodes })=>{
-            for (const node of classNodes){
-                const issues = getClassValidationIssues(node.value, css, {
-                    disallowUnknownClass: options.disallowUnknownClass,
-                    displayClassName: node.raw
-                });
-                for (const issue of issues){
-                    context.report({
-                        loc: node.loc,
-                        messageId: issue.kind === 'invalid' ? 'invalidClass' : 'disallowUnknownClass',
-                        data: {
-                            message: issue.message
-                        }
-                    });
-                }
-            }
-        });
-    }
-});
-
-export { noInvalidClasses as default };

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

@@ -1,77 +0,0 @@
-'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 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 = cssLint.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
-                    }
-                });
-            }
-        });
-    }
-});
-
-module.exports = noUnapprovedRawValues;

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

@@ -1,75 +0,0 @@
-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

@@ -1,112 +0,0 @@
-'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;