@craft-ng/dev-tools 0.5.0-beta.0 → 0.5.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-ng/dev-tools",
-  "version": "0.5.0-beta.0",
+  "version": "0.5.0-beta.2",
   "description": "Development tools for ng-craft: ESLint configs, ESLint rules, and codemods",
   "type": "module",
   "main": "./src/index.js",

package/src/eslint-rules/brand-angular-deps-match.cjs

@@ -85,9 +85,20 @@ module.exports = {
           path.dirname(filePath),
           getCwd(context),
         );
+        if (process.env.DEBUG_CRAFT_RULE) {
+          console.log('[DEBUG] file text snippet:', text.substring(0, 300));
+          console.log('[DEBUG] sf text snippet:', sourceFile.getFullText().substring(0, 300));
+        }
         const analysis = analyzeSourceFileDependencies(sourceFile, {
           configFilePath,
         });
+        if (process.env.DEBUG_CRAFT_RULE) {
+          console.log('[DEBUG] analysis deps:', analysis.dependencyGroups);
+          console.log('[DEBUG] generated deps:', analysis.generatedDependencyGroups);
+          console.log('[DEBUG] className:', analysis.className, 'kind:', analysis.angularKind);
+          console.log('[DEBUG] sf has class?', !!sourceFile.getClass('DemoComponent'));
+          console.log('[DEBUG] full sf text:', sourceFile.getFullText());
+        }
         if (
           !analysis.classDeclaration ||
           analysis.skipped ||

package/src/eslint-rules/craft-computed-name-match.cjs

@@ -0,0 +1,125 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure craftComputed(name, ...) is called with a string literal first argument that matches the declared variable or class property name.",
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      missingName:
+        "craftComputed must be called with a string literal name matching '{{declaredName}}' as the first argument.",
+      mismatchedName:
+        "craftComputed first argument '{{actual}}' must match the declared name '{{declaredName}}'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'craftComputed'
+        ) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+        if (!declaredName) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+
+        if (!firstArg) {
+          context.report({
+            node,
+            messageId: 'missingName',
+            data: { declaredName },
+            fix(fixer) {
+              const openParen = sourceCode.getTokenAfter(
+                node.callee,
+                (token) => token.type === 'Punctuator' && token.value === '(',
+              );
+              if (!openParen) return null;
+              return fixer.insertTextAfter(openParen, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        if (isStringLiteral(firstArg)) {
+          const actual = getStringLiteralValue(firstArg);
+          if (actual === declaredName) {
+            return;
+          }
+          context.report({
+            node: firstArg,
+            messageId: 'mismatchedName',
+            data: { declaredName, actual },
+            fix(fixer) {
+              return fixer.replaceText(firstArg, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        context.report({
+          node: firstArg,
+          messageId: 'missingName',
+          data: { declaredName },
+          fix(fixer) {
+            return fixer.insertTextBefore(firstArg, `'${declaredName}', `);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isStringLiteral(node) {
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return true;
+  }
+  if (
+    node.type === 'TemplateLiteral' &&
+    node.expressions.length === 0 &&
+    node.quasis.length === 1
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function getStringLiteralValue(node) {
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  return node.quasis[0].value.cooked;
+}

package/src/eslint-rules/craft-method-name-match.cjs

@@ -0,0 +1,166 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure craftMethod(name, ...) is called with a string literal first argument (or { name } object) that matches the declared variable or class property name.",
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      missingName:
+        "craftMethod must be called with a string literal name matching '{{declaredName}}' as the first argument.",
+      mismatchedName:
+        "craftMethod first argument '{{actual}}' must match the declared name '{{declaredName}}'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'craftMethod'
+        ) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+        if (!declaredName) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+
+        if (!firstArg) {
+          context.report({
+            node,
+            messageId: 'missingName',
+            data: { declaredName },
+            fix(fixer) {
+              const openParen = sourceCode.getTokenAfter(
+                node.callee,
+                (token) => token.type === 'Punctuator' && token.value === '(',
+              );
+              if (!openParen) return null;
+              return fixer.insertTextAfter(openParen, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        // Handle object config form: { name: 'methodName', providers: [...] }
+        if (firstArg.type === 'ObjectExpression') {
+          const nameProp = firstArg.properties.find(
+            (p) =>
+              p.type === 'Property' &&
+              !p.computed &&
+              p.key.type === 'Identifier' &&
+              p.key.name === 'name',
+          );
+          if (!nameProp) {
+            context.report({
+              node: firstArg,
+              messageId: 'missingName',
+              data: { declaredName },
+            });
+            return;
+          }
+          const nameValue = nameProp.value;
+          if (isStringLiteral(nameValue)) {
+            const actual = getStringLiteralValue(nameValue);
+            if (actual === declaredName) {
+              return;
+            }
+            context.report({
+              node: nameValue,
+              messageId: 'mismatchedName',
+              data: { declaredName, actual },
+              fix(fixer) {
+                return fixer.replaceText(nameValue, `'${declaredName}'`);
+              },
+            });
+          } else {
+            context.report({
+              node: nameValue,
+              messageId: 'mismatchedName',
+              data: { declaredName, actual: sourceCode.getText(nameValue) },
+            });
+          }
+          return;
+        }
+
+        if (isStringLiteral(firstArg)) {
+          const actual = getStringLiteralValue(firstArg);
+          if (actual === declaredName) {
+            return;
+          }
+          context.report({
+            node: firstArg,
+            messageId: 'mismatchedName',
+            data: { declaredName, actual },
+            fix(fixer) {
+              return fixer.replaceText(firstArg, `'${declaredName}'`);
+            },
+          });
+          return;
+        }
+
+        context.report({
+          node: firstArg,
+          messageId: 'missingName',
+          data: { declaredName },
+          fix(fixer) {
+            return fixer.insertTextBefore(firstArg, `'${declaredName}', `);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isStringLiteral(node) {
+  if (node.type === 'Literal' && typeof node.value === 'string') {
+    return true;
+  }
+  if (
+    node.type === 'TemplateLiteral' &&
+    node.expressions.length === 0 &&
+    node.quasis.length === 1
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function getStringLiteralValue(node) {
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  return node.quasis[0].value.cooked;
+}

package/src/eslint-rules/index.cjs

@@ -2,11 +2,16 @@ const brandAngularGenDepsRequired = require('./brand-angular-gen-deps-required.c
 const brandAngularDepsMatch = require('./brand-angular-deps-match.cjs');
 const appStartRegistryMatch = require('./app-start-registry-match.cjs');
 const componentTestGenDepsMatch = require('./component-test-gen-deps-match.cjs');
+const craftMethodNameMatch = require('./craft-method-name-match.cjs');
+const craftComputedNameMatch = require('./craft-computed-name-match.cjs');
+const preferCraftComputed = require('./prefer-craft-computed.cjs');
 const noAngularInject = require('./no-angular-inject.cjs');
 const noAngularSignalForms = require('./no-angular-signal-forms.cjs');
+const provideHostNameMatchComponent = require('./provide-host-name-match-component.cjs');
 const preferCraftHttpClient = require('./prefer-craft-http-client.cjs');
 const preferCraftService = require('./prefer-craft-service.cjs');
 const preferBrowserBoundaries = require('./prefer-browser-boundaries.cjs');
+const requireComponentMonitoring = require('./require-component-monitoring.cjs');
 
 module.exports = {
   rules: {
@@ -14,10 +19,15 @@ module.exports = {
     'brand-angular-gen-deps-required': brandAngularGenDepsRequired,
     'brand-angular-deps-match': brandAngularDepsMatch,
     'component-test-gen-deps-match': componentTestGenDepsMatch,
+    'craft-method-name-match': craftMethodNameMatch,
+    'craft-computed-name-match': craftComputedNameMatch,
+    'prefer-craft-computed': preferCraftComputed,
     'no-angular-inject': noAngularInject,
     'no-angular-signal-forms': noAngularSignalForms,
+    'provide-host-name-match-component': provideHostNameMatchComponent,
     'prefer-craft-http-client': preferCraftHttpClient,
     'prefer-craft-service': preferCraftService,
     'prefer-browser-boundaries': preferBrowserBoundaries,
+    'require-component-monitoring': requireComponentMonitoring,
   },
 };

package/src/eslint-rules/prefer-craft-computed.cjs

@@ -0,0 +1,105 @@
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Prefer craftComputed() over computed() from @angular/core for better observability and host name tracking.",
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      preferCraftComputed:
+        "Use craftComputed('{{name}}', ...) instead of computed() for better observability. craftComputed adds HostName tracking to the computed signal.",
+      preferCraftComputedUnnamed:
+        "Use craftComputed('name', ...) instead of computed() for better observability. craftComputed adds HostName tracking to the computed signal.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'computed'
+        ) {
+          return;
+        }
+
+        if (!isAngularComputedImport(node, context)) {
+          return;
+        }
+
+        const declaredName = getDeclaredName(node);
+
+        if (declaredName) {
+          context.report({
+            node,
+            messageId: 'preferCraftComputed',
+            data: { name: declaredName },
+            suggest: [
+              {
+                desc: `Replace with craftComputed('${declaredName}', ...)`,
+                fix(fixer) {
+                  return fixer.replaceText(node.callee, 'craftComputed');
+                },
+              },
+            ],
+          });
+        } else {
+          context.report({
+            node,
+            messageId: 'preferCraftComputedUnnamed',
+          });
+        }
+      },
+    };
+  },
+};
+
+function getDeclaredName(callNode) {
+  const parent = callNode.parent;
+  if (!parent) return undefined;
+
+  if (
+    parent.type === 'VariableDeclarator' &&
+    parent.init === callNode &&
+    parent.id.type === 'Identifier'
+  ) {
+    return parent.id.name;
+  }
+
+  if (
+    parent.type === 'PropertyDefinition' &&
+    parent.value === callNode &&
+    !parent.computed &&
+    parent.key.type === 'Identifier'
+  ) {
+    return parent.key.name;
+  }
+
+  return undefined;
+}
+
+function isAngularComputedImport(callNode, context) {
+  const scope = context.getScope ? context.getScope() : context.sourceCode.getScope(callNode);
+
+  let currentScope = scope;
+  while (currentScope) {
+    for (const variable of currentScope.variables) {
+      if (variable.name === 'computed') {
+        for (const def of variable.defs) {
+          if (
+            def.type === 'ImportBinding' &&
+            def.parent &&
+            def.parent.source &&
+            def.parent.source.value === '@angular/core'
+          ) {
+            return true;
+          }
+        }
+      }
+    }
+    currentScope = currentScope.upper;
+  }
+
+  return false;
+}