@dsivd/prestations-ng 19.0.6-beta.2 → 19.0.7

package/src/eslint/signal-names.mjs

@@ -0,0 +1,232 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import ts from "typescript";
+
+/**
+ * Collects the signal member names of a component, walking up its inheritance chain.
+ *
+ * Base classes are resolved automatically: the `extends` clause is matched against the
+ * imports of the file, the module is resolved the way TypeScript would (relative paths,
+ * `node_modules`, `paths` mappings) and the base class is read from there. Nothing has
+ * to be declared by hand.
+ */
+
+// `output()` is absent: an output is never called, it is emitted.
+const SIGNAL_FACTORIES = new Set([
+  "input",
+  "model",
+  "computed",
+  "signal",
+  "linkedSignal",
+  "toSignal",
+  "viewChild",
+  "viewChildren",
+  "contentChild",
+  "contentChildren",
+]);
+
+// Types of a signal member. Declaration files qualify them with the namespace they were
+// imported under: `readonly icon: _angular_core.ModelSignal<IconProp>`, hence the
+// comparison on the last segment only.
+const SIGNAL_TYPES = new Set([
+  "Signal",
+  "WritableSignal",
+  "InputSignal",
+  "InputSignalWithTransform",
+  "ModelSignal",
+]);
+
+const parsedFiles = new Map();
+const compilerOptionsByDirectory = new Map();
+
+const parseFile = (path) => {
+  let stamp;
+  try {
+    stamp = statSync(path).mtimeMs;
+  } catch {
+    return undefined;
+  }
+
+  const cached = parsedFiles.get(path);
+  if (cached?.stamp === stamp) {
+    return cached.sourceFile;
+  }
+
+  const sourceFile = ts.createSourceFile(
+    path,
+    readFileSync(path, "utf8"),
+    ts.ScriptTarget.Latest,
+    false,
+  );
+  parsedFiles.set(path, { stamp, sourceFile });
+  return sourceFile;
+};
+
+const compilerOptionsFor = (path) => {
+  const directory = dirname(path);
+  if (compilerOptionsByDirectory.has(directory)) {
+    return compilerOptionsByDirectory.get(directory);
+  }
+
+  const configPath = ts.findConfigFile(directory, ts.sys.fileExists);
+  const config = configPath
+    ? ts.readConfigFile(configPath, ts.sys.readFile).config
+    : undefined;
+  // Only the options are converted: reading the whole config would glob `include`.
+  const { options } = ts.convertCompilerOptionsFromJson(
+    config?.compilerOptions ?? {},
+    configPath ? dirname(configPath) : directory,
+  );
+  // Without these, `node_modules` is not searched at all.
+  options.module ??= ts.ModuleKind.ESNext;
+  options.moduleResolution ??= ts.ModuleResolutionKind.Bundler;
+
+  compilerOptionsByDirectory.set(directory, options);
+  return options;
+};
+
+const resolveModule = (specifier, containingFile) =>
+  ts.resolveModuleName(
+    specifier,
+    containingFile,
+    compilerOptionsFor(containingFile),
+    ts.sys,
+  ).resolvedModule?.resolvedFileName;
+
+const lastSegmentOf = (entityName) =>
+  ts.isQualifiedName(entityName) ? entityName.right.text : entityName.text;
+
+const isSignalType = (typeNode) =>
+  !!typeNode &&
+  ts.isTypeReferenceNode(typeNode) &&
+  SIGNAL_TYPES.has(lastSegmentOf(typeNode.typeName));
+
+const isSignalFactoryCall = (expression) => {
+  if (!expression || !ts.isCallExpression(expression)) {
+    return false;
+  }
+  // `input.required<T>()` and `viewChild.required(…)` unwrap to their factory.
+  let callee = expression.expression;
+  while (ts.isPropertyAccessExpression(callee)) {
+    callee = callee.expression;
+  }
+  return ts.isIdentifier(callee) && SIGNAL_FACTORIES.has(callee.text);
+};
+
+const isSignalMember = (member) => {
+  if (ts.isGetAccessor(member)) {
+    return isSignalType(member.type);
+  }
+  return (
+    ts.isPropertyDeclaration(member) &&
+    (isSignalType(member.type) || isSignalFactoryCall(member.initializer))
+  );
+};
+
+const findClass = (sourceFile, className) => {
+  let found;
+  const visit = (node) => {
+    if (found) {
+      return;
+    }
+    if (ts.isClassDeclaration(node) && node.name?.text === className) {
+      found = node;
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  sourceFile.forEachChild(visit);
+  return found;
+};
+
+const extendedClassNameOf = (classDeclaration) => {
+  const clause = classDeclaration.heritageClauses?.find(
+    (heritageClause) => heritageClause.token === ts.SyntaxKind.ExtendsKeyword,
+  );
+  const expression = clause?.types[0]?.expression;
+  return expression && ts.isIdentifier(expression) ? expression.text : undefined;
+};
+
+// The import that brings `localName` into the file, with the name it is exported under.
+const importOf = (sourceFile, localName) => {
+  for (const statement of sourceFile.statements) {
+    const bindings = ts.isImportDeclaration(statement)
+      ? statement.importClause?.namedBindings
+      : undefined;
+    if (!bindings || !ts.isNamedImports(bindings)) {
+      continue;
+    }
+    const element = bindings.elements.find(
+      (namedImport) => namedImport.name.text === localName,
+    );
+    if (element) {
+      return {
+        specifier: statement.moduleSpecifier.text,
+        exportedName: (element.propertyName ?? element.name).text,
+      };
+    }
+  }
+  return undefined;
+};
+
+const reExportedModulesOf = (sourceFile) =>
+  sourceFile.statements
+    .filter((statement) => ts.isExportDeclaration(statement) && statement.moduleSpecifier)
+    .map((statement) => statement.moduleSpecifier.text);
+
+const collect = (path, className, names, visited) => {
+  const key = `${path}::${className ?? "*"}`;
+  if (visited.has(key)) {
+    return;
+  }
+  visited.add(key);
+
+  const sourceFile = parseFile(path);
+  if (!sourceFile) {
+    return;
+  }
+
+  const classDeclarations = className
+    ? [findClass(sourceFile, className)].filter(Boolean)
+    : sourceFile.statements.filter(ts.isClassDeclaration);
+
+  // A barrel: the class is only re-exported from here.
+  if (className && classDeclarations.length === 0) {
+    for (const specifier of reExportedModulesOf(sourceFile)) {
+      const target = resolveModule(specifier, path);
+      if (target) {
+        collect(target, className, names, visited);
+      }
+    }
+    return;
+  }
+
+  for (const classDeclaration of classDeclarations) {
+    for (const member of classDeclaration.members) {
+      if (member.name && ts.isIdentifier(member.name) && isSignalMember(member)) {
+        names.add(member.name.text);
+      }
+    }
+
+    const baseName = extendedClassNameOf(classDeclaration);
+    if (!baseName) {
+      continue;
+    }
+    // Declaration bundles are flattened: the base class often sits in the same file.
+    if (findClass(sourceFile, baseName)) {
+      collect(path, baseName, names, visited);
+      continue;
+    }
+    const imported = importOf(sourceFile, baseName);
+    const target = imported && resolveModule(imported.specifier, path);
+    if (target) {
+      collect(target, imported.exportedName, names, visited);
+    }
+  }
+};
+
+export const collectSignalNames = (componentPath) => {
+  const names = new Set();
+  collect(componentPath, undefined, names, new Set());
+  return names;
+};

package/src/eslint/template-ast.mjs

@@ -0,0 +1,26 @@
+/**
+ * Two subtleties of the Angular template AST that every template rule runs into.
+ * Both are easy to get wrong, hence the shared names.
+ */
+
+/**
+ * The expression carried by a `BoundEvent` handler.
+ *
+ * A two-way binding `[(x)]="expr"` generates a `BoundEvent` named `xChange` whose
+ * handler is the very expression of the twin `BoundAttribute` — same source span, two
+ * AST nodes. A rule that reports on both copies reports the binding twice.
+ */
+export const handlerExpressionOf = (boundEvent) => {
+  const { handler } = boundEvent;
+  return handler?.type === "ASTWithSource" ? handler.ast : handler;
+};
+
+/**
+ * Whether a node is read directly on the component.
+ *
+ * `mySignal` reads the member on an `ImplicitReceiver`, `this.mySignal` on a
+ * `ThisReceiver` — two distinct node types for the same intent. Anything else
+ * (`obj.mySignal`) is read on a foreign object.
+ */
+export const isComponentReceiver = (node) =>
+  node?.type === "ImplicitReceiver" || node?.type === "ThisReceiver";

package/types/dsivd-prestations-ng.d.ts

@@ -3153,8 +3153,6 @@ declare class FoehnListSummaryComponent extends FoehnInputComponent<FoehnListIte
     readonly showAsTable: _angular_core.InputSignal<boolean>;
     readonly tableActionButtons: _angular_core.Signal<TemplateRef<unknown>>;
     readonly canAddItems: _angular_core.InputSignal<boolean>;
-    readonly internalList: _angular_core.WritableSignal<FoehnListItem[]>;
-    readonly internalListItemDescriptions: _angular_core.WritableSignal<FoehnListItemDescription[]>;
     readonly itemRemoved: _angular_core.OutputEmitterRef<void>;
     readonly itemEdit: _angular_core.OutputEmitterRef<number>;
     listCopyForTable: FoehnListItem[];

package/eslint/rules/__tests__/no-direct-signal-mutation.test.mjs

@@ -1,98 +0,0 @@
-import { describe, it } from 'vitest';
-import { RuleTester } from 'eslint';
-import rule from '../no-direct-signal-mutation.mjs';
-
-describe('no-direct-signal-mutation', () => {
-  const ruleTester = new RuleTester({
-    languageOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  });
-
-  it('should validate signal mutation rule', () => {
-    ruleTester.run('no-direct-signal-mutation', rule, {
-      valid: [
-        // Using .update()
-        'model.update((current) => ({ ...current, property: value }))',
-        'this.model.update((current) => ({ ...current, property: value }))',
-        'getSignal().update((current) => ({ ...current, property: value }))',
-
-        // Using .set()
-        'model.set({ property: value })',
-        'this.model.set({ property: value })',
-        'getSignal().set({ property: value })',
-
-        // Regular property assignments
-        'this.property = value',
-        'obj.property = value',
-        'this.obj.property = value',
-
-        // Reading from function calls (no assignment)
-        'model().property',
-        'this.model().property',
-        'getSignal().property',
-
-        // Method calls on function results
-        'model().someMethod()',
-        'this.model().someMethod()',
-        'getSignal().doSomething()',
-
-        // Assignments to non-function results
-        'let x = value',
-        'const obj = { prop: value }',
-        'array[0] = value',
-        'pendingFilesByFormKey.get(formKey).files = []',
-        'this.pendingFilesByFormKey.get(formKey).url = baseUrl',
-        'const autocompleteComponent = viewChild("auto"); autocompleteComponent().inputElement().nativeElement.hidden = true',
-        'component.inputElement().nativeElement.value = ""',
-
-        // Method chaining without assignment
-        'model().update((v) => v).subscribe()',
-
-        // One-way bindings are OK
-        '[model]="model().property"',
-        '[ngModel]="model().comment"',
-      ],
-
-      invalid: [
-        {
-          code: "model().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "this.model().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "getSignal().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().nested.property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "this.model().deeply.nested.property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property += value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property -= value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property *= value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().array[0] = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-      ],
-    });
-  });
-});