@plumeria/eslint-plugin 0.19.1 → 0.19.3

package/README.md

@@ -14,7 +14,7 @@ The `plugin:@plumeria/recommended` config enables the following:
 - `@plumeria/validate-values`: **warn**
 
 ```js
-import plumeria from '@plumeria/eslint-plugin';
+import { plumeria } from '@plumeria/eslint-plugin';
 
 export default [plumeria.flatConfigs.recommended];
 ```
@@ -27,7 +27,7 @@ Disallow destructuring `css.create` and `css.props`, etc.
 
 ### no-inner-call
 
-Disallow calling `css.create`, `css.global`, etc. inside functions.
+Disallow calling `css.create`, etc. inside functions.
 
 ### no-unused-keys
 

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { ESLint, Linter, Rule } from 'eslint';
+export declare const plumeria: ESLint.Plugin & {
+    rules: {
+        "no-destructure": Rule.RuleModule;
+        "no-inner-call": Rule.RuleModule;
+        "no-unused-keys": Rule.RuleModule;
+        "sort-properties": Rule.RuleModule;
+        "validate-values": Rule.RuleModule;
+    };
+    configs: {
+        recommended: Linter.LegacyConfig;
+    };
+    flatConfigs: {
+        recommended: Linter.Config<Linter.RulesRecord>;
+    };
+};

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plumeria = void 0;
+const no_destructure_1 = require("./rules/no-destructure");
+const no_inner_call_js_1 = require("./rules/no-inner-call.js");
+const no_unused_keys_1 = require("./rules/no-unused-keys");
+const sort_properties_1 = require("./rules/sort-properties");
+const validate_values_1 = require("./rules/validate-values");
+const rules = {
+    'no-destructure': no_destructure_1.noDestructure,
+    'no-inner-call': no_inner_call_js_1.noInnerCall,
+    'no-unused-keys': no_unused_keys_1.noUnusedKeys,
+    'sort-properties': sort_properties_1.sortProperties,
+    'validate-values': validate_values_1.validateValues,
+};
+const configs = {
+    recommended: {
+        plugins: ['@plumeria'],
+        rules: {
+            '@plumeria/no-destructure': 'error',
+            '@plumeria/no-inner-call': 'error',
+            '@plumeria/no-unused-keys': 'warn',
+            '@plumeria/sort-properties': 'warn',
+            '@plumeria/validate-values': 'warn',
+        },
+    },
+};
+const flatConfigs = {
+    recommended: {
+        plugins: {
+            '@plumeria': {
+                rules,
+            },
+        },
+        rules: {
+            '@plumeria/no-destructure': 'error',
+            '@plumeria/no-inner-call': 'error',
+            '@plumeria/no-unused-keys': 'warn',
+            '@plumeria/sort-properties': 'warn',
+            '@plumeria/validate-values': 'warn',
+        },
+    },
+};
+exports.plumeria = {
+    rules,
+    configs,
+    flatConfigs,
+};

