@plumeria/eslint-plugin 18.2.13 → 18.2.15

package/dist/rules/expand-border-shorthands.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandBorderShorthands = void 0;
 const borderShorthand_1 = require("../util/borderShorthand");
 const logicalPhysical_1 = require("../util/logicalPhysical");
+const styleObject_1 = require("../util/styleObject");
 const BUNDLES = new Set(borderShorthand_1.BORDER_BUNDLES);
 exports.expandBorderShorthands = {
     meta: {
@@ -65,10 +66,11 @@ exports.expandBorderShorthands = {
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });

package/dist/rules/format-properties.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatProperties = void 0;
+const styleObject_1 = require("../util/styleObject");
 exports.formatProperties = {
     meta: {
         type: 'layout',
@@ -164,10 +165,11 @@ exports.formatProperties = {
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });

package/dist/rules/no-combinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noCombinator = void 0;
+const styleObject_1 = require("../util/styleObject");
 exports.noCombinator = {
     meta: {
         type: 'problem',
@@ -177,9 +178,9 @@ exports.noCombinator = {
                     if (keyName) {
                         checkAndReport(keyName, prop.key);
                     }
-                    if (prop.value.type === 'ObjectExpression') {
-                        checkForCombinatorsRecursively(prop.value);
-                    }
+                    const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                    if (style)
+                        checkForCombinatorsRecursively(style);
                 }
             }
         }

package/dist/rules/no-invalid-selector.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noInvalidSelector = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const styleObject_1 = require("../util/styleObject");
 exports.noInvalidSelector = {
     meta: {
         type: 'problem',
@@ -216,10 +217,11 @@ exports.noInvalidSelector = {
                                 });
                             }
                         }
-                        if (prop.type === utils_1.TSESTree.AST_NODE_TYPES.Property &&
-                            prop.value.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression) {
-                            checkNesting(prop.value, 'CLASS');
-                        }
+                        if (prop.type !== utils_1.TSESTree.AST_NODE_TYPES.Property)
+                            return;
+                        const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                        if (style)
+                            checkNesting(style, 'CLASS');
                     });
                 }
                 if (isCssKeyframes &&

package/dist/rules/no-order-dependent-overlap.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noOrderDependentOverlap = void 0;
 const zss_engine_1 = require("zss-engine");
 const logicalPhysical_1 = require("../util/logicalPhysical");
+const selector_1 = require("../util/selector");
+const styleObject_1 = require("../util/styleObject");
 const DIRECT_SHORTHANDS = {};
 for (const [shorthand, longhands] of Object.entries(zss_engine_1.DIRECT_LONGHANDS)) {
     for (const longhand of longhands) {
@@ -59,6 +61,7 @@ exports.noOrderDependentOverlap = {
             alias: "'{{ first }}' and '{{ second }}' are the same property under two names, so neither outranks the other. The one written last wins.",
             crossing: "'{{ first }}' and '{{ second }}' overlap, but neither property outranks the other. The result depends on the order they are written.",
             condition: "'{{ narrow }}' matches only where '{{ broad }}' also matches, so it is the more specific of the two, and both set '{{ property }}'. Written first, it reads as though the broader one wins, which is the opposite of what the stylesheet does.",
+            state: "'{{ first }}' and '{{ second }}' can match at the same time and both set '{{ property }}', but neither outranks the other, so the result depends on the order they are written. Declare '{{ compound }}' if the intersection has a value of its own, or split them into separate styles and compose them in the order that should win.",
             keep: "Keep '{{ keep }}'",
             swap: "Write '{{ narrow }}' after '{{ broad }}'",
         },
@@ -112,10 +115,11 @@ exports.noOrderDependentOverlap = {
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });
@@ -132,17 +136,31 @@ exports.noOrderDependentOverlap = {
                 ? prop.key.value
                 : '';
         }
-        function declaredNames(node) {
+        function declaredNames(node, withCustomProperties = false) {
             const names = new Set();
             node.properties.forEach((prop) => {
                 if (prop.type !== 'Property' || prop.value.type === 'ObjectExpression')
                     return;
                 const name = keyNameOf(prop);
-                if (name && !name.startsWith('--'))
-                    names.add(name);
+                if (!name)
+                    return;
+                if (name.startsWith('--')) {
+                    if (withCustomProperties)
+                        names.add(name);
+                    return;
+                }
+                names.add(name);
             });
             return names;
         }
+        function overlapsProperty(first, second) {
+            if (first.startsWith('--') || second.startsWith('--')) {
+                return first === second;
+            }
+            return ((0, logicalPhysical_1.canonicalProperty)((0, logicalPhysical_1.toKebabCase)(first)) ===
+                (0, logicalPhysical_1.canonicalProperty)((0, logicalPhysical_1.toKebabCase)(second)) ||
+                overlapOf((0, logicalPhysical_1.toKebabCase)(first), (0, logicalPhysical_1.toKebabCase)(second)) === 'crossing');
+        }
         function swapProperties(fixer, first, second) {
             return [
                 fixer.replaceText(first, sourceCode.getText(second)),
@@ -162,6 +180,7 @@ exports.noOrderDependentOverlap = {
         function checkStyleObject(node) {
             const declarations = [];
             const conditions = [];
+            const states = [];
             node.properties.forEach((prop) => {
                 if (prop.type !== 'Property')
                     return;
@@ -175,6 +194,13 @@ exports.noOrderDependentOverlap = {
                             sets: declaredNames(prop.value),
                         });
                     }
+                    else if ((0, selector_1.isStateSelector)(condition)) {
+                        states.push({
+                            prop,
+                            name: condition,
+                            sets: declaredNames(prop.value, true),
+                        });
+                    }
                     checkStyleObject(prop.value);
                     return;
                 }
@@ -215,6 +241,40 @@ exports.noOrderDependentOverlap = {
                     });
                 }
             }
+            for (let i = 0; i < states.length; i++) {
+                for (let j = i + 1; j < states.length; j++) {
+                    const first = states[i];
+                    const second = states[j];
+                    if ((0, zss_engine_1.getPseudoElement)(first.name) !== (0, zss_engine_1.getPseudoElement)(second.name)) {
+                        continue;
+                    }
+                    if ((0, zss_engine_1.getSpecificity)(first.name).join() !==
+                        (0, zss_engine_1.getSpecificity)(second.name).join()) {
+                        continue;
+                    }
+                    if ((0, selector_1.areExclusive)(first.name, second.name))
+                        continue;
+                    const shared = [...first.sets].find((name) => [...second.sets].some((other) => overlapsProperty(name, other)));
+                    if (!shared)
+                        continue;
+                    if (states.some((state) => state !== first &&
+                        state !== second &&
+                        (0, selector_1.covers)(state.name, first.name, second.name) &&
+                        [...state.sets].some((name) => overlapsProperty(name, shared)))) {
+                        continue;
+                    }
+                    context.report({
+                        node: second.prop.key,
+                        messageId: 'state',
+                        data: {
+                            first: first.name,
+                            second: second.name,
+                            property: shared,
+                            compound: (0, selector_1.compoundOf)(first.name, second.name),
+                        },
+                    });
+                }
+            }
             for (let i = 0; i < declarations.length; i++) {
                 for (let j = i + 1; j < declarations.length; j++) {
                     const first = declarations[i];

package/dist/rules/no-unknown-css-properties.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnknownCssProperties = void 0;
 const known_css_properties_1 = require("known-css-properties");
+const styleObject_1 = require("../util/styleObject");
 const knownProperties = new Set(known_css_properties_1.all);
 const kebabCache = new Map();
 function toKebabCase(str) {
@@ -70,10 +71,11 @@ exports.noUnknownCssProperties = {
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });

package/dist/rules/no-unused-keys.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnusedKeys = void 0;
+const styleObject_1 = require("../util/styleObject");
 function getRootObject(node) {
     if (node.type === 'Identifier') {
         return node;
@@ -46,7 +47,7 @@ exports.noUnusedKeys = {
                         arg.properties.forEach((prop) => {
                             if (prop.type === 'Property' &&
                                 prop.key.type === 'Identifier' &&
-                                prop.value.type === 'ObjectExpression') {
+                                (0, styleObject_1.styleObjectFromValue)(prop.value)) {
                                 keyMap.set(prop.key.name, prop.key);
                             }
                         });

package/dist/rules/sort-properties.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortProperties = void 0;
+const styleObject_1 = require("../util/styleObject");
 const propertyGroups_1 = require("../util/propertyGroups");
 function getPropertyName(property) {
     if (property.key.type === 'Identifier') {
@@ -212,10 +213,11 @@ exports.sortProperties = {
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });

package/dist/rules/validate-pseudos.js

@@ -4,6 +4,7 @@ exports.validatePseudos = void 0;
 exports.splitChainedPseudos = splitChainedPseudos;
 exports.isValidPseudo = isValidPseudo;
 const utils_1 = require("@typescript-eslint/utils");
+const styleObject_1 = require("../util/styleObject");
 const VALID_STATIC_PSEUDOS = new Set([
     ':hover',
     ':active',
@@ -235,10 +236,11 @@ exports.validatePseudos = {
                     node.arguments[0]?.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression) {
                     const styleObj = node.arguments[0];
                     styleObj.properties.forEach((prop) => {
-                        if (prop.type === utils_1.TSESTree.AST_NODE_TYPES.Property &&
-                            prop.value.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression) {
-                            checkProperties(prop.value);
-                        }
+                        if (prop.type !== utils_1.TSESTree.AST_NODE_TYPES.Property)
+                            return;
+                        const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                        if (style)
+                            checkProperties(style);
                     });
                 }
             },

package/dist/rules/validate-values.js

@@ -5,6 +5,7 @@ const validData_1 = require("../util/validData");
 const unitData_1 = require("../util/unitData");
 const colorData_1 = require("../util/colorData");
 const place_1 = require("../util/place");
+const styleObject_1 = require("../util/styleObject");
 const globalValues = ['inherit', 'initial', 'revert', 'revert-layer', 'unset'];
 const lengthValueProperties = [
     'width',
@@ -1674,10 +1675,11 @@ exports.validateValues = {
                 node.arguments.forEach((arg) => {
                     if (arg.type === 'ObjectExpression') {
                         arg.properties.forEach((prop) => {
-                            if (prop.type === 'Property' &&
-                                prop.value.type === 'ObjectExpression') {
-                                checkStyleObject(prop.value);
-                            }
+                            if (prop.type !== 'Property')
+                                return;
+                            const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                            if (style)
+                                checkStyleObject(style);
                         });
                     }
                 });

package/dist/util/selector.d.ts

@@ -0,0 +1,11 @@
+interface Token {
+    text: string;
+    isPseudoElement: boolean;
+}
+export declare function tokenize(selector: string): Token[];
+export declare function isStateSelector(selector: string): boolean;
+export declare function areExclusive(first: string, second: string): boolean;
+export declare function statesOf(selector: string): string[];
+export declare function compoundOf(first: string, second: string): string;
+export declare function covers(compound: string, first: string, second: string): boolean;
+export {};

package/dist/util/selector.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+exports.isStateSelector = isStateSelector;
+exports.areExclusive = areExclusive;
+exports.statesOf = statesOf;
+exports.compoundOf = compoundOf;
+exports.covers = covers;
+const zss_engine_1 = require("zss-engine");
+const LEGACY_PSEUDO_ELEMENTS = new Set([
+    'before',
+    'after',
+    'first-line',
+    'first-letter',
+]);
+const EXCLUSIVE_PAIRS = [
+    [':link', ':visited'],
+    [':enabled', ':disabled'],
+    [':read-only', ':read-write'],
+    [':valid', ':invalid'],
+    [':in-range', ':out-of-range'],
+    [':required', ':optional'],
+].map((pair) => pair.slice().sort().join('\0'));
+const isNameChar = (char) => /[\w-]/.test(char);
+const skipName = (selector, from) => {
+    let index = from;
+    while (index < selector.length) {
+        if (selector[index] === '\\') {
+            index += 2;
+            continue;
+        }
+        if (!isNameChar(selector[index]))
+            break;
+        index += 1;
+    }
+    return index;
+};
+const findClose = (selector, open) => {
+    let depth = 0;
+    for (let index = open; index < selector.length; index++) {
+        const char = selector[index];
+        if (char === '\\') {
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            index += 1;
+            while (index < selector.length && selector[index] !== char) {
+                if (selector[index] === '\\')
+                    index += 1;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        else if (char === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return selector.length;
+};
+const skipBracket = (selector, open) => {
+    for (let index = open + 1; index < selector.length; index++) {
+        const char = selector[index];
+        if (char === '\\') {
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            index += 1;
+            while (index < selector.length && selector[index] !== char) {
+                if (selector[index] === '\\')
+                    index += 1;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === ']')
+            return index + 1;
+    }
+    return selector.length;
+};
+function tokenize(selector) {
+    const tokens = [];
+    let index = 0;
+    while (index < selector.length) {
+        const char = selector[index];
+        const start = index;
+        if (char === '#' || char === '.') {
+            index = skipName(selector, index + 1);
+            tokens.push({
+                text: selector.slice(start, index),
+                isPseudoElement: false,
+            });
+            continue;
+        }
+        if (char === '[') {
+            index = skipBracket(selector, index);
+            tokens.push({
+                text: selector.slice(start, index),
+                isPseudoElement: false,
+            });
+            continue;
+        }
+        if (char === ':') {
+            const doubleColon = selector[index + 1] === ':';
+            const nameStart = index + (doubleColon ? 2 : 1);
+            const nameEnd = skipName(selector, nameStart);
+            const name = selector.slice(nameStart, nameEnd).toLowerCase();
+            index = nameEnd;
+            let inner = '';
+            if (selector[index] === '(') {
+                const close = findClose(selector, index);
+                inner = selector.slice(index + 1, close);
+                index = close + 1;
+            }
+            const text = selector.slice(start, index);
+            const argument = inner ? `(${inner})` : '';
+            if (doubleColon || LEGACY_PSEUDO_ELEMENTS.has(name)) {
+                tokens.push({
+                    text: `::${name}${argument}`,
+                    isPseudoElement: true,
+                });
+                continue;
+            }
+            tokens.push({ text, isPseudoElement: false });
+            continue;
+        }
+        if (isNameChar(char) || char === '\\') {
+            index = skipName(selector, index);
+            tokens.push({
+                text: selector.slice(start, index),
+                isPseudoElement: false,
+            });
+            continue;
+        }
+        index += 1;
+    }
+    return tokens;
+}
+function isStateSelector(selector) {
+    const tokens = tokenize(selector);
+    return (tokens.length > 0 &&
+        tokens.every((token) => token.isPseudoElement ||
+            token.text.startsWith(':') ||
+            token.text.startsWith('[')));
+}
+const negationOf = (state) => {
+    if (!state.startsWith(':not(') || !state.endsWith(')'))
+        return null;
+    return state.slice(5, -1).trim();
+};
+function areExclusive(first, second) {
+    const left = new Set(statesOf(first));
+    const right = new Set(statesOf(second));
+    for (const a of left) {
+        for (const b of right) {
+            if (a === b)
+                continue;
+            if (negationOf(a) === b || negationOf(b) === a)
+                return true;
+            if (EXCLUSIVE_PAIRS.includes([a, b].sort().join('\0')))
+                return true;
+        }
+    }
+    return false;
+}
+function statesOf(selector) {
+    return tokenize(selector)
+        .filter((token) => !token.isPseudoElement)
+        .map((token) => token.text);
+}
+function compoundOf(first, second) {
+    const states = [...new Set([...statesOf(first), ...statesOf(second)])];
+    return states.join('') + (0, zss_engine_1.getPseudoElement)(first);
+}
+function covers(compound, first, second) {
+    const declared = new Set(statesOf(compound));
+    if ((0, zss_engine_1.getPseudoElement)(compound) !== (0, zss_engine_1.getPseudoElement)(first))
+        return false;
+    return [...statesOf(first), ...statesOf(second)].every((state) => declared.has(state));
+}

package/dist/util/spellingRule.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSpellingRule = void 0;
 const logicalPhysical_1 = require("./logicalPhysical");
+const styleObject_1 = require("./styleObject");
 const DESCRIPTIONS = {
     physical: 'Disallow the physical name of a property that also has a logical name',
     logical: 'Disallow the logical name of a property that also has a physical name',
@@ -77,10 +78,11 @@ const createSpellingRule = (reject) => ({
                     node.arguments.forEach((arg) => {
                         if (arg.type === 'ObjectExpression') {
                             arg.properties.forEach((prop) => {
-                                if (prop.type === 'Property' &&
-                                    prop.value.type === 'ObjectExpression') {
-                                    checkStyleObject(prop.value);
-                                }
+                                if (prop.type !== 'Property')
+                                    return;
+                                const style = (0, styleObject_1.styleObjectFromValue)(prop.value);
+                                if (style)
+                                    checkStyleObject(style);
                             });
                         }
                     });

package/dist/util/styleObject.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectExpression } from 'estree';
+export declare function styleObjectFromValue(value: {
+    type: string;
+}): ObjectExpression | undefined;

package/dist/util/styleObject.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styleObjectFromValue = styleObjectFromValue;
+function styleObjectFromValue(value) {
+    if (value.type === 'ObjectExpression')
+        return value;
+    if (value.type !== 'ArrowFunctionExpression' &&
+        value.type !== 'FunctionExpression')
+        return undefined;
+    const body = value.body;
+    if (body?.type === 'ObjectExpression')
+        return body;
+    if (body?.type !== 'BlockStatement')
+        return undefined;
+    const first = body.body?.[0];
+    return first?.type === 'ReturnStatement' &&
+        first.argument?.type === 'ObjectExpression'
+        ? first.argument
+        : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/eslint-plugin",
-  "version": "18.2.13",
+  "version": "18.2.15",
   "description": "Plumeria ESLint plugin",
   "author": "Refirst 11",
   "license": "MIT",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "^8.60.0",
     "known-css-properties": "^0.37.0",
-    "zss-engine": "2.5.0"
+    "zss-engine": "2.6.0"
   },
   "scripts": {
     "build": "rimraf dist && pnpm cjs",