@master/eslint-plugin-css 2.0.0-rc.2 → 2.0.0-rc.20

package/README.md

@@ -41,7 +41,7 @@
             <img alt="Follow @mastercorg" src="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
         </picture>
     </a>
-    <a aria-label="Github Actions" href="https://github.com/1aron/repo/actions/workflows/release.yml">
+    <a aria-label="Github Actions" href="https://github.com/master-co/css/actions/workflows/release.yml">
         <picture>
             <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/release.yml?branch=rc&label=%20&message=twitter&color=212022&logo=githubactions&style=for-the-badge">
             <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">

package/dist/configs/config.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const config = {
+    rules: {
+        '@master/css/class-order': 'warn',
+        '@master/css/class-validation': 'error',
+        '@master/css/class-collision': 'warn'
+    },
+    parserOptions: {
+        ecmaFeatures: {
+            jsx: true
+        }
+    }
+};
+
+module.exports = config;

package/dist/configs/config.mjs

@@ -1 +1,14 @@
-const s={rules:{"@master/css/class-order":"warn","@master/css/class-validation":"error","@master/css/class-collision":"warn"},parserOptions:{ecmaFeatures:{jsx:!0}}};var r=s;export{r as default};
+const config = {
+    rules: {
+        '@master/css/class-order': 'warn',
+        '@master/css/class-validation': 'error',
+        '@master/css/class-collision': 'warn'
+    },
+    parserOptions: {
+        ecmaFeatures: {
+            jsx: true
+        }
+    }
+};
+
+export { config as default };

package/dist/configs/flat.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var plugin = require('../plugin.cjs');
+var config = require('./config.cjs');
+
+var flat = {
+    plugins: {
+        '@master/css': plugin
+    },
+    ...config
+};
+
+module.exports = flat;

package/dist/configs/flat.d.ts

@@ -10,7 +10,16 @@ declare const _default: {
         };
     };
     plugins: {
-        '@master/css': import("eslint").ESLint.Plugin;
+        '@master/css': {
+            meta: {
+                name: string;
+            };
+            rules: {
+                'class-collision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                'class-order': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                'class-validation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+            };
+        };
     };
 };
 export default _default;

package/dist/configs/flat.mjs

@@ -1 +1,11 @@
-import o from"../plugin.mjs";import r from"./config.mjs";var p={plugins:{"@master/css":o},...r};export{p as default};
+import plugin from '../plugin.mjs';
+import config from './config.mjs';
+
+var flat = {
+    plugins: {
+        '@master/css': plugin
+    },
+    ...config
+};
+
+export { flat as default };

package/dist/configs/recommended.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var config = require('./config.cjs');
+
+var recommended = {
+    plugins: [
+        '@master/css'
+    ],
+    ...config
+};
+
+module.exports = recommended;

package/dist/configs/recommended.mjs

@@ -1 +1,10 @@
-import o from"./config.mjs";var s={plugins:["@master/css"],...o};export{s as default};
+import config from './config.mjs';
+
+var recommended = {
+    plugins: [
+        '@master/css'
+    ],
+    ...config
+};
+
+export { recommended as default };

package/dist/create-rule.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var utils = require('@typescript-eslint/utils');
+
+var createRule = utils.ESLintUtils.RuleCreator((name)=>'https://rc.css.master.co/docs/code-linting#' + name);
+
+module.exports = createRule;

package/dist/create-rule.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: <TOptions extends readonly unknown[], TMessageIds extends string>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds>>) => ESLintUtils.RuleModule<TMessageIds, TOptions, ESLintUtils.RuleListener>;
+export default _default;

package/dist/create-rule.mjs

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+var createRule = ESLintUtils.RuleCreator((name)=>'https://rc.css.master.co/docs/code-linting#' + name);
+
+export { createRule as default };

package/dist/functions/get-css.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var css = require('@master/css');
+var exploreConfig = require('explore-config');
+
+let currentCSS;
+let currentConfig;
+function getCSS(config) {
+    if (!currentCSS || currentConfig !== config) {
+        currentCSS = new css.MasterCSS(typeof config === 'object' ? config : exploreConfig(config || ''));
+        currentConfig = config;
+    }
+    return currentCSS;
+}
+
+module.exports = getCSS;