package/dist/rules/no-destructure.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noDestructure: ESLintUtils.RuleModule<"noDestructure", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/no-destructure.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDestructure = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => name);
+exports.noDestructure = createRule({
+    name: 'no-destructure',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow destructuring css.props and css.global',
+        },
+        messages: {
+            noDestructure: 'Do not destructure "{{name}}" from "css". Use dot notation instead.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === 'ObjectPattern' &&
+                    node.init &&
+                    node.init.type === 'Identifier' &&
+                    node.init.name === 'css') {
+                    for (const prop of node.id.properties) {
+                        if (prop.type === 'Property' &&
+                            prop.key.type === 'Identifier' &&
+                            (prop.key.name === 'create' ||
+                                prop.key.name === 'props' ||
+                                prop.key.name === 'keyframes' ||
+                                prop.key.name === 'viewTransition' ||
+                                prop.key.name.startsWith('define'))) {
+                            context.report({
+                                node: prop,
+                                messageId: 'noDestructure',
+                                data: { name: prop.key.name },
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-inner-call.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noInnerCall: ESLintUtils.RuleModule<"noInnerCall", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/no-inner-call.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noInnerCall = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => name);
+exports.noInnerCall = createRule({
+    name: 'no-inner-call',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'An error occurs if a specific call is made within a function',
+        },
+        messages: {
+            noInnerCall: 'Do not use {{name}} inside functions',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        let functionDepth = 0;
+        return {
+            FunctionDeclaration() {
+                functionDepth++;
+            },
+            FunctionExpression() {
+                functionDepth++;
+            },
+            ArrowFunctionExpression() {
+                functionDepth++;
+            },
+            'FunctionDeclaration:exit'() {
+                functionDepth--;
+            },
+            'FunctionExpression:exit'() {
+                functionDepth--;
+            },
+            'ArrowFunctionExpression:exit'() {
+                functionDepth--;
+            },
+            CallExpression(node) {
+                if (functionDepth > 0) {
+                    if (node.callee.type === 'MemberExpression' &&
+                        'name' in node.callee.object &&
+                        'name' in node.callee.property) {
+                        const objectName = node.callee.object.name;
+                        const propertyName = node.callee.property.name;
+                        if (objectName === 'css') {
+                            const fullName = `${objectName}.${propertyName}`;
+                            if (propertyName === 'create' ||
+                                propertyName === 'keyframes' ||
+                                propertyName === 'viewTransition' ||
+                                propertyName.startsWith('define')) {
+                                context.report({
+                                    node,
+                                    messageId: 'noInnerCall',
+                                    data: { name: fullName },
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unused-keys.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noUnusedKeys: ESLintUtils.RuleModule<"unusedKey", [], unknown, ESLintUtils.RuleListener>;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnusedKeys = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => name);
+function getFilename(context) {
+    return context.getFilename ? context.getFilename() : context.filename;
+}
+exports.noUnusedKeys = createRule({
+    name: 'no-unused-keys',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Detect unused object keys if they are not referenced anywhere',
+        },
+        messages: {
+            unusedKey: "The key '{{ key }}' is defined but never referenced anywhere.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = getFilename(context);
+        if (filename.endsWith('.ts')) {
+            return {};
+        }
+        const parserServices = context.parserServices;
+        const checker = parserServices?.program?.getTypeChecker();
+        const definedKeys = new Map();
+        const referencedKeys = new Set();
+        return {
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    'name' in node.callee.object &&
+                    'name' in node.callee.property &&
+                    node.callee.object.name === 'css' &&
+                    node.callee.property.name === 'create') {
+                    const arg = node.arguments[0];
+                    if (arg &&
+                        arg.type === 'ObjectExpression' &&
+                        node.parent.type === 'VariableDeclarator' &&
+                        'name' in node.parent.id) {
+                        const variableName = node.parent.id.name;
+                        const keyMap = new Map();
+                        arg.properties.forEach((prop) => {
+                            if (prop.type === 'Property' &&
+                                prop.key &&
+                                prop.key.type === 'Identifier' &&
+                                prop.value.type === 'ObjectExpression') {
+                                keyMap.set(prop.key.name, prop.key);
+                            }
+                        });
+                        definedKeys.set(variableName, keyMap);
+                    }
+                }
+            },
+            MemberExpression(node) {
+                if (node.object.type === 'Identifier' &&
+                    node.property.type === 'Identifier') {
+                    const normalKey = `${node.object.name}.${node.property.name}`;
+                    referencedKeys.add(normalKey);
+                    if (parserServices && checker) {
+                        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                        const symbol = checker.getSymbolAtLocation(tsNode);
+                        if (symbol) {
+                            referencedKeys.add(normalKey);
+                        }
+                    }
+                }
+            },
+            'Program:exit'() {
+                definedKeys.forEach((keyMap, variableName) => {
+                    keyMap.forEach((keyNode, keyName) => {
+                        const normalKey = `${variableName}.${keyName}`;
+                        if (!referencedKeys.has(normalKey)) {
+                            context.report({
+                                node: keyNode,
+                                messageId: 'unusedKey',
+                                data: { key: keyName },
+                            });
+                        }
+                    });
+                });
+            },
+        };
+    },
+});

package/dist/rules/sort-properties.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const sortProperties: ESLintUtils.RuleModule<"sortProperties", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/sort-properties.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortProperties = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const propertyGroups_1 = require("../util/propertyGroups");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => name);
+function getSourceCode(context) {
+    return context.getSourceCode ? context.getSourceCode() : context.sourceCode;
+}
+function getPropertyName(property) {
+    if (property.key.type === 'Literal' && Array.isArray(property.key.value)) {
+        return property.key.value;
+    }
+    if (property.key.type === 'Identifier') {
+        return property.key.name;
+    }
+    if (property.key.type === 'Literal') {
+        return String(property.key.value);
+    }
+    return '';
+}
+function getPropertyIndex(property, isTopLevel = false) {
+    const name = getPropertyName(property);
+    if (Array.isArray(name)) {
+        return null;
+    }
+    if (isTopLevel &&
+        (property.key.type !== 'Identifier' ||
+            (typeof name === 'string' &&
+                (name.startsWith('&') || name.startsWith(':') || name.startsWith('@'))))) {
+        return null;
+    }
+    let lastGroupIndex = 0;
+    let maxPropIndex = 0;
+    for (let i = 0; i < propertyGroups_1.propertyGroups.length; i++) {
+        const group = propertyGroups_1.propertyGroups[i];
+        const propIndex = group.properties.indexOf(name);
+        if (propIndex !== -1) {
+            return i * 1000 + propIndex;
+        }
+        lastGroupIndex = i;
+        maxPropIndex = Math.max(maxPropIndex, group.properties.length);
+    }
+    if (typeof name === 'string') {
+        if (name.startsWith('&'))
+            return (propertyGroups_1.propertyGroups.length + 1) * 1000;
+        if (name.includes(':'))
+            return (propertyGroups_1.propertyGroups.length + 2) * 1000;
+        if (name.includes('@media'))
+            return (propertyGroups_1.propertyGroups.length + 3) * 1000;
+    }
+    return lastGroupIndex * 1000 + maxPropIndex + 1;
+}
+exports.sortProperties = createRule({
+    name: 'sort-properties',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Sort CSS properties keeping original order for specific keys',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            sortProperties: 'Property "{{property}}" should be at position {{position}}',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ObjectExpression(node) {
+                const sourceCode = getSourceCode(context);
+                const isTopLevel = !node.parent || node.parent.type !== 'Property';
+                const properties = node.properties.filter((prop) => 'key' in prop && !!prop.key);
+                const sorted = [...properties].sort((a, b) => {
+                    const indexA = getPropertyIndex(a, isTopLevel);
+                    const indexB = getPropertyIndex(b, isTopLevel);
+                    return indexA === null || indexB === null ? 0 : indexA - indexB;
+                });
+                const misordered = properties.filter((prop, i) => prop !== sorted[i]);
+                if (misordered.length === 0)
+                    return;
+                const match = sourceCode.getText(node).match(/^{\s*\n(\s*)/);
+                const indent = match ? match[1] : '';
+                const lineEnding = match ? '\n' : ' ';
+                misordered.forEach((prop) => {
+                    context.report({
+                        node: prop,
+                        messageId: 'sortProperties',
+                        data: {
+                            position: sorted.indexOf(prop) + 1,
+                            property: getPropertyName(prop),
+                        },
+                        fix(fixer) {
+                            const newText = sorted
+                                .map((p) => {
+                                const propName = getPropertyName(p);
+                                if (Array.isArray(propName)) {
+                                    const arrayKey = sourceCode.getText(p.key);
+                                    const arrayContent = p.value.properties
+                                        .map((inner) => `${indent}  ${sourceCode.getText(inner)}`)
+                                        .join(`,${lineEnding}`);
+                                    return `${indent}${arrayKey}: {\n${arrayContent}\n${indent}}`;
+                                }
+                                return `${indent}${sourceCode.getText(p)}`;
+                            })
+                                .join(`,${lineEnding}`);
+                            return fixer.replaceTextRange([node.range[0] + 1, node.range[1] - 1], `${lineEnding}${newText}${lineEnding}`);
+                        },
+                    });
+                });
+            },
+        };
+    },
+});

package/dist/rules/validate-values.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const validateValues: ESLintUtils.RuleModule<"validateValue", [], unknown, ESLintUtils.RuleListener>;