@ethlete/eslint-plugin 1.0.0-next.23 → 1.0.0-next.25

package/src/rules/no-angular-router-api.js

@@ -35,6 +35,10 @@
  *   injectQueryParamChanges(), injectPathParamChanges()
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isImportedAs } = require('./internals/import-resolution');
+
+const ANGULAR_ROUTER = '@angular/router';
+
 /**
  * Router properties that expose route state and must not be read directly.
  * @type {Map<string, string>}
@@ -66,6 +70,17 @@ const noAngularRouterApi = {
     schema: [],
   },
   create(context) {
+    const sourceCode = context.sourceCode;
+
+    /**
+     * @param {any} call
+     * @param {string} token
+     */
+    const isInjectOf = (call, token) =>
+      call?.type === 'CallExpression' &&
+      isImportedAs(sourceCode, call.callee, 'inject') &&
+      isImportedAs(sourceCode, call.arguments[0], token, ANGULAR_ROUTER);
+
     /**
      * Names of variables/properties assigned from inject(Router).
      * We track identifiers whose initializer is inject(Router) so we can
@@ -78,28 +93,14 @@ const noAngularRouterApi = {
       // ── Track inject(Router) bindings ──────────────────────────────────────
       // const router = inject(Router);
       VariableDeclarator(node) {
-        if (
-          node.init?.type === 'CallExpression' &&
-          node.init.callee.type === 'Identifier' &&
-          node.init.callee.name === 'inject' &&
-          node.init.arguments[0]?.type === 'Identifier' &&
-          node.init.arguments[0].name === 'Router' &&
-          node.id.type === 'Identifier'
-        ) {
+        if (isInjectOf(node.init, 'Router') && node.id.type === 'Identifier') {
           routerBindings.add(node.id.name);
         }
       },
 
       // ── Track class property assignments: router = inject(Router) ──────────
       PropertyDefinition(node) {
-        if (
-          node.value?.type === 'CallExpression' &&
-          node.value.callee.type === 'Identifier' &&
-          node.value.callee.name === 'inject' &&
-          node.value.arguments[0]?.type === 'Identifier' &&
-          node.value.arguments[0].name === 'Router' &&
-          node.key.type === 'Identifier'
-        ) {
+        if (isInjectOf(node.value, 'Router') && node.key.type === 'Identifier') {
           routerBindings.add(node.key.name);
         }
       },
@@ -130,24 +131,17 @@ const noAngularRouterApi = {
       },
 
       // ── ActivatedRoute import ───────────────────────────────────────────────
-      ImportDeclaration(node) {
-        if (node.source.value !== '@angular/router') return;
-        for (const specifier of node.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') continue;
-          if (specifier.imported.name === 'ActivatedRoute') {
-            context.report({ node, messageId: 'noActivatedRoute' });
-            return;
-          }
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== ANGULAR_ROUTER) return;
+        if (reference.named.some((entry) => entry.name === 'ActivatedRoute')) {
+          context.report({ node, messageId: 'noActivatedRoute' });
         }
       },
 
       // ── inject(ActivatedRoute) ──────────────────────────────────────────────
       CallExpression(node) {
-        const { callee } = node;
-        if (callee.type !== 'Identifier' || callee.name !== 'inject') return;
-        const arg = node.arguments[0];
-        if (arg?.type !== 'Identifier') return;
-        if (arg.name === 'ActivatedRoute') {
+        if (isInjectOf(node, 'ActivatedRoute')) {
           context.report({ node, messageId: 'noActivatedRoute' });
         }
       },

package/src/rules/no-angular-seo-services.js

@@ -1,6 +1,13 @@
 // @ts-check
 'use strict';
 
+const {
+  MODULE_REFERENCE_SELECTOR,
+  getImportedName,
+  getModuleReference,
+  isImportedAs,
+} = require('./internals/import-resolution');
+
 /**
  * Disallows injecting Angular's `Title` and `Meta` services from
  * `@angular/platform-browser` and importing them from that module.
@@ -48,11 +55,11 @@ const rule = {
      */
     const injectTokenName = (node) => {
       if (node.type !== 'CallExpression') return null;
-      if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') return null;
+      if (!isImportedAs(context.sourceCode, node.callee, 'inject')) return null;
       const firstArg = node.arguments[0];
       if (!firstArg) return null;
-      if (firstArg.type === 'Identifier') return firstArg.name;
-      return null;
+
+      return getImportedName(context.sourceCode, firstArg, '@angular/platform-browser');
     };
 
     return {
@@ -64,13 +71,11 @@ const rule = {
       },
 
       // Detect: import { Title, Meta } from '@angular/platform-browser'
-      ImportDeclaration(node) {
-        const decl = /** @type {any} */ (node);
-        if (decl.source.value !== '@angular/platform-browser') return;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== '@angular/platform-browser') return;
 
-        for (const specifier of decl.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') continue;
-          const imported = specifier.imported.name ?? specifier.imported.value;
+        for (const { name: imported, node: specifier } of reference.named) {
           if (imported === 'Title') context.report({ node: specifier, messageId: 'noImportTitle' });
           if (imported === 'Meta') context.report({ node: specifier, messageId: 'noImportMeta' });
         }

package/src/rules/no-cdk-import.js

@@ -4,6 +4,7 @@
 const { createRequire } = require('node:module');
 const path = require('node:path');
 const fs = require('node:fs');
+const { MODULE_REFERENCE_SELECTOR, getModuleReference } = require('./internals/import-resolution');
 
 /**
  * Disallows importing from `@ethlete/cdk`, the maintenance-mode predecessor of `@ethlete/components`,
@@ -52,13 +53,6 @@ const loadMigrationMap = (mapPath, cwd) => {
   return map;
 };
 
-/** @param {any} specifier */
-const importedName = (specifier) => {
-  if (specifier.type !== 'ImportSpecifier') return null;
-
-  return specifier.imported.name ?? specifier.imported.value ?? null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const noCdkImport = {
   meta: {
@@ -95,13 +89,13 @@ const noCdkImport = {
     const entryFor = (name) => map?.[name] ?? null;
 
     return {
-      ImportDeclaration(node) {
-        const declaration = /** @type {any} */ (node);
-        const source = declaration.source.value;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        const source = reference?.source;
 
-        if (typeof source !== 'string' || (source !== CDK_PACKAGE && !source.startsWith(`${CDK_PACKAGE}/`))) return;
+        if (!reference || (source !== CDK_PACKAGE && !source?.startsWith(`${CDK_PACKAGE}/`))) return;
 
-        const named = declaration.specifiers.filter(/** @param {any} s */ (s) => importedName(s));
+        const { named } = reference;
 
         if (!named.length) {
           context.report({ node, messageId: 'module', data: { cdk: CDK_PACKAGE, docs: migrationDocs } });
@@ -109,8 +103,7 @@ const noCdkImport = {
           return;
         }
 
-        for (const specifier of named) {
-          const name = /** @type {string} */ (importedName(specifier));
+        for (const { name, node: specifier } of named) {
           const entry = entryFor(name);
 
           if (!entry) {

package/src/rules/no-csp-unsafe.js

@@ -0,0 +1,362 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows code that a strict Content Security Policy without `'unsafe-inline'` / `'unsafe-eval'`
+ * blocks at runtime:
+ *
+ *   script-src 'self' 'nonce-…'; style-src 'self' 'nonce-…'
+ *
+ * BAD:
+ *   el.setAttribute('style', 'color: red');          // inline style attribute
+ *   renderer.setAttribute(el, 'style', css);
+ *   const s = document.createElement('style');       // appended without a nonce
+ *   eval(code); new Function(code); setTimeout('tick()', 10);
+ *   `<div style="color: red">…</div>`                // HTML string parsed into the DOM
+ *   <div style="color: red"></div>                   // static template attribute
+ *   host: { style: 'display: block' }
+ *
+ * GOOD:
+ *   el.style.color = 'red';  el.style.setProperty('--x', '1');  [style.color]="c"
+ *   s.setAttribute('nonce', inject(CSP_NONCE));      // or s.nonce = …
+ *   a class or data attribute styled by a shipped stylesheet
+ *
+ * In an Angular template this rule runs on `.html` files and on inline templates extracted by
+ * `processInlineTemplates`; in TypeScript it skips a decorator's `template` string for that reason.
+ */
+
+const fs = require('node:fs');
+const { isGlobalReference } = require('./internals/import-resolution');
+
+const NONCED_ELEMENTS = new Set(['script', 'style']);
+const TIMER_FUNCTIONS = new Set(['setTimeout', 'setInterval']);
+const HTML_STYLE_ATTRIBUTE = /<[a-zA-Z][^<>]*\sstyle\s*=/;
+const UNFIXABLE_STYLE_VALUE = /['"\\]|\/\*|!important|url\(/i;
+const PLAIN_STYLE_PROPERTY = /^[a-zA-Z]+$/;
+const STYLE_PROPERTY = /^-{0,2}[a-zA-Z][\w-]*$/;
+const QUOTED_INLINE_TEMPLATE = /\btemplate\s*:\s*['"]/;
+
+/**
+ * Turns `a: b; c-d: e` into `{ a: 'b', 'c-d': 'e' }`, or returns null when the declarations cannot be
+ * rewritten without changing what they mean.
+ *
+ * @param {string} css
+ */
+const toStyleObjectLiteral = (css) => {
+  if (UNFIXABLE_STYLE_VALUE.test(css)) return null;
+
+  const entries = [];
+
+  for (const declaration of css.split(';')) {
+    if (!declaration.trim()) continue;
+
+    const colon = declaration.indexOf(':');
+
+    if (colon === -1) return null;
+
+    const property = declaration.slice(0, colon).trim();
+    const value = declaration
+      .slice(colon + 1)
+      .trim()
+      .replace(/\s+/g, ' ');
+
+    if (!STYLE_PROPERTY.test(property) || !value) return null;
+
+    entries.push(`${PLAIN_STYLE_PROPERTY.test(property) ? property : `'${property}'`}: '${value}'`);
+  }
+
+  return entries.length ? `{ ${entries.join(', ')} }` : null;
+};
+
+/** @param {any} node */
+const stringValue = (node) => (node?.type === 'Literal' && typeof node.value === 'string' ? node.value : null);
+
+/** @param {any} node */
+const propertyName = (node) => {
+  if (node?.type !== 'Property' || node.computed) return null;
+  if (node.key.type === 'Identifier') return node.key.name;
+
+  return stringValue(node.key);
+};
+
+/** @param {any} node */
+const calleeMemberName = (node) =>
+  node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property.type === 'Identifier'
+    ? node.callee.property.name
+    : null;
+
+/** @param {any} node @param {string} name */
+const hasProperty = (node, name) =>
+  node?.type === 'ObjectExpression' && node.properties.some(/** @param {any} p */ (p) => propertyName(p) === name);
+
+/** @param {any} node */
+const isDecoratorTemplate = (node) => {
+  const property = node.parent;
+
+  if (propertyName(property) !== 'template' || property.value !== node) return false;
+
+  const call = property.parent?.parent;
+
+  return call?.type === 'CallExpression' && call.parent?.type === 'Decorator';
+};
+
+/** @param {any} node */
+const isHostMetadata = (node) => {
+  const property = node.parent;
+
+  if (propertyName(property) !== 'host' || property.value !== node) return false;
+
+  const call = property.parent?.parent;
+
+  return call?.type === 'CallExpression' && call.parent?.type === 'Decorator';
+};
+
+/** @param {any} node */
+const enclosingScopeNode = (node) => {
+  let current = node.parent;
+
+  while (current) {
+    if (
+      current.type === 'FunctionDeclaration' ||
+      current.type === 'FunctionExpression' ||
+      current.type === 'ArrowFunctionExpression' ||
+      current.type === 'Program'
+    ) {
+      return current;
+    }
+
+    current = current.parent;
+  }
+
+  return null;
+};
+
+/** @param {any} node */
+const boundTarget = (node) => {
+  const parent = node.parent;
+
+  if (parent?.type === 'VariableDeclarator' && parent.init === node && parent.id.type === 'Identifier')
+    return parent.id;
+  if (parent?.type === 'AssignmentExpression' && parent.right === node) return parent.left;
+
+  return null;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noCspUnsafe = {
+  meta: {
+    type: 'problem',
+    fixable: 'code',
+    docs: {
+      description:
+        "Disallow code a strict Content Security Policy (no 'unsafe-inline', no 'unsafe-eval') blocks at runtime.",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      styleAttribute:
+        "A `style` attribute is blocked by a CSP without 'unsafe-inline'. Set styles through CSSOM (`el.style.x = …`, `style.setProperty()`, a `[style.x]` binding) or use a class.",
+      htmlStyleAttribute:
+        "This HTML string sets a `style` attribute, which a CSP without 'unsafe-inline' blocks once it is parsed into the DOM. Use a class or a data attribute styled by a stylesheet.",
+      templateStyleAttribute:
+        "A static `style` attribute is blocked by a CSP without 'unsafe-inline'. Use `[style.x]` bindings or a class.",
+      missingNonce:
+        "A `<{{tag}}>` element created without a nonce is blocked by a CSP without 'unsafe-inline'. Set `nonce` from `inject(CSP_NONCE)` on it in the same function.",
+      dynamicCode: "`{{name}}` evaluates a string as code, which a CSP without 'unsafe-eval' blocks.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const parserServices = /** @type {any} */ (sourceCode.parserServices);
+
+    if (parserServices?.convertNodeSourceSpanToLoc) {
+      /** @param {any} span @param {string} messageId */
+      const reportSpan = (span, messageId) =>
+        context.report({ loc: parserServices.convertNodeSourceSpanToLoc(span), messageId });
+
+      let quotedInlineTemplate = /** @type {boolean | undefined} */ (undefined);
+
+      // The fix writes single quotes, which would end a quoted `template: '…'` string in the component.
+      const canFixTemplate = () => {
+        if (context.physicalFilename === context.filename || !context.physicalFilename.endsWith('.ts')) return true;
+
+        quotedInlineTemplate ??= QUOTED_INLINE_TEMPLATE.test(fs.readFileSync(context.physicalFilename, 'utf8'));
+
+        return !quotedInlineTemplate;
+      };
+
+      return {
+        /** @param {any} node */
+        Element(node) {
+          const hasStyleBinding = (node.inputs ?? []).some(
+            /** @param {any} input */ (input) => input.name === 'style' && String(input.keySpan) === 'style',
+          );
+
+          for (const attribute of node.attributes ?? []) {
+            if (attribute.name !== 'style') continue;
+
+            const literal = hasStyleBinding || !canFixTemplate() ? null : toStyleObjectLiteral(attribute.value);
+
+            context.report({
+              loc: parserServices.convertNodeSourceSpanToLoc(attribute.sourceSpan),
+              messageId: 'templateStyleAttribute',
+              fix: literal
+                ? (fixer) =>
+                    fixer.replaceTextRange(
+                      [attribute.sourceSpan.start.offset, attribute.sourceSpan.end.offset],
+                      `[style]="${literal}"`,
+                    )
+                : null,
+            });
+          }
+
+          for (const input of node.inputs ?? []) {
+            if (input.name === 'style' && String(input.keySpan) === 'attr.style') {
+              reportSpan(input.sourceSpan, 'styleAttribute');
+            }
+          }
+        },
+      };
+    }
+
+    /** @param {any} scope @param {string} target */
+    const setsNonce = (scope, target) => {
+      let found = false;
+
+      /** @param {any} node */
+      const matches = (node) => node && sourceCode.getText(node) === target;
+
+      /** @param {any} node */
+      const visit = (node) => {
+        if (found || !node || typeof node.type !== 'string') return;
+
+        if (
+          node.type === 'AssignmentExpression' &&
+          node.left.type === 'MemberExpression' &&
+          !node.left.computed &&
+          node.left.property.name === 'nonce' &&
+          matches(node.left.object)
+        ) {
+          found = true;
+          return;
+        }
+
+        if (node.type === 'CallExpression') {
+          const method = calleeMemberName(node);
+          const [first, second] = node.arguments;
+
+          if (
+            (method === 'setAttribute' && matches(node.callee.object) && stringValue(first) === 'nonce') ||
+            (method === 'setAttribute' && matches(first) && stringValue(second) === 'nonce') ||
+            ((method === 'setAttributes' || method === 'assign') && matches(first) && hasProperty(second, 'nonce'))
+          ) {
+            found = true;
+            return;
+          }
+        }
+
+        for (const key of sourceCode.visitorKeys[node.type] ?? []) {
+          const child = node[key];
+
+          if (Array.isArray(child)) child.forEach(visit);
+          else visit(child);
+        }
+      };
+
+      visit(scope);
+
+      return found;
+    };
+
+    /** @param {any} node @param {string} text */
+    const checkHtmlString = (node, text) => {
+      if (HTML_STYLE_ATTRIBUTE.test(text) && !isDecoratorTemplate(node)) {
+        context.report({ node, messageId: 'htmlStyleAttribute' });
+      }
+    };
+
+    return {
+      /** @param {any} node */
+      CallExpression(node) {
+        const method = calleeMemberName(node);
+        const [first, second] = node.arguments;
+
+        if (method === 'setAttribute') {
+          if (stringValue(first) === 'style' || (node.arguments.length >= 3 && stringValue(second) === 'style')) {
+            context.report({ node, messageId: 'styleAttribute' });
+          }
+
+          return;
+        }
+
+        if (method === 'setAttributes' && hasProperty(second, 'style')) {
+          context.report({ node, messageId: 'styleAttribute' });
+          return;
+        }
+
+        if (method === 'createElement') {
+          const tag = stringValue(first)?.toLowerCase();
+
+          if (!tag || !NONCED_ELEMENTS.has(tag)) return;
+
+          const target = boundTarget(node);
+          const scope = enclosingScopeNode(node);
+
+          if (!target || !scope || !setsNonce(scope, sourceCode.getText(target))) {
+            context.report({ node, messageId: 'missingNonce', data: { tag } });
+          }
+
+          return;
+        }
+
+        const callee = node.callee;
+        const name = callee.type === 'Identifier' ? callee.name : callee.type === 'MemberExpression' ? method : null;
+
+        if (!name) return;
+
+        if (callee.type === 'Identifier' && (name === 'eval' || name === 'Function')) {
+          if (isGlobalReference(sourceCode, callee)) context.report({ node, messageId: 'dynamicCode', data: { name } });
+
+          return;
+        }
+
+        if (TIMER_FUNCTIONS.has(name) && (stringValue(first) !== null || first?.type === 'TemplateLiteral')) {
+          if (callee.type === 'MemberExpression' || isGlobalReference(sourceCode, callee)) {
+            context.report({ node, messageId: 'dynamicCode', data: { name: `${name}(string)` } });
+          }
+        }
+      },
+      /** @param {any} node */
+      NewExpression(node) {
+        if (
+          node.callee.type === 'Identifier' &&
+          node.callee.name === 'Function' &&
+          isGlobalReference(sourceCode, node.callee)
+        ) {
+          context.report({ node, messageId: 'dynamicCode', data: { name: 'new Function' } });
+        }
+      },
+      /** @param {any} node */
+      ObjectExpression(node) {
+        if (!isHostMetadata(node)) return;
+
+        for (const property of node.properties) {
+          const key = propertyName(property);
+
+          if (key === 'style' || key === '[attr.style]')
+            context.report({ node: property, messageId: 'styleAttribute' });
+        }
+      },
+      /** @param {any} node */
+      Literal(node) {
+        if (typeof node.value === 'string') checkHtmlString(node, node.value);
+      },
+      /** @param {any} node */
+      TemplateLiteral(node) {
+        checkHtmlString(node, node.quasis.map(/** @param {any} q */ (q) => q.value.cooked ?? q.value.raw).join('x'));
+      },
+    };
+  },
+};
+
+module.exports = noCspUnsafe;

package/src/rules/no-document-cookie.js

@@ -21,6 +21,8 @@
  *   deleteCookie('name');
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noDocumentCookie = {
   meta: {
@@ -42,6 +44,7 @@ const noDocumentCookie = {
         if (
           node.object.type === 'Identifier' &&
           node.object.name === 'document' &&
+          isGlobalReference(context.sourceCode, node.object) &&
           node.property.type === 'Identifier' &&
           node.property.name === 'cookie'
         ) {

package/src/rules/no-effect-cleanup-return.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Disallows returning a cleanup function from an `effect()` callback.
  *
@@ -115,7 +117,9 @@ const noEffectCleanupReturn = {
       CallExpression(node) {
         const { callee } = node;
 
-        if (callee.type !== 'Identifier' || !EFFECT_CALLEES.has(callee.name)) {
+        const calleeName = getImportedName(context.sourceCode, callee, ANGULAR_CORE);
+
+        if (!calleeName || !EFFECT_CALLEES.has(calleeName)) {
           return;
         }
 
@@ -130,7 +134,7 @@ const noEffectCleanupReturn = {
           context.report({
             node: callback.body,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
           });
 
           return;
@@ -163,7 +167,7 @@ const noEffectCleanupReturn = {
           context.report({
             node: statement.argument,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
             fix:
               fixable && openParen
                 ? (fixer) => [

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
 
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
@@ -14,22 +16,6 @@ const getPropertyName = (key) => {
   return null;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 const MESSAGE_IDS = {
   hostDirectives: 'noEmptyHostDirectives',
   imports: 'noEmptyImports',
@@ -55,7 +41,7 @@ const noEmptyAngularMetadataArrays = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const decorator = /** @type {any} */ (node);

package/src/rules/no-inject-chain.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noInjectChain = {
   meta: {
@@ -19,7 +21,7 @@ const noInjectChain = {
     return {
       MemberExpression(node) {
         const obj = node.object;
-        if (obj.type === 'CallExpression' && obj.callee.type === 'Identifier' && obj.callee.name === 'inject') {
+        if (obj.type === 'CallExpression' && isImportedAs(context.sourceCode, obj.callee, 'inject')) {
           // Allow inject(X).method() — immediately-invoked patterns like
           // inject(DestroyRef).onDestroy(...) are intentional Angular idioms.
           const parent = node.parent;