@plumeria/eslint-plugin 0.19.2 → 0.19.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/eslint-plugin",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "description": "Plumeria ESLint plugin",
   "repository": {
     "type": "git",
@@ -8,15 +8,20 @@
     "directory": "packages/eslint-plugin"
   },
   "license": "MIT",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "lib/"
+    "dist/"
   ],
   "devDependencies": {
+    "@typescript-eslint/utils": "^8.44.1",
     "eslint": "^9.15.0"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf dist && pnpm cjs",
+    "cjs": "tsc --project tsconfig.cjs.json"
   }
 }

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,51 +0,0 @@
-'use strict';
-
-const noDestructure = require('./rules/no-destructure.js');
-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-destructure': noDestructure,
-  'no-inner-call': noInnerCall,
-  'no-unused-keys': noUnusedKeys,
-  'sort-properties': sortProperties,
-  'validate-values': 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',
-    },
-  },
-};
-
-module.exports = {
-  rules,
-  configs,
-  flatConfigs,
-};

package/lib/rules/no-destructure.js

@@ -1,52 +0,0 @@
-/**
- * @fileoverview Restrict destructure css.create and css.global
- * Compatible with eslint 8 and below or 9 and above
- */
-
-'use strict';
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow destructuring css.props and css.global',
-      recommended: true,
-    },
-    messages: {
-      noDestructure:
-        'Do not destructure "{{name}}" from "css". Use dot notation instead.',
-    },
-    schema: [],
-  },
-  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/lib/rules/no-inner-call.js

@@ -1,69 +0,0 @@
-/**
- * @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) {
-          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 === 'keyframes' ||
-                propertyName === 'viewTransition' ||
-                propertyName.startsWith('define')
-              ) {
-                context.report({
-                  node,
-                  messageId: 'noInnerCall',
-                  data: { name: fullName },
-                });
-              }
-            }
-          }
-        }
-      },
-    };
-  },
-};

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

@@ -1,111 +0,0 @@
-/**
- * @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 {
-      CallExpression(node) {
-        if (
-          node.callee.type === 'MemberExpression' &&
-          node.callee.object.name === 'css' &&
-          node.callee.property.name === 'create'
-        ) {
-          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);
-          }
-        }
-      },
-      MemberExpression(node) {
-        if (
-          node.object.type === 'Identifier' &&
-          node.property.type === 'Identifier'
-        ) {
-          const normalKey = `${node.object.name}.${node.property.name}`;
-          const dollerKey = `${node.object.name}.$${node.property.name}`;
-          referencedKeys.add(normalKey);
-          referencedKeys.add(dollerKey);
-
-          if (parserServices && checker) {
-            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-            const symbol = checker.getSymbolAtLocation(tsNode);
-            if (symbol) {
-              referencedKeys.add(normalKey);
-              referencedKeys.add(dollerKey);
-            }
-          }
-        }
-      },
-      'Program:exit'() {
-        definedKeys.forEach((keyMap, variableName) => {
-          keyMap.forEach((keyNode, keyName) => {
-            const normalKey = `${variableName}.${keyName}`;
-            const dollerKey = `${variableName}.$${keyName}`;
-            if (
-              !referencedKeys.has(normalKey) &&
-              !referencedKeys.has(dollerKey)
-            ) {
-              context.report({
-                node: keyNode,
-                messageId: 'unusedKey',
-                data: { key: keyName },
-              });
-            }
-          });
-        });
-      },
-    };
-  },
-};

package/lib/rules/sort-properties.js

@@ -1,131 +0,0 @@
-/**
- * @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}`,
-              );
-            },
-          });
-        });
-      },
-    };
-  },
-};