@plumeria/eslint-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) zss-in-js contributer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import { ESLint, Linter, Rule } from 'eslint';
+
+declare const plugin: ESLint.Plugin & {
+  rules: {
+    '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>;
+  };
+};
+
+export = plugin;

package/lib/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const noInnerCall = require('./rules/no-inner-call.js');
+const noUnusedKeys = require('./rules/no-unused-keys.js');
+const sortProperties = require('./rules/sort-properties.js');
+const validateValues = require('./rules/validate-values.js');
+
+const rules = {
+  'no-inner-call': noInnerCall,
+  'no-unused-keys': noUnusedKeys,
+  'sort-properties': sortProperties,
+  'validate-values': validateValues,
+};
+
+const configs = {
+  recommended: {
+    plugins: ['@plumeria'],
+    rules: {
+      '@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-inner-call': 'error',
+      '@plumeria/no-unused-keys': 'warn',
+      '@plumeria/sort-properties': 'warn',
+      '@plumeria/validate-values': 'warn',
+    },
+  },
+};
+
+module.exports = {
+  rules,
+  configs,
+  flatConfigs,
+};

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

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Restrict calls inside a function
+ * Compatible with eslint 8 and below or 9 and above
+ */
+
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'An error occurs if a specific call is made within a function',
+      recommended: true,
+    },
+    messages: {
+      noInnerCall: 'Do not use {{name}} inside functions',
+    },
+  },
+  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) {
+          // メンバー式（MemberExpression）の場合の処理
+          if (node.callee.type === 'MemberExpression') {
+            const objectName = node.callee.object.name;
+            const propertyName = node.callee.property.name;
+
+            if (objectName === 'css') {
+              const fullName = `${objectName}.${propertyName}`;
+              if (
+                propertyName === 'create' ||
+                propertyName === 'global' ||
+                propertyName === 'keyframes' ||
+                propertyName === 'defineThemeVars'
+              ) {
+                context.report({
+                  node,
+                  messageId: 'noInnerCall',
+                  data: { name: fullName },
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Warns about unused keys in objects inside functions
+ * Compatible with eslint 8 and below or 9 and above
+ */
+
+'use strict';
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @returns {import('eslint').Filename}
+ */
+function getFilename(context) {
+  return context.getFilename ? context.getFilename() : context.filename;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect unused object keys if they are not referenced anywhere',
+      recommended: true,
+    },
+    messages: {
+      unusedKey: "The key '{{ key }}' is defined but never referenced anywhere.",
+    },
+  },
+
+  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 {
+      // Filter out `css.global` and find objects in functions
+      CallExpression(node) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          node.callee.object.name === 'css' &&
+          node.callee.property.name !== 'global' &&
+          node.callee.property.name !== 'defineThemeVars' &&
+          node.callee.property.name !== 'keyframes'
+        ) {
+          const arg = node.arguments[0];
+          if (arg && arg.type === 'ObjectExpression' && node.parent.type === 'VariableDeclarator') {
+            const variableName = node.parent.id.name;
+            const keyMap = new Map();
+
+            arg.properties.forEach((prop) => {
+              if (prop.key && prop.key.type === 'Identifier' && prop.value.type === 'ObjectExpression') {
+                keyMap.set(prop.key.name, prop.key);
+              }
+            });
+
+            definedKeys.set(variableName, keyMap);
+          }
+        }
+      },
+      // `styles.header_main` の参照を記録
+      MemberExpression(node) {
+        if (node.object.type === 'Identifier' && node.property.type === 'Identifier') {
+          const fullKey = `${node.object.name}.${node.property.name}`;
+          referencedKeys.add(fullKey);
+
+          // TypeScript の型情報を取得し、ジャンプ可能かチェック
+          if (parserServices && checker) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const symbol = checker.getSymbolAtLocation(tsNode);
+            if (symbol) {
+              referencedKeys.add(fullKey);
+            }
+          }
+        }
+      },
+      'Program:exit'() {
+        definedKeys.forEach((keyMap, variableName) => {
+          keyMap.forEach((keyNode, keyName) => {
+            const fullKey = `${variableName}.${keyName}`;
+            if (!referencedKeys.has(fullKey)) {
+              context.report({
+                node: keyNode,
+                messageId: 'unusedKey',
+                data: { key: keyName },
+              });
+            }
+          });
+        });
+      },
+    };
+  },
+};

package/lib/rules/sort-properties.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview CSS properties recess base reorder fix feature
+ * Compatible with eslint 8 and below or 9 and above
+ */
+
+'use strict';
+
+const propertyGroups = require('../util/propertyGroups');
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @returns {import('eslint').SourceCode}
+ */
+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;
+  }
+  return property.key.name || property.key.value || '';
+}
+
+function getPropertyIndex(property, isTopLevel = false) {
+  const name = getPropertyName(property);
+
+  if (
+    isTopLevel &&
+    (property.key.type !== 'Identifier' || name.startsWith('&') || name.startsWith(':') || name.startsWith('@'))
+  ) {
+    return null;
+  }
+
+  let lastGroupIndex = 0;
+  let maxPropIndex = 0;
+
+  for (let i = 0; i < propertyGroups.length; i++) {
+    const group = 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.length + 1) * 1000;
+    if (name.includes(':')) return (propertyGroups.length + 2) * 1000;
+    if (name.includes('@media')) return (propertyGroups.length + 3) * 1000;
+  }
+
+  return lastGroupIndex * 1000 + maxPropIndex + 1;
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Sort CSS properties keeping original order for specific keys',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      sortProperties: 'Property "{{property}}" should be at position {{position}}',
+    },
+  },
+
+  create(context) {
+    return {
+      ObjectExpression(node) {
+        const sourceCode = getSourceCode(context);
+        const isTopLevel = !node.parent || node.parent.type !== 'Property';
+        const properties = node.properties.filter((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) => {
+                  if (Array.isArray(getPropertyName(p))) {
+                    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}`
+              );
+            },
+          });
+        });
+      },
+    };
+  },
+};