@craft-ts/dev-tools 0.7.0-beta.13

package/src/eslint-rules/provide-host-name-match-component.cjs

@@ -0,0 +1,455 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  IndentationText,
+  Node,
+  Project,
+  QuoteKind,
+  SyntaxKind,
+} = require('ts-morph');
+
+const projectCache = new Map();
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        "Ensure Angular @Component and @Directive classes provide provideHostName('ClassName') in providers.",
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    return {
+      'Program:exit'() {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const filePath = getFilePath(context);
+        if (!filePath || !filePath.endsWith('.ts')) {
+          return;
+        }
+
+        const text = sourceCode.getText();
+        if (!text.includes('@Component') && !text.includes('@Directive')) {
+          return;
+        }
+
+        const sourceFile = getProjectSourceFile(
+          getProject(getCwd(context)),
+          filePath,
+          text,
+        );
+        const issues = collectHostNameIssues(sourceFile);
+        if (issues.length === 0) {
+          return;
+        }
+
+        const reportLoc = getNodeLoc(sourceCode, issues[0].reportNode);
+
+        for (const issue of issues) {
+          applyIssueFix(issue);
+        }
+        ensureProvideHostNameImport(sourceFile);
+
+        const fixedText = sourceFile.getFullText();
+        if (fixedText === text) {
+          return;
+        }
+
+        context.report({
+          loc: reportLoc,
+          message: formatIssueMessage(issues),
+          fix(fixer) {
+            return fixer.replaceTextRange([0, text.length], fixedText);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getProject(cwd) {
+  let project = projectCache.get(cwd);
+  if (project) {
+    return project;
+  }
+
+  const manipulationSettings = {
+    indentationText: IndentationText.TwoSpaces,
+    quoteKind: QuoteKind.Single,
+  };
+  const tsConfigFilePath = path.join(cwd, 'tsconfig.json');
+  project = fs.existsSync(tsConfigFilePath)
+    ? new Project({
+        tsConfigFilePath,
+        manipulationSettings,
+      })
+    : new Project({
+        compilerOptions: {
+          experimentalDecorators: true,
+          target: 9,
+        },
+        manipulationSettings,
+      });
+
+  projectCache.set(cwd, project);
+  return project;
+}
+
+function getProjectSourceFile(project, filePath, text) {
+  const normalizedPath = path.resolve(filePath);
+  const existingSourceFile = project.getSourceFile(normalizedPath);
+  if (existingSourceFile) {
+    existingSourceFile.replaceWithText(text);
+    return existingSourceFile;
+  }
+
+  const sourceFile = project.addSourceFileAtPathIfExists(normalizedPath);
+  if (sourceFile) {
+    sourceFile.replaceWithText(text);
+    return sourceFile;
+  }
+
+  return project.createSourceFile(normalizedPath, text, { overwrite: true });
+}
+
+function getFilePath(context) {
+  const filePath = context.filename ?? context.getFilename();
+  if (!filePath || filePath === '<input>') {
+    return undefined;
+  }
+
+  return filePath;
+}
+
+function getCwd(context) {
+  return context.cwd ?? process.cwd();
+}
+
+function getNodeLoc(sourceCode, node) {
+  return {
+    start: sourceCode.getLocFromIndex(node.getStart()),
+    end: sourceCode.getLocFromIndex(node.getEnd()),
+  };
+}
+
+function collectHostNameIssues(sourceFile) {
+  const angularDecorators = collectAngularDecoratorNames(sourceFile);
+  if (
+    angularDecorators.componentNames.size === 0 &&
+    angularDecorators.directiveNames.size === 0 &&
+    angularDecorators.namespaceNames.size === 0
+  ) {
+    return [];
+  }
+
+  const issues = [];
+
+  for (const classDeclaration of sourceFile.getClasses()) {
+    const className = classDeclaration.getName();
+    if (!className) {
+      continue;
+    }
+
+    const decoratorMatch = findAngularDecorator(
+      classDeclaration,
+      angularDecorators,
+    );
+    if (!decoratorMatch) {
+      continue;
+    }
+
+    const metadata = getDecoratorMetadata(decoratorMatch.decorator);
+    if (!metadata) {
+      continue;
+    }
+
+    const providersProperty = getObjectProperty(metadata, 'providers');
+    if (!providersProperty) {
+      issues.push({
+        kind: 'missing-providers',
+        decoratorKind: decoratorMatch.kind,
+        className,
+        metadata,
+        reportNode: classDeclaration,
+      });
+      continue;
+    }
+
+    const providersArray = getArrayInitializer(providersProperty);
+    if (!providersArray) {
+      continue;
+    }
+
+    const hostNameCalls = findProvideHostNameCalls(providersArray);
+    if (hostNameCalls.length === 0) {
+      issues.push({
+        kind: 'missing-call',
+        decoratorKind: decoratorMatch.kind,
+        className,
+        providersArray,
+        reportNode: classDeclaration,
+      });
+      continue;
+    }
+
+    const expectedHostName = `${getHostNamePrefix(decoratorMatch.kind)}${className}`;
+    const matchingCall = hostNameCalls.find((callExpression) =>
+      isMatchingHostNameCall(callExpression, expectedHostName),
+    );
+    if (matchingCall) {
+      continue;
+    }
+
+    issues.push({
+      kind: 'mismatched-call',
+      decoratorKind: decoratorMatch.kind,
+      className,
+      callExpression: hostNameCalls[0],
+      reportNode: classDeclaration,
+    });
+  }
+
+  return issues;
+}
+
+function collectAngularDecoratorNames(sourceFile) {
+  const componentNames = new Set();
+  const directiveNames = new Set();
+  const namespaceNames = new Set();
+
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    if (importDeclaration.getModuleSpecifierValue() !== '@angular/core') {
+      continue;
+    }
+
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      const importedName = namedImport.getName();
+      const localName = namedImport.getAliasNode()?.getText() ?? importedName;
+
+      if (importedName === 'Component') {
+        componentNames.add(localName);
+      }
+      if (importedName === 'Directive') {
+        directiveNames.add(localName);
+      }
+    }
+
+    const namespaceImport = importDeclaration.getNamespaceImport();
+    if (namespaceImport) {
+      namespaceNames.add(namespaceImport.getText());
+    }
+  }
+
+  return {
+    componentNames,
+    directiveNames,
+    namespaceNames,
+  };
+}
+
+function findAngularDecorator(classDeclaration, angularDecorators) {
+  for (const decorator of classDeclaration.getDecorators()) {
+    const expression = decorator.getExpression();
+    if (!Node.isCallExpression(expression)) {
+      continue;
+    }
+
+    const callee = expression.getExpression();
+    if (Node.isIdentifier(callee)) {
+      const decoratorName = callee.getText();
+      if (angularDecorators.componentNames.has(decoratorName)) {
+        return { decorator, kind: 'component' };
+      }
+      if (angularDecorators.directiveNames.has(decoratorName)) {
+        return { decorator, kind: 'directive' };
+      }
+      continue;
+    }
+
+    if (!Node.isPropertyAccessExpression(callee)) {
+      continue;
+    }
+
+    const objectExpression = callee.getExpression();
+    const propertyName = callee.getName();
+    if (
+      Node.isIdentifier(objectExpression) &&
+      angularDecorators.namespaceNames.has(objectExpression.getText())
+    ) {
+      if (propertyName === 'Component') {
+        return { decorator, kind: 'component' };
+      }
+      if (propertyName === 'Directive') {
+        return { decorator, kind: 'directive' };
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function getHostNamePrefix(kind) {
+  return kind === 'directive' ? 'directive:' : 'component:';
+}
+
+function getDecoratorMetadata(decorator) {
+  const expression = decorator.getExpression();
+  if (!Node.isCallExpression(expression)) {
+    return undefined;
+  }
+
+  const [metadataArgument] = expression.getArguments();
+  if (!metadataArgument || !Node.isObjectLiteralExpression(metadataArgument)) {
+    return undefined;
+  }
+
+  return metadataArgument;
+}
+
+function getObjectProperty(objectLiteralExpression, name) {
+  const property = objectLiteralExpression
+    .getProperties()
+    .find(
+      (candidate) =>
+        Node.isPropertyAssignment(candidate) && candidate.getName() === name,
+    );
+
+  return Node.isPropertyAssignment(property) ? property : undefined;
+}
+
+function getArrayInitializer(propertyAssignment) {
+  const initializer = propertyAssignment.getInitializer();
+  if (!initializer || !Node.isArrayLiteralExpression(initializer)) {
+    return undefined;
+  }
+
+  return initializer;
+}
+
+function findProvideHostNameCalls(arrayLiteralExpression) {
+  return arrayLiteralExpression
+    .getElements()
+    .filter((element) => Node.isCallExpression(element))
+    .filter((callExpression) => isProvideHostNameCall(callExpression));
+}
+
+function isProvideHostNameCall(callExpression) {
+  const expression = callExpression.getExpression();
+  if (Node.isIdentifier(expression)) {
+    return expression.getText() === 'provideHostName';
+  }
+
+  if (Node.isPropertyAccessExpression(expression)) {
+    return expression.getName() === 'provideHostName';
+  }
+
+  return false;
+}
+
+function isMatchingHostNameCall(callExpression, expectedHostName) {
+  const [nameArgument] = callExpression.getArguments();
+  if (
+    !nameArgument ||
+    (!Node.isStringLiteral(nameArgument) &&
+      !Node.isNoSubstitutionTemplateLiteral(nameArgument))
+  ) {
+    return false;
+  }
+
+  return nameArgument.getLiteralText() === expectedHostName;
+}
+
+function applyIssueFix(issue) {
+  const expectedHostName = `${getHostNamePrefix(issue.decoratorKind)}${issue.className}`;
+  const expectedCall = `provideHostName('${expectedHostName}')`;
+
+  if (issue.kind === 'missing-providers') {
+    issue.metadata.addPropertyAssignment({
+      name: 'providers',
+      initializer: `[${expectedCall}]`,
+    });
+    return;
+  }
+
+  if (issue.kind === 'missing-call') {
+    issue.providersArray.addElement(expectedCall);
+    return;
+  }
+
+  if (issue.kind === 'mismatched-call') {
+    issue.callExpression.replaceWithText(expectedCall);
+  }
+}
+
+function ensureProvideHostNameImport(sourceFile) {
+  const coreImports = sourceFile
+    .getImportDeclarations()
+    .filter(
+      (importDeclaration) =>
+        importDeclaration.getModuleSpecifierValue() === '@craft-ts/core',
+    );
+
+  for (const importDeclaration of coreImports) {
+    const namedImports = importDeclaration.getNamedImports();
+    const directImport = namedImports.find(
+      (namedImport) =>
+        namedImport.getName() === 'provideHostName' &&
+        !namedImport.getAliasNode(),
+    );
+    if (directImport) {
+      return;
+    }
+  }
+
+  for (const importDeclaration of coreImports) {
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      if (
+        namedImport.getName() === 'provideHostName' &&
+        namedImport.getAliasNode()
+      ) {
+        namedImport.remove();
+      }
+    }
+  }
+
+  const targetImport = coreImports.find(
+    (importDeclaration) => !importDeclaration.getNamespaceImport(),
+  );
+  if (targetImport) {
+    const hasNamedImport = targetImport
+      .getNamedImports()
+      .some((namedImport) => namedImport.getName() === 'provideHostName');
+    if (!hasNamedImport) {
+      targetImport.addNamedImport('provideHostName');
+    }
+    return;
+  }
+
+  const insertIndex = sourceFile
+    .getStatements()
+    .findIndex(
+      (statement) => statement.getKind() !== SyntaxKind.ImportDeclaration,
+    );
+
+  sourceFile.insertImportDeclaration(
+    insertIndex < 0 ? sourceFile.getImportDeclarations().length : insertIndex,
+    {
+      moduleSpecifier: '@craft-ts/core',
+      namedImports: ['provideHostName'],
+    },
+  );
+}
+
+function formatIssueMessage(issues) {
+  if (issues.length === 1) {
+    const issue = issues[0];
+    const expectedHostName = `${getHostNamePrefix(issue.decoratorKind)}${issue.className}`;
+    return `${issue.className} must include provideHostName('${expectedHostName}') in providers.`;
+  }
+
+  const classNames = [...new Set(issues.map((issue) => issue.className))].join(
+    ', ',
+  );
+  return `Classes must include provideHostName('<kind>:<ClassName>') in providers: ${classNames}.`;
+}

package/src/eslint-rules/recommended-config.cjs

@@ -0,0 +1,77 @@
+module.exports = {
+  'craft-ts/craft-method-name-match': 'warn',
+  'craft-ts/craft-computed-name-match': 'warn',
+  'craft-ts/craft-source-name-match': 'warn',
+  'craft-ts/craft-signal-source-name-match': 'warn',
+  'craft-ts/craft-component-name-match': 'warn',
+  'craft-ts/craft-directive-name-match': 'warn',
+  'craft-ts/no-direct-temporal-globals': 'error',
+  'craft-ts/prefer-craft-template-blocks': 'error',
+  'craft-ts/no-render-writes': 'error',
+  'craft-ts/require-reactive-template-bindings': 'error',
+  'craft-ts/craft-css-vars-contract': 'error',
+  'craft-ts/craft-styles-scope-safe': 'error',
+  'craft-ts/craft-css-var-naming': 'warn',
+  'craft-ts/craft-css-token-registry': 'error',
+  'craft-ts/no-hardcoded-design-values': 'warn',
+  'craft-ts/no-important-in-component-styles': 'error',
+  'craft-ts/no-craft-computed-side-effects': 'error',
+  'craft-ts/provide-host-name-match-component': 'warn',
+  'craft-ts/prefer-craft-http-transport': 'error',
+  'craft-ts/no-imperative-craft-resource-trigger': 'error',
+  'craft-ts/no-transition-actions': 'error',
+  'craft-ts/require-craft-resource-trigger-yield': 'error',
+  'craft-ts/prefer-browser-boundaries': 'warn',
+  'craft-ts/app-start-registry-match': 'warn',
+  'craft-ts/global-exception-registry-match': 'warn',
+  'craft-ts/require-component-monitoring': 'warn',
+  'craft-ts/require-primitive-generator-unwrap': 'warn',
+  'craft-ts/require-yieldable-template-method': 'error',
+  'craft-ts/require-craft-method-for-yieldable-callback': 'error',
+  'craft-ts/require-yieldable-reactive-read': 'error',
+  'craft-ts/require-yieldable-insertion-write': 'error',
+  'craft-ts/prefer-direct-yieldable-callback': 'error',
+  'craft-ts/no-craft-use': 'error',
+  'craft-ts/no-type-assertions-in-template': 'error',
+  'craft-ts/no-ephemeral-template-form-state': 'error',
+  'craft-ts/template-element-name-unique': 'error',
+  'craft-ts/require-primitive-context': 'error',
+  'craft-ts/require-primitive-derived-property': 'error',
+  'craft-ts/no-invalid-insertion-pipe': 'error',
+  'craft-ts/no-redundant-primitive-insertion': 'error',
+  'craft-ts/prefer-query-method-over-state-trigger': 'error',
+  'craft-ts/no-injection-token': 'error',
+  'craft-ts/no-manual-route-provider-list': 'error',
+  'craft-ts/no-widened-route-provider-context': 'error',
+  'craft-ts/no-async-await': 'error',
+  'craft-ts/no-throw': 'error',
+  'craft-ts/require-assert-exhaustive-route-exceptions': 'warn',
+  'craft-ts/require-pending-component-di-check': 'warn',
+  'craft-ts/require-craft-exception-handler': 'warn',
+  'craft-ts/require-exception-component-di-check': 'warn',
+  // These aggregate proofs are too expensive for broad app configs and can
+  // trigger TS2589 when route graphs are large.
+  'craft-ts/require-child-route-mount-check': 'off',
+  'craft-ts/require-lazy-load-with-retry': 'warn',
+  'craft-ts/require-cascade-route-di-check': 'off',
+  'craft-ts/prefer-named-html-helpers': 'error',
+  'craft-ts/img-has-alt': 'error',
+  'craft-ts/control-has-accessible-name': 'error',
+  'craft-ts/label-has-associated-control': 'error',
+  'craft-ts/no-noninteractive-element-interactions': 'error',
+  'craft-ts/anchor-has-href': 'error',
+  'craft-ts/button-has-type': 'error',
+  'craft-ts/require-interactive-local-name': 'error',
+  'craft-ts/iframe-has-title': 'error',
+  'craft-ts/heading-has-content': 'error',
+  'craft-ts/prefer-relative-heading': 'error',
+  'craft-ts/require-route-heading-outline': 'error',
+  'craft-ts/require-outlet-heading-section': 'error',
+  'craft-ts/no-heading-level-skip': 'error',
+  'craft-ts/no-positive-tabindex': 'error',
+  'craft-ts/valid-aria': 'error',
+  'craft-ts/role-has-required-aria': 'error',
+  'craft-ts/target-blank-noopener': 'error',
+  'craft-ts/require-focus-visible': 'error',
+  'craft-ts/require-reduced-motion': 'error',
+};