@plumeria/eslint-plugin 21.1.1 → 21.1.2

package/dist/rules/no-style-prop-relay.js

@@ -1,6 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noStylePropRelay = void 0;
+const fs = __importStar(require("fs"));
+const compiler_1 = require("@plumeria/compiler");
 const style_prop_1 = require("../util/style-prop");
 const scan_1 = require("../util/scan");
 const isFunction = (node) => node?.type === 'FunctionDeclaration' ||
@@ -20,6 +55,14 @@ const componentFunctionOf = (node) => {
     }
     return undefined;
 };
+const realPathOf = (filename) => {
+    try {
+        return fs.realpathSync.native(filename);
+    }
+    catch {
+        return filename;
+    }
+};
 const unwrapDefault = (pattern) => pattern?.type === 'AssignmentPattern' ? pattern.left : pattern;
 const keyName = (key) => key.type === 'Identifier'
     ? key.name
@@ -35,6 +78,7 @@ exports.noStylePropRelay = {
         schema: style_prop_1.stylePropSchema,
         messages: {
             relay: "'{{prop}}' is never applied here. Apply it to {{styleProp}} or css.use() on an element this component renders.",
+            receiver: "'{{prop}}' is a style received through a prop and cannot be passed on to a component that declares {{styleProp}}. Apply it on an element this component renders.",
         },
     },
     create(context) {
@@ -120,13 +164,14 @@ exports.noStylePropRelay = {
             }
             return into;
         }