package/dist/functions/get-css.d.ts

@@ -0,0 +1 @@
+export default function getCSS(config: any): any;

package/dist/functions/get-css.mjs

@@ -0,0 +1,14 @@
+import { MasterCSS } from '@master/css';
+import exploreConfig from 'explore-config';
+
+let currentCSS;
+let currentConfig;
+function getCSS(config) {
+    if (!currentCSS || currentConfig !== config) {
+        currentCSS = new MasterCSS(typeof config === 'object' ? config : exploreConfig(config || ''));
+        currentConfig = config;
+    }
+    return currentCSS;
+}
+
+export { getCSS as default };

package/dist/functions/reorder-valid-classes.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var synckit = require('synckit');
+var reorderValidClasses_worker = require('./reorder-valid-classes.worker.cjs');
+var path = require('path');
+
+var reorderValidClasses = process.env.NODE_ENV === 'test' ? reorderValidClasses_worker : synckit.createSyncFn(path.join(__dirname, 'reorder-valid-classes.worker.cjs'));
+
+module.exports = reorderValidClasses;

package/dist/functions/reorder-valid-classes.d.ts

@@ -0,0 +1,3 @@
+import runReorderValidClasses from './reorder-valid-classes.worker';
+declare const _default: typeof runReorderValidClasses;
+export default _default;

package/dist/functions/reorder-valid-classes.mjs

@@ -0,0 +1,11 @@
+import __url_for_shim from 'url';
+import __path_for_shim from 'path';
+const __filename = __url_for_shim.fileURLToPath(import.meta.url);
+const __dirname = __path_for_shim.dirname(__filename);
+import { createSyncFn } from 'synckit';
+import runReorderValidClasses from './reorder-valid-classes.worker.mjs';
+import { join } from 'path';
+var reorderValidClasses = process.env.NODE_ENV === 'test' ? runReorderValidClasses : createSyncFn(join(__dirname, 'reorder-valid-classes.worker.cjs'));
+export {
+    reorderValidClasses as default
+};

package/dist/functions/reorder-valid-classes.worker.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var css = require('@master/css');
+var synckit = require('synckit');
+var getCss = require('./get-css.cjs');
+
+function runReorderValidClasses(classNames, config) {
+    const currentCSS = getCss(config);
+    return css.reorderForReadableClasses(classNames, {
+        css: currentCSS
+    }).filter((eachOrderedClassName)=>classNames.includes(eachOrderedClassName));
+}
+synckit.runAsWorker(runReorderValidClasses);
+
+module.exports = runReorderValidClasses;

package/dist/functions/reorder-valid-classes.worker.d.ts

@@ -0,0 +1 @@
+export default function runReorderValidClasses(classNames: string[], config: string | object): string[];

package/dist/functions/reorder-valid-classes.worker.mjs

@@ -0,0 +1,13 @@
+import { reorderForReadableClasses } from '@master/css';
+import { runAsWorker } from 'synckit';
+import getCSS from './get-css.mjs';
+
+function runReorderValidClasses(classNames, config) {
+    const currentCSS = getCSS(config);
+    return reorderForReadableClasses(classNames, {
+        css: currentCSS
+    }).filter((eachOrderedClassName)=>classNames.includes(eachOrderedClassName));
+}
+runAsWorker(runReorderValidClasses);
+
+export { runReorderValidClasses as default };

package/dist/functions/valid-rules.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var synckit = require('synckit');
+var validRules_worker = require('./valid-rules.worker.cjs');
+var path = require('path');
+
+var validRules = process.env.NODE_ENV === 'test' ? validRules_worker : synckit.createSyncFn(path.join(__dirname, 'valid-rules.worker.cjs'));
+
+module.exports = validRules;

package/dist/functions/valid-rules.d.ts

@@ -0,0 +1,3 @@
+import runValidRules from './valid-rules.worker';
+declare const _default: typeof runValidRules;
+export default _default;

package/dist/functions/valid-rules.mjs

