@jmruthers/pace-core 0.6.5 → 0.6.7

package/dist/eslint-rules/rules/04-code-quality.cjs

@@ -0,0 +1,290 @@
+/**
+ * Code Quality Rules (Standard 4)
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/rules/code-quality
+ * 
+ * Enforces code quality patterns from Standard 4:
+ * - Naming conventions (hooks: use*, providers: *Provider)
+ * - TypeScript best practices
+ * 
+ * Reference: packages/core/docs/standards/4-code-quality-standards.md
+ */
+
+const { isPaceCoreSourceFile } = require('../utils/helpers.cjs');
+
+module.exports = {
+  rules: {
+    /**
+     * Enforce naming conventions for hooks and providers
+     */
+    'naming-convention': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: 'Enforce naming conventions: hooks must start with "use", providers must end with "Provider"',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/4-code-quality-standards.md'
+        },
+        messages: {
+          hookNaming: "Hook '{{name}}' must start with 'use' (e.g., useEventData, useUserProfile)",
+          providerNaming: "Provider '{{name}}' must end with 'Provider' (e.g., AuthProvider, OrganisationProvider)"
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        return {
+          FunctionDeclaration(node) {
+            if (!node.id) return;
+            
+            const functionName = node.id.name;
+            if (!functionName) return;
+            
+            // Check for hooks (functions that use React hooks)
+            const sourceCode = context.getSourceCode();
+            const functionText = sourceCode.getText(node.body);
+            const usesReactHooks = /use(State|Effect|Callback|Memo|Ref|Context|Reducer|LayoutEffect|ImperativeHandle|DebugValue)/.test(functionText);
+            
+            // Check if function is a hook (starts with 'use' or uses React hooks)
+            if (usesReactHooks || functionName.startsWith('use')) {
+              if (!functionName.startsWith('use')) {
+                context.report({
+                  node: node.id,
+                  messageId: 'hookNaming',
+                  data: { name: functionName },
+                  suggest: [{
+                    desc: `Rename to use${functionName.charAt(0).toUpperCase() + functionName.slice(1)}`,
+                    fix(fixer) {
+                      return null; // Complex rename
+                    }
+                  }]
+                });
+              }
+            }
+            
+            // Check for providers (components that return JSX and have Provider in name or return Provider-like structure)
+            const returnsJSX = functionText.includes('return') && (functionText.includes('<') || functionText.includes('createElement'));
+            const hasProviderPattern = functionName.includes('Provider') || 
+                                      functionText.includes('Provider') ||
+                                      functionText.includes('Context.Provider');
+            
+            if (returnsJSX && hasProviderPattern && !functionName.endsWith('Provider')) {
+              context.report({
+                node: node.id,
+                messageId: 'providerNaming',
+                data: { name: functionName },
+                suggest: [{
+                  desc: `Rename to ${functionName}Provider`,
+                  fix(fixer) {
+                    return null; // Complex rename
+                  }
+                }]
+              });
+            }
+          },
+          
+          VariableDeclarator(node) {
+            if (!node.id || node.id.type !== 'Identifier') return;
+            if (!node.init) return;
+            
+            const varName = node.id.name;
+            if (!varName) return;
+            
+            // Check for hook variables (arrow functions that use React hooks)
+            if (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression') {
+              const sourceCode = context.getSourceCode();
+              const functionText = sourceCode.getText(node.init);
+              const usesReactHooks = /use(State|Effect|Callback|Memo|Ref|Context|Reducer|LayoutEffect|ImperativeHandle|DebugValue)/.test(functionText);
+              
+              if (usesReactHooks && !varName.startsWith('use')) {
+                context.report({
+                  node: node.id,
+                  messageId: 'hookNaming',
+                  data: { name: varName },
+                  suggest: [{
+                    desc: `Rename to use${varName.charAt(0).toUpperCase() + varName.slice(1)}`,
+                    fix(fixer) {
+                      return null; // Complex rename
+                    }
+                  }]
+                });
+              }
+            }
+          }
+        };
+      }
+    },
+
+    /**
+     * Enforce component naming: PascalCase
+     */
+    'component-naming': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: 'Enforce component naming: components must use PascalCase',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/4-code-quality-standards.md'
+        },
+        messages: {
+          componentNaming: "Component '{{name}}' must use PascalCase (e.g., EventCard, UserProfile)"
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        const isComponentFile = filename.match(/(components|Components)\//);
+        if (!isComponentFile) {
+          return {};
+        }
+        
+        return {
+          FunctionDeclaration(node) {
+            if (!node.id) return;
+            
+            const functionName = node.id.name;
+            if (!functionName) return;
+            
+            // Check if it's a component (returns JSX)
+            const sourceCode = context.getSourceCode();
+            const functionText = sourceCode.getText(node.body);
+            const returnsJSX = functionText.includes('return') && (functionText.includes('<') || functionText.includes('createElement'));
+            
+            if (returnsJSX) {
+              // Check if it's PascalCase
+              const isPascalCase = /^[A-Z][a-zA-Z0-9]*$/.test(functionName);
+              if (!isPascalCase) {
+                context.report({
+                  node: node.id,
+                  messageId: 'componentNaming',
+                  data: { name: functionName },
+                  suggest: [{
+                    desc: `Rename to ${functionName.charAt(0).toUpperCase() + functionName.slice(1).replace(/[^a-zA-Z0-9]/g, '')}`,
+                    fix(fixer) {
+                      return null; // Complex rename
+                    }
+                  }]
+                });
+              }
+            }
+          },
+          
+          VariableDeclarator(node) {
+            if (!node.id || node.id.type !== 'Identifier') return;
+            if (!node.init) return;
+            
+            const varName = node.id.name;
+            if (!varName) return;
+            
+            // Check for component variables (arrow functions that return JSX)
+            if (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression') {
+              const sourceCode = context.getSourceCode();
+              const functionText = sourceCode.getText(node.init);
+              const returnsJSX = functionText.includes('return') && (functionText.includes('<') || functionText.includes('createElement'));
+              
+              if (returnsJSX) {
+                const isPascalCase = /^[A-Z][a-zA-Z0-9]*$/.test(varName);
+                if (!isPascalCase) {
+                  context.report({
+                    node: node.id,
+                    messageId: 'componentNaming',
+                    data: { name: varName },
+                    suggest: [{
+                      desc: `Rename to ${varName.charAt(0).toUpperCase() + varName.slice(1).replace(/[^a-zA-Z0-9]/g, '')}`,
+                      fix(fixer) {
+                        return null; // Complex rename
+                      }
+                    }]
+                  });
+                }
+              }
+            }
+          }
+        };
+      }
+    },
+
+    /**
+     * Enforce type/interface naming: PascalCase
+     */
+    'type-naming': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: 'Enforce type/interface naming: types and interfaces must use PascalCase',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/4-code-quality-standards.md'
+        },
+        messages: {
+          typeNaming: "Type/interface '{{name}}' must use PascalCase (e.g., EventStatus, UserProfile)"
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        return {
+          TSInterfaceDeclaration(node) {
+            const interfaceName = node.id.name;
+            if (!interfaceName) return;
+            
+            const isPascalCase = /^[A-Z][a-zA-Z0-9]*$/.test(interfaceName);
+            if (!isPascalCase) {
+              context.report({
+                node: node.id,
+                messageId: 'typeNaming',
+                data: { name: interfaceName },
+                suggest: [{
+                  desc: `Rename to ${interfaceName.charAt(0).toUpperCase() + interfaceName.slice(1).replace(/[^a-zA-Z0-9]/g, '')}`,
+                  fix(fixer) {
+                    return null; // Complex rename
+                  }
+                }]
+              });
+            }
+          },
+          
+          TSTypeAliasDeclaration(node) {
+            const typeName = node.id.name;
+            if (!typeName) return;
+            
+            const isPascalCase = /^[A-Z][a-zA-Z0-9]*$/.test(typeName);
+            if (!isPascalCase) {
+              context.report({
+                node: node.id,
+                messageId: 'typeNaming',
+                data: { name: typeName },
+                suggest: [{
+                  desc: `Rename to ${typeName.charAt(0).toUpperCase() + typeName.slice(1).replace(/[^a-zA-Z0-9]/g, '')}`,
+                  fix(fixer) {
+                    return null; // Complex rename
+                  }
+                }]
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+};

package/dist/eslint-rules/rules/05-styling.cjs

@@ -0,0 +1,61 @@
+/**
+ * Styling Rules (Standard 5)
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/rules/styling
+ * 
+ * Enforces styling patterns from Standard 5:
+ * - No inline styles (use pace-core components or Tailwind classes)
+ * 
+ * Reference: packages/core/docs/standards/5-styling-standards.md
+ */
+
+const { isPaceCoreSourceFile } = require('../utils/helpers.cjs');
+
+module.exports = {
+  rules: {
+    /**
+     * Disallow inline styles
+     */
+    'no-inline-styles': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Disallow inline styles. Use pace-core components or Tailwind classes instead.',
+          category: 'Best Practices',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/5-styling-standards.md'
+        },
+        messages: {
+          inlineStyle: 'Inline style detected. Use pace-core components or Tailwind classes instead.'
+        },
+        hasSuggestions: true
+      },
+      create(context) {
+        const filename = context.getFilename();
+        
+        // Exclude pace-core source files - these rules are for consuming apps
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        
+        return {
+          JSXAttribute(node) {
+            if (node.name && node.name.name === 'style') {
+              context.report({
+                node,
+                messageId: 'inlineStyle',
+                suggest: [{
+                  desc: 'Remove inline style and use pace-core component styling or Tailwind utility classes',
+                  fix(fixer) {
+                    // Remove the style attribute
+                    return fixer.remove(node);
+                  }
+                }]
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+};