-        function applied(fn) {
+        function applied(fn, receives) {
             const found = [];
-            const visit = (node) => {
+            const passed = [];
+            const visit = (node, owner) => {
                 if (!node || typeof node !== 'object')
                     return;
                 if (Array.isArray(node)) {
-                    node.forEach(visit);
+                    node.forEach((item) => visit(item, owner));
                     return;
                 }
                 const current = node;
@@ -135,26 +180,74 @@ exports.noStylePropRelay = {
                 if (current.type === 'JSXAttribute' &&
                     current.name?.name === styleProp &&
                     current.value?.type === 'JSXExpressionContainer') {
-                    roots(current.value.expression, found);
+                    const expression = current.value.expression;
+                    if (owner !== undefined && receives(owner)) {
+                        passed.push({ attribute: current, roots: roots(expression, []) });
+                    }
+                    else {
+                        roots(expression, found);
+                    }
                 }
                 if (isUse(current) && current.type === 'CallExpression') {
                     current.arguments.forEach((argument) => roots(argument, found));
                 }
+                const next = current.type === 'JSXOpeningElement'
+                    ? current.name?.type === 'JSXIdentifier'
+                        ? current.name.name
+                        : undefined
+                    : owner;
                 for (const key of Object.keys(current)) {
                     if (key === 'parent')
                         continue;
-                    visit(current[key]);
+                    visit(current[key], next);
                 }
             };
             visit(fn.body);
-            return found;
+            return { found, passed };
         }
         return {
             Program(program) {
                 const tables = (0, scan_1.scanTables)(context.cwd, styleProp);
                 const table = tables.componentPropsTable ?? {};
+                const filename = realPathOf(context.filename);
+                const imports = new Map();
+                for (const node of program.body ?? []) {
+                    if (node.type !== 'ImportDeclaration')
+                        continue;
+                    for (const specifier of node.specifiers) {
+                        const name = specifier.type === 'ImportDefaultSpecifier'
+                            ? 'default'
+                            : specifier.type === 'ImportSpecifier'
+                                ? keyName(specifier.imported)
+                                : null;
+                        if (name === null)
+                            continue;
+                        imports.set(specifier.local.name, {
+                            source: node.source.value,
+                            name,
+                        });
+                    }
+                }
+                const receivers = tables.styleReceiverTable ?? {};
+                const known = new Map();
+                const receives = (name) => {
+                    if (known.has(name))
+                        return known.get(name);
+                    const binding = imports.get(name);
+                    let key = `${filename}-${name}`;
+                    if (binding) {
+                        const actualPath = (0, compiler_1.resolveImportPath)(binding.source, filename);
+                        const site = actualPath
+                            ? (0, compiler_1.resolveExport)(actualPath, binding.name)
+                            : null;
+                        key = site ? `${site.filePath}-${site.localName}` : null;
+                    }
+                    const result = key !== null && (receivers[key]?.includes(styleProp) ?? false);
+                    known.set(name, result);
+                    return result;
+                };
                 for (const { name, fn } of components(program)) {
-                    const props = table[`${context.filename}-${name}`];
+                    const props = table[`${filename}-${name}`];
                     if (!props)
                         continue;
                     const param = unwrapDefault(fn.params[0]);
@@ -174,18 +267,34 @@ exports.noStylePropRelay = {
                                 locals.set(local.name, prop);
                         }
                     }
-                    const done = new Set();
-                    for (const root of applied(fn)) {
-                        if (root.type === 'Identifier') {
-                            done.add(locals.get(root.name) ?? root.name);
-                        }
-                        else if (root.type === 'MemberExpression' &&
+                    const propOf = (root) => root.type === 'Identifier'
+                        ? (locals.get(root.name) ?? root.name)
+                        : root.type === 'MemberExpression' &&
                             root.object.type === 'Identifier' &&
                             root.object.name === paramName &&
                             !root.computed &&
-                            root.property.type === 'Identifier') {
-                            done.add(root.property.name);
-                        }
+                            root.property.type === 'Identifier'
+                            ? root.property.name
+                            : null;
+                    const done = new Set();
+                    const { found, passed } = applied(fn, receives);
+                    for (const root of found) {
+                        const prop = propOf(root);
+                        if (prop !== null)
+                            done.add(prop);
+                    }
+                    for (const { attribute, roots: passedRoots } of passed) {
+                        const prop = passedRoots
+                            .map(propOf)
+                            .find((name) => name !== null && name in props);
+                        if (!prop)
+                            continue;
+                        done.add(prop);
+                        context.report({
+                            node: attribute,
+                            messageId: 'receiver',
+                            data: { prop, styleProp },
+                        });
                     }
                     for (const prop of Object.keys(props)) {
                         if (done.has(prop))

package/dist/util/scan.d.ts

@@ -1 +1,4 @@
-export declare const scanTables: (cwd: string, styleProp: string) => import("@plumeria/compiler").ScanSummary;
+import { styleReceivers } from '@plumeria/compiler';
+export declare const scanTables: (cwd: string, styleProp: string) => import("@plumeria/compiler").ScanSummary & {
+    styleReceiverTable: ReturnType<typeof styleReceivers>;
+};

package/dist/util/scan.js

@@ -10,7 +10,12 @@ const scanTables = (cwd, styleProp) => {
     if (!recentScan ||
         recentScan.key !== key ||
         now - recentScan.at > SCAN_REUSE_MS) {
-        recentScan = { key, at: now, tables: (0, compiler_1.scanAll)(cwd, styleProp) };
+        const summary = (0, compiler_1.scanAll)(cwd, styleProp);
+        recentScan = {
+            key,
+            at: now,
+            tables: { ...summary, styleReceiverTable: (0, compiler_1.styleReceivers)() },
+        };
     }
     return recentScan.tables;
 };

package/dist/util/selector.js

@@ -20,6 +20,13 @@ const EXCLUSIVE_PAIRS = [
     [':valid', ':invalid'],
     [':in-range', ':out-of-range'],
     [':required', ':optional'],
+    [':user-valid', ':user-invalid'],
+    [':playing', ':paused'],
+    [':dir(ltr)', ':dir(rtl)'],
+    [':nth-child(odd)', ':nth-child(even)'],
+    [':nth-last-child(odd)', ':nth-last-child(even)'],
+    [':nth-of-type(odd)', ':nth-of-type(even)'],
+    [':nth-last-of-type(odd)', ':nth-last-of-type(even)'],
 ].map((pair) => pair.slice().sort().join('\0'));
 const isNameChar = (char) => /[\w-]/.test(char);
 const skipName = (selector, from) => {
@@ -153,6 +160,24 @@ const negationOf = (state) => {
         return null;
     return state.slice(5, -1).trim();
 };
+const exactAttributeOf = (state) => {
+    const match = /^\[\s*([\w-]+)\s*=\s*(?:"([^"\\]*)"|'([^'\\]*)'|([\w-]+))\s*([is])?\s*\]$/i.exec(state);
+    if (!match)
+        return null;
+    return {
+        name: match[1],
+        value: (match[2] ?? match[3] ?? match[4]).toLowerCase(),
+    };
+};
+const attributeNameOf = (state) => /^\[\s*([\w-]+)/.exec(state)?.[1] ?? null;
+const absentAttribute = (negated, other) => negated !== null &&
+    /^\[\s*[\w-]+\s*\]$/.test(negated) &&
+    attributeNameOf(negated) === attributeNameOf(other);
+const differentAttributeValues = (first, second) => {
+    const a = exactAttributeOf(first);
+    const b = exactAttributeOf(second);
+    return a !== null && b !== null && a.name === b.name && a.value !== b.value;
+};
 function areExclusive(first, second) {
     const left = new Set(statesOf(first));
     const right = new Set(statesOf(second));
@@ -164,6 +189,11 @@ function areExclusive(first, second) {
                 return true;
             if (EXCLUSIVE_PAIRS.includes([a, b].sort().join('\0')))
                 return true;
+            if (differentAttributeValues(a, b))
+                return true;
+            if (absentAttribute(negationOf(a), b) ||
+                absentAttribute(negationOf(b), a))
+                return true;
         }
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/eslint-plugin",
-  "version": "21.1.1",
+  "version": "21.1.2",
   "description": "Plumeria ESLint plugin",
   "author": "Refirst 11",
   "license": "MIT",
@@ -59,7 +59,7 @@
   "dependencies": {
     "oxlint": "1.87.0",
     "zss-engine": "3.0.1",
-    "@plumeria/compiler": "21.1.1"
+    "@plumeria/compiler": "21.1.2"
   },
   "scripts": {
     "build": "rimraf dist && pnpm cjs",