@@ -0,0 +1,11 @@
+import __url_for_shim from 'url';
+import __path_for_shim from 'path';
+const __filename = __url_for_shim.fileURLToPath(import.meta.url);
+const __dirname = __path_for_shim.dirname(__filename);
+import { createSyncFn } from 'synckit';
+import runValidRules from './valid-rules.worker.mjs';
+import { join } from 'path';
+var validRules = process.env.NODE_ENV === 'test' ? runValidRules : createSyncFn(join(__dirname, 'valid-rules.worker.cjs'));
+export {
+    validRules as default
+};

package/dist/functions/valid-rules.worker.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var synckit = require('synckit');
+var getCss = require('./get-css.cjs');
+var cssValidator = require('@master/css-validator');
+
+function runValidRules(classNames, config) {
+    const currentCSS = getCss(config);
+    const ruleOfClass = {};
+    classNames.forEach((eachClassName)=>{
+        const validRule = cssValidator.generateValidRules(eachClassName, {
+            css: currentCSS
+        })[0];
+        if (validRule) ruleOfClass[eachClassName] = {
+            vendorPrefixSelectors: validRule?.vendorPrefixSelectors,
+            declarations: validRule?.declarations,
+            stateToken: validRule?.stateToken
+        };
+    });
+    return ruleOfClass;
+}
+synckit.runAsWorker(runValidRules);
+
+module.exports = runValidRules;

package/dist/functions/valid-rules.worker.d.ts

@@ -0,0 +1,6 @@
+import { Rule } from '@master/css';
+export default function runValidRules(classNames: string[], config: string | object): Record<string, {
+    declarations: Rule['declarations'];
+    stateToken: Rule['stateToken'];
+    vendorPrefixSelectors: Rule['vendorPrefixSelectors'];
+}>;

package/dist/functions/valid-rules.worker.mjs

@@ -0,0 +1,22 @@
+import { runAsWorker } from 'synckit';
+import getCSS from './get-css.mjs';
+import { generateValidRules } from '@master/css-validator';
+
+function runValidRules(classNames, config) {
+    const currentCSS = getCSS(config);
+    const ruleOfClass = {};
+    classNames.forEach((eachClassName)=>{
+        const validRule = generateValidRules(eachClassName, {
+            css: currentCSS
+        })[0];
+        if (validRule) ruleOfClass[eachClassName] = {
+            vendorPrefixSelectors: validRule?.vendorPrefixSelectors,
+            declarations: validRule?.declarations,
+            stateToken: validRule?.stateToken
+        };
+    });
+    return ruleOfClass;
+}
+runAsWorker(runValidRules);
+
+export { runValidRules as default };

package/dist/functions/validate.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var synckit = require('synckit');
+var validate_worker = require('./validate.worker.cjs');
+var path = require('path');
+
+var validate = process.env.NODE_ENV === 'test' ? validate_worker : synckit.createSyncFn(path.join(__dirname, 'validate.worker.cjs'));
+
+module.exports = validate;

package/dist/functions/validate.d.ts

@@ -0,0 +1,3 @@
+import runValidate from './validate.worker';
+declare const _default: typeof runValidate;
+export default _default;

package/dist/functions/validate.mjs

@@ -0,0 +1,11 @@
+import __url_for_shim from 'url';
+import __path_for_shim from 'path';
+const __filename = __url_for_shim.fileURLToPath(import.meta.url);
+const __dirname = __path_for_shim.dirname(__filename);
+import { createSyncFn } from 'synckit';
+import runValidate from './validate.worker.mjs';
+import { join } from 'path';
+var validate = process.env.NODE_ENV === 'test' ? runValidate : createSyncFn(join(__dirname, 'validate.worker.cjs'));
+export {
+    validate as default
+};

package/dist/functions/validate.worker.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var synckit = require('synckit');
+var getCss = require('./get-css.cjs');
+var cssValidator = require('@master/css-validator');
+
+function runValidate(className, config) {
+    const currentCSS = getCss(config);
+    return cssValidator.validate(className, {
+        css: currentCSS
+    });
+}
+synckit.runAsWorker(runValidate);
+
+module.exports = runValidate;

package/dist/functions/validate.worker.d.ts

@@ -0,0 +1,5 @@
+import { SyntaxError } from '@master/css-validator';
+export default function runValidate(className: string, config: string | object): {
+    isMasterCSS: boolean;
+    errors: SyntaxError[];
+};

package/dist/functions/validate.worker.mjs

@@ -0,0 +1,13 @@
+import { runAsWorker } from 'synckit';
+import getCSS from './get-css.mjs';
+import { validate } from '@master/css-validator';
+
+function runValidate(className, config) {
+    const currentCSS = getCSS(config);
+    return validate(className, {
+        css: currentCSS
+    });
+}
+runAsWorker(runValidate);
+
+export { runValidate as default };

package/dist/index.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var plugin = require('./plugin.cjs');
+var settings = require('./settings.cjs');
+var recommended = require('./configs/recommended.cjs');
+var flat = require('./configs/flat.cjs');
+
+/** @type {import('typescript-eslint').Config} */ var index = {
+    ...plugin,
+    configs: {
+        recommended,
+        flat
+    },
+    settings
+};
+
+module.exports = index;

package/dist/index.d.ts

@@ -1 +1,57 @@
-export {};
+/** @type {import('typescript-eslint').Config} */
+declare const _default: {
+    configs: {
+        recommended: {
+            rules: {
+                readonly '@master/css/class-order': "warn";
+                readonly '@master/css/class-validation': "error";
+                readonly '@master/css/class-collision': "warn";
+            };
+            parserOptions: {
+                readonly ecmaFeatures: {
+                    readonly jsx: true;
+                };
+            };
+            plugins: string[];
+        };
+        flat: {
+            rules: {
+                readonly '@master/css/class-order': "warn";
+                readonly '@master/css/class-validation': "error";
+                readonly '@master/css/class-collision': "warn";
+            };
+            parserOptions: {
+                readonly ecmaFeatures: {
+                    readonly jsx: true;
+                };
+            };
+            plugins: {
+                '@master/css': {
+                    meta: {
+                        name: string;
+                    };
+                    rules: {
+                        'class-collision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                        'class-order': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                        'class-validation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    };
+                };
+            };
+        };
+    };
+    settings: {
+        calleeMatching: string;
+        classMatching: string;
+        ignoredKeys: string[];
+        config: string;
+    };
+    meta: {
+        name: string;
+    };
+    rules: {
+        'class-collision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'class-order': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'class-validation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    };
+};
+export default _default;

package/dist/index.mjs

@@ -1 +1,15 @@
-var i=(r,o)=>()=>(o||r((o={exports:{}}).exports,o),o.exports);import t from"./plugin.mjs";import f from"./settings.mjs";import p from"./configs/recommended.mjs";import e from"./configs/flat.mjs";var n=i((x,m)=>{m.exports={...t,configs:{recommended:p,flat:e},settings:f}});export default n();
+import plugin from './plugin.mjs';
+import settings from './settings.mjs';
+import recommended from './configs/recommended.mjs';
+import flat from './configs/flat.mjs';
+
+/** @type {import('typescript-eslint').Config} */ var index = {
+    ...plugin,
+    configs: {
+        recommended,
+        flat
+    },
+    settings
+};
+
+export { index as default };

package/dist/plugin.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var classCollision = require('./rules/class-collision.cjs');
+var classOrder = require('./rules/class-order.cjs');
+var classValidation = require('./rules/class-validation.cjs');
+
+const plugin = {
+    meta: {
+        name: '@master/eslint-plugin-css'
+    },
+    rules: {
+        'class-collision': classCollision,
+        'class-order': classOrder,
+        'class-validation': classValidation
+    }
+};
+
+module.exports = plugin;

package/dist/plugin.d.ts

@@ -1,3 +1,11 @@
-import type { ESLint } from 'eslint';
-declare const plugin: ESLint.Plugin;
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'class-collision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'class-order': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'class-validation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", any[], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    };
+};
 export default plugin;

package/dist/plugin.mjs

@@ -1 +1,16 @@
-import s from"./rules/class-collision.mjs";import i from"./rules/class-order.mjs";import l from"./rules/class-validation.mjs";const o={meta:{name:"@master/eslint-plugin-css"},rules:{"class-collision":s,"class-order":i,"class-validation":l}};var n=o;export{n as default};
+import classCollision from './rules/class-collision.mjs';
+import classOrder from './rules/class-order.mjs';
+import classValidation from './rules/class-validation.mjs';
+
+const plugin = {
+    meta: {
+        name: '@master/eslint-plugin-css'
+    },
+    rules: {
+        'class-collision': classCollision,
+        'class-order': classOrder,
+        'class-validation': classValidation
+    }
+};
+
+export { plugin as default };

package/dist/rules/class-collision.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+var areDeclarationsEqual = require('../utils/are-declarations-equal.cjs');
+var areVendorPrefixSelectorsEqual = require('../utils/are-vendor-prefix-selectors-equal.cjs');
+var defineVisitors = require('../utils/define-visitors.cjs');
+var resolveContext = require('../utils/resolve-context.cjs');
+var findLoc = require('../utils/find-loc.cjs');
+var parseNodeRecursive = require('../utils/parse-node-recursive.cjs');
+var validRules = require('../functions/valid-rules.cjs');
+var createRule = require('../create-rule.cjs');
+
+var classCollision = createRule({
+    name: 'class-collision-detection',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Avoid applying classes with the same CSS declaration',
+            recommended: 'recommended'
+        },
+        messages: {
+            collisionClass: '{{message}}'
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    calleeMatching: {
+                        type: 'string'
+                    },
+                    classMatching: {
+                        type: 'string'
+                    },
+                    ignoredKeys: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            minLength: 0
+                        },
+                        uniqueItems: true
+                    },
+                    config: {
+                        type: [
+                            'string',
+                            'object'
+                        ]
+                    }
+                }
+            }
+        ]
+    },
+    defaultOptions: [],
+    create (context) {
+        const { options, settings } = resolveContext(context);
+        const visitNode = (node, arg = null)=>{
+            parseNodeRecursive.parseNodeRecursive(node, arg, (classNames, node, originalClassNamesValue, start, end)=>{
+                const sourceCode = context.sourceCode;
+                const sourceCodeLines = sourceCode.lines;
+                const nodeStartLine = node.loc.start.line;
+                const nodeEndLine = node.loc.end.line;
+                const ruleOfClass = validRules(classNames, settings.config);
+                for(let i = 0; i < classNames.length; i++){
+                    const className = classNames[i];
+                    const rule = ruleOfClass[className];
+                    const conflicts = [];
+                    if (rule) {
+                        for(let j = 0; j < classNames.length; j++){
+                            const compareClassName = classNames[j];
+                            const compareRule = ruleOfClass[compareClassName];
+                            if (i !== j && compareRule && areDeclarationsEqual(rule.declarations, compareRule.declarations) && areVendorPrefixSelectorsEqual(rule.vendorPrefixSelectors, compareRule.vendorPrefixSelectors) && rule.stateToken === compareRule.stateToken) {
+                                conflicts.push(compareClassName);
+                            }
+                        }
+                    }
+                    if (conflicts.length > 0) {
+                        const conflictClassNamesMsg = conflicts.map((x)=>`"${x}"`).join(' and ');
+                        let fixClassNames = originalClassNamesValue;
+                        for (const conflictClassName of conflicts){
+                            const regexSafe = conflictClassName.replace(/(\\|\.|\(|\)|\[|\]|\{|\}|\+|\*|\?|\^|\$|\||\/)/g, '\\$1');
+                            fixClassNames = fixClassNames.replace(new RegExp(`\\s+${regexSafe}|${regexSafe}\\s+`), '');
+                        }
+                        context.report({
+                            loc: findLoc(className, sourceCodeLines, nodeStartLine, nodeEndLine),
+                            messageId: 'collisionClass',
+                            data: {
+                                message: `"${className}" applies the same CSS declarations as ${conflictClassNamesMsg}.`
+                            },
+                            fix: function(fixer) {
+                                return fixer.replaceTextRange([
+                                    start,
+                                    end
+                                ], fixClassNames);
+                            }
+                        });
+                    }
+                }
+            }, false, false, settings.ignoredKeys, context);
+        };
+        return defineVisitors({
+            context,
+            settings,
+            options
+        }, visitNode);
+    }
+});
+
+module.exports = classCollision;