@onecx/angular-linter-rules 8.0.0-rc.1

package/README.md

@@ -0,0 +1,17 @@
+# @onecx/angular-linter-rules
+
+`@onecx/angular-linter-rules` is an ESLint plugin that provides opinionated Angular rules to ensure code quality and consistency across Angular projects within the OneCX ecosystem.
+More information about the library can be found [here](https://onecx.github.io/docs/documentation/current/onecx-portal-ui-libs/libraries/angular-linter-rules.html)
+
+## Installation
+
+```bash
+npm install @onecx/angular-linter-rules
+```
+
+## Additional Commands
+- `npx nx run angular-linter-rules:build` - Builds the library and outputs the result to the `dist` folder.
+- `npx nx run angular-linter-rules:build-migrations` - Builds the migration files for the library.
+- `npx nx run angular-linter-rules:test` - Runs the unit tests for the library.
+- `npx nx run angular-linter-rules:lint` - Lints the library's codebase.
+- `npx nx run angular-linter-rules:release` - Releases a new version of the library to npm, following semantic versioning guidelines.

package/eslint.config.cjs

@@ -0,0 +1,19 @@
+const baseConfig = require('../.eslintrc.json')
+
+module.exports = [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: require('jsonc-eslint-parser'),
+    },
+  },
+]

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'angular-linter-rules',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/libs/angular-linter-rules',
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@onecx/angular-linter-rules",
+  "version": "8.0.0-rc.1",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/project.json

@@ -0,0 +1,28 @@
+{
+  "name": "angular-linter-rules",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/angular-linter-rules/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/angular-linter-rules",
+        "main": "libs/angular-linter-rules/src/index.ts",
+        "tsConfig": "libs/angular-linter-rules/tsconfig.lib.json",
+        "assets": ["libs/angular-linter-rules/*.md"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/angular-linter-rules/jest.config.ts",
+        "codeCoverage": true,
+        "passWithNoTests": true
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import { rules } from './lib/rules'
+import { configs } from './lib/configs'
+
+export { rules, configs }
+
+export const plugin = {
+  rules,
+  configs,
+}
+
+export type { AngularLinterRulesPlugin } from './lib/types'

package/src/lib/configs.ts

@@ -0,0 +1,16 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+import { rules } from './rules'
+
+const pluginName = '@onecx/angular-linter-rules'
+
+const recommendedRules = Object.keys(rules).reduce<Record<string, TSESLint.Linter.RuleEntry>>((acc, ruleName) => {
+  acc[`${pluginName}/${ruleName}`] = 'warn'
+  return acc
+}, {})
+
+export const configs: Record<string, TSESLint.Linter.Config> = {
+  recommended: {
+    plugins: [pluginName],
+    rules: recommendedRules,
+  },
+}

package/src/lib/rules/index.ts

@@ -0,0 +1,9 @@
+import { noSubscribeAssignment } from './no-subscribe-assignment.rule'
+import { noTranslateInstant } from './no-translate-instant.rule'
+import { preferTranslateParams } from './prefer-translate-params.rule'
+
+export const rules = {
+  'no-subscribe-assignment': noSubscribeAssignment,
+  'no-translate-instant': noTranslateInstant,
+  'prefer-translate-params': preferTranslateParams,
+} as const

package/src/lib/rules/no-subscribe-assignment.rule.spec.ts

@@ -0,0 +1,118 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import { noSubscribeAssignment } from './no-subscribe-assignment.rule'
+
+RuleTester.afterAll = afterAll
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: require('@typescript-eslint/parser'),
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+  },
+} as unknown as any)
+
+const messageId = 'assignmentOutside'
+
+ruleTester.run('no-subscribe-assignment', noSubscribeAssignment, {
+  valid: [
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        of(1).subscribe((value) => {
+          const local = value
+          console.log(local)
+        })
+      }
+      `,
+    },
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        let outer = 0
+        of(1).subscribe((value) => {
+          const outer = value
+          console.log(outer)
+        })
+        console.log(outer)
+      }
+      `,
+    },
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        of({ a: 1 }).subscribe((value) => {
+          const { a } = value
+          console.log(a)
+        })
+      }
+      `,
+    },
+  ],
+  invalid: [
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        let outer: number | undefined
+        of(1).subscribe((value) => {
+          outer = value
+        })
+        console.log(outer)
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      class A {
+        value?: number
+        test() {
+          of(1).subscribe((value) => {
+            this.value = value
+          })
+        }
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        let outer = 0
+        of(1).subscribe(function (value) {
+          outer++
+        })
+        console.log(outer)
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      code: `
+      import { of } from 'rxjs'
+
+      function test() {
+        let outer = 0
+        of(1).subscribe((value) => {
+          ;({ outer } = { outer: value })
+        })
+        console.log(outer)
+      }
+      `,
+      errors: [{ messageId }],
+    },
+  ],
+})

package/src/lib/rules/no-subscribe-assignment.rule.ts

@@ -0,0 +1,149 @@
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils'
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/onecx/onecx-portal-ui-libs/tree/main/libs/angular-linter-rules#${name}`)
+
+type Options = []
+type MessageIds = 'assignmentOutside'
+
+function isSubscribeCall(node: TSESTree.CallExpression): boolean {
+  return node.callee.type === AST_NODE_TYPES.MemberExpression &&
+    node.callee.property.type === AST_NODE_TYPES.Identifier &&
+    node.callee.property.name === 'subscribe'
+}
+
+function getFunctionArg(node: TSESTree.CallExpression): TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression | undefined {
+  for (const arg of node.arguments) {
+    if (arg.type === AST_NODE_TYPES.ArrowFunctionExpression || arg.type === AST_NODE_TYPES.FunctionExpression) {
+      return arg
+    }
+  }
+  return undefined
+}
+
+type PatternLike =
+  | TSESTree.Identifier
+  | TSESTree.ArrayPattern
+  | TSESTree.ObjectPattern
+  | TSESTree.RestElement
+  | TSESTree.AssignmentPattern
+
+function getAssignedIdentifiers(pattern: PatternLike): TSESTree.Identifier[] {
+  switch (pattern.type) {
+    case AST_NODE_TYPES.Identifier:
+      return [pattern]
+    case AST_NODE_TYPES.ArrayPattern:
+      return pattern.elements.flatMap((el) => (el ? getAssignedIdentifiers(el as PatternLike) : []))
+    case AST_NODE_TYPES.ObjectPattern:
+      return pattern.properties.flatMap((p) => {
+        if (p.type === AST_NODE_TYPES.Property) return getAssignedIdentifiers(p.value as PatternLike)
+        if (p.type === AST_NODE_TYPES.RestElement) return getAssignedIdentifiers(p.argument as PatternLike)
+        return []
+      })
+    case AST_NODE_TYPES.RestElement:
+      return getAssignedIdentifiers(pattern.argument as PatternLike)
+    case AST_NODE_TYPES.AssignmentPattern:
+      return getAssignedIdentifiers(pattern.left as PatternLike)
+  }
+}
+
+function getDeclaredVariablesInFunctionBody(
+  body: TSESTree.BlockStatement | TSESTree.Expression,
+): Set<string> {
+  const names = new Set<string>()
+  if (body.type !== AST_NODE_TYPES.BlockStatement) return names
+
+  for (const stmt of body.body) {
+    if (stmt.type !== AST_NODE_TYPES.VariableDeclaration) continue
+    for (const decl of stmt.declarations) {
+      for (const id of getAssignedIdentifiers(decl.id as any)) {
+        names.add(id.name)
+      }
+    }
+  }
+
+  return names
+}
+
+export const noSubscribeAssignment = createRule<Options, MessageIds>({
+  name: 'no-subscribe-assignment',
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Warn when assigning inside an Observable subscribe callback to variables declared outside the callback (including class members).',
+    },
+    schema: [],
+    messages: {
+      assignmentOutside: 'Avoid assigning to outer-scope variables inside `subscribe`. Prefer `map/tap` + `async` pipe or return the value.',
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isSubscribeCall(node)) return
+
+        const callback = getFunctionArg(node)
+        if (!callback) return
+
+        const callbackBody = callback.body
+        const localDeclarations = getDeclaredVariablesInFunctionBody(callbackBody)
+
+        const reportIfOuter = (identifier: TSESTree.Identifier) => {
+          if (localDeclarations.has(identifier.name)) return
+          context.report({
+            node: identifier,
+            messageId: 'assignmentOutside',
+          })
+        }
+
+        const sourceCode = context.sourceCode
+        const visitor = (n: TSESTree.Node) => {
+          if (n.type === AST_NODE_TYPES.AssignmentExpression) {
+            if (n.left.type === AST_NODE_TYPES.MemberExpression) {
+              if (n.left.object.type === AST_NODE_TYPES.ThisExpression) {
+                context.report({ node: n.left, messageId: 'assignmentOutside' })
+              }
+              return
+            }
+
+            if (n.left.type === AST_NODE_TYPES.Identifier) {
+              reportIfOuter(n.left)
+              return
+            }
+
+            if (n.left.type === AST_NODE_TYPES.ObjectPattern || n.left.type === AST_NODE_TYPES.ArrayPattern) {
+              for (const id of getAssignedIdentifiers(n.left)) {
+                reportIfOuter(id)
+              }
+            }
+            return
+          }
+
+          if (n.type === AST_NODE_TYPES.UpdateExpression) {
+            if (n.argument.type === AST_NODE_TYPES.Identifier) {
+              reportIfOuter(n.argument)
+            }
+            if (n.argument.type === AST_NODE_TYPES.MemberExpression && n.argument.object.type === AST_NODE_TYPES.ThisExpression) {
+              context.report({ node: n.argument, messageId: 'assignmentOutside' })
+            }
+            return
+          }
+
+          for (const child of sourceCode.visitorKeys[n.type] ?? []) {
+            const val = (n as any)[child]
+            if (Array.isArray(val)) {
+              for (const item of val) {
+                if (item && typeof item.type === 'string') visitor(item)
+              }
+            } else if (val && typeof val.type === 'string') {
+              visitor(val)
+            }
+          }
+        }
+
+        visitor(callbackBody)
+      },
+    }
+  },
+})

package/src/lib/rules/no-translate-instant.rule.spec.ts

@@ -0,0 +1,122 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import { noTranslateInstant } from './no-translate-instant.rule'
+
+RuleTester.afterAll = afterAll
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: require('@typescript-eslint/parser'),
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+  },
+} as unknown as any)
+
+const messageId = 'noTranslateInstant'
+
+ruleTester.run('no-translate-instant', noTranslateInstant, {
+  valid: [
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/some.spec.ts`,
+      code: `
+      class A {
+        constructor(private translate: any) {}
+        test() {
+          return this.translate.instant('KEY')
+        }
+      }
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/testing/test-helper.ts`,
+      code: `
+      const translateService: any = { instant: (k: string) => k }
+      translateService.instant('KEY')
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/mocks/translate.mock.ts`,
+      code: `
+      const translate: any = { instant: (k: string) => k }
+      translate.instant('KEY')
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/a.ts`,
+      code: `
+      const other = { instant: (k: string) => k }
+      other.instant('KEY')
+      `,
+    },
+  ],
+  invalid: [
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/a.ts`,
+      code: `
+      class A {
+        constructor(private translate: any) {}
+        test() {
+          return this.translate.instant('KEY')
+        }
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/b.ts`,
+      code: `
+      function f(translate: any) {
+        return translate.instant('KEY')
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/c.ts`,
+      code: `
+      function f(translateService: any) {
+        return translateService.instant('KEY')
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/d.ts`,
+      code: `
+      class A {
+        private translateService: any
+        test() {
+          return this.translateService.instant('KEY')
+        }
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/e.ts`,
+      code: `
+      import { TranslateService } from '@ngx-translate/core'
+
+      class A {
+        constructor(private translate: TranslateService) {}
+        test() {
+          return this.translate.instant('KEY')
+        }
+      }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/f.ts`,
+      code: `
+      import { TranslateService } from '@ngx-translate/core'
+
+      function f(translateService: TranslateService) {
+        return translateService.instant('KEY')
+      }
+      `,
+      errors: [{ messageId }],
+    },
+  ],
+})

package/src/lib/rules/no-translate-instant.rule.ts

@@ -0,0 +1,98 @@
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils'
+import { isTranslateServiceType } from '../utils/type-utils'
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/onecx/onecx-portal-ui-libs/tree/main/libs/angular-linter-rules#${name}`,
+)
+
+type Options = []
+type MessageIds = 'noTranslateInstant'
+
+const defaultAllowedFilePatterns = [/\.spec\.ts$/i, /\.test\.ts$/i, /\/testing\//i, /\/mocks\//i]
+
+function isAllowedTestFile(filename: string): boolean {
+  if (!filename || filename === '<input>' || filename === '<text>') return false
+  return defaultAllowedFilePatterns.some((re) => re.test(filename))
+}
+
+function isInstantMemberCall(node: TSESTree.CallExpression): boolean {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false
+  const property = node.callee.property
+  if (property.type !== AST_NODE_TYPES.Identifier || property.name !== 'instant') return false
+
+  const obj = node.callee.object
+  if (obj.type === AST_NODE_TYPES.Identifier) {
+    return obj.name === 'translate' || obj.name === 'translateService'
+  }
+
+  if (obj.type === AST_NODE_TYPES.MemberExpression) {
+    if (obj.object.type !== AST_NODE_TYPES.ThisExpression) return false
+    if (obj.property.type !== AST_NODE_TYPES.Identifier) return false
+    return obj.property.name === 'translate' || obj.property.name === 'translateService'
+  }
+
+  return false
+}
+
+type ContextWithTypeInfo = {
+  sourceCode: {
+    parserServices?: {
+      program?: unknown
+      esTreeNodeToTSNodeMap?: unknown
+    }
+  }
+}
+
+function isTranslateServiceReceiver(context: ContextWithTypeInfo, node: TSESTree.CallExpression): boolean {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false
+  if (!context.sourceCode.parserServices?.program) return false
+
+  const { esTreeNodeToTSNodeMap, program } = context.sourceCode.parserServices
+  if (!esTreeNodeToTSNodeMap) return false
+  const checker = (program as any).getTypeChecker()
+
+  const receiverTsNode = (esTreeNodeToTSNodeMap as any).get(node.callee.object as any)
+  const receiverType = checker.getTypeAtLocation(receiverTsNode)
+  if (isTranslateServiceType(checker, receiverType)) return true
+
+  const receiverTypeText = checker.typeToString(receiverType)
+  return receiverTypeText === 'TranslateService'
+}
+
+export const noTranslateInstant = createRule<Options, MessageIds>({
+  name: 'no-translate-instant',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow ngx-translate TranslateService.instant outside of tests.',
+    },
+    schema: [],
+    messages: {
+      noTranslateInstant:
+        'Avoid `TranslateService.instant(...)` in production code. Use stream-based translation (`get`/`stream`) or the translate pipe instead.',
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename
+    const allowed = isAllowedTestFile(filename)
+
+    return {
+      CallExpression(node) {
+        if (allowed) return
+
+        if (isTranslateServiceReceiver(context as unknown as ContextWithTypeInfo, node)) {
+          context.report({ node: node.callee, messageId: 'noTranslateInstant' })
+          return
+        }
+
+        if (!isInstantMemberCall(node)) return
+
+        context.report({
+          node: node.callee,
+          messageId: 'noTranslateInstant',
+        })
+      },
+    }
+  },
+})

package/src/lib/rules/prefer-translate-params.rule.spec.ts

@@ -0,0 +1,97 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import { preferTranslateParams } from './prefer-translate-params.rule'
+
+RuleTester.afterAll = afterAll
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: require('@typescript-eslint/parser'),
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+  },
+} as unknown as any)
+
+const messageId = 'preferTranslateParams'
+
+ruleTester.run('prefer-translate-params', preferTranslateParams, {
+  valid: [
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/a.ts`,
+      code: `
+        function f(translate: any, name: string) {
+          return translate.get('HELLO_NAME', { name })
+        }
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/b.ts`,
+      code: `
+        function f(translate: any, name: string) {
+          return translate.get('HELLO_' + name)
+        }
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/b2.ts`,
+      code: `
+        function f(translate: any, name: string) {
+          return translate.stream('HELLO_' + name)
+        }
+      `,
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/some.spec.ts`,
+      code: `
+        function f(translate: any, name: string) {
+          return translate.get('HELLO')
+        }
+      `,
+    },
+  ],
+  invalid: [
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/d.ts`,
+      code: `
+        import { map } from 'rxjs'
+
+        function f(translateService: any, name: string) {
+          return translate.get('HELLO').pipe(map((t: string) => 'Hi ' + t))
+        }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/rx.ts`,
+      code: `
+        import { map } from 'rxjs'
+
+        function f(translate: any, name: string) {
+          return translate.get('HELLO').pipe(map((t: string) => t + name))
+        }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/rx2.ts`,
+      code: `
+        import { map } from 'rxjs'
+
+        function f(translate: any, name: string) {
+          return translate.stream('HELLO').pipe(map((t: string) => t + name))
+        }
+      `,
+      errors: [{ messageId }],
+    },
+    {
+      filename: `${process.cwd()}/libs/angular-linter-rules/src/app/e.ts`,
+      code: `
+        function f(translate: any, name: string) {
+          return ` + "`" + '${translate.instant(\'HELLO\')} ${name}' + "`" + `
+        }
+      `,
+      errors: [{ messageId }],
+    },
+  ],
+})

package/src/lib/rules/prefer-translate-params.rule.ts

@@ -0,0 +1,133 @@
+import { AST_NODE_TYPES, ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/utils'
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/onecx/onecx-portal-ui-libs/tree/main/libs/angular-linter-rules#${name}`,
+)
+
+type Options = []
+type MessageIds = 'preferTranslateParams'
+
+const defaultAllowedFilePatterns = [/\.spec\.ts$/i, /\.test\.ts$/i, /\/testing\//i, /\/mocks\//i]
+
+function isAllowedTestFile(filename: string): boolean {
+  if (!filename || filename === '<input>' || filename === '<text>') return false
+  return defaultAllowedFilePatterns.some((re) => re.test(filename))
+}
+
+function isTranslateGetOrStreamCallExpression(node: TSESTree.Node): node is TSESTree.CallExpression {
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false
+  if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return false
+  return node.callee.property.name === 'get' || node.callee.property.name === 'stream'
+}
+
+function isTranslateInstantCallExpression(node: TSESTree.Node): node is TSESTree.CallExpression {
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false
+  if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return false
+  return node.callee.property.name === 'instant'
+}
+
+function isTranslateGetOrStreamPipeCallExpression(node: TSESTree.Node): node is TSESTree.CallExpression {
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false
+  if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return false
+  if (node.callee.property.name !== 'pipe') return false
+
+  const obj = node.callee.object
+  return isTranslateGetOrStreamCallExpression(obj)
+}
+
+function containsBinaryPlus(context: TSESLint.RuleContext<MessageIds, Options>, node: TSESTree.Node): boolean {
+  let found = false
+
+  const visit = (n: TSESTree.Node): void => {
+    if (found) return
+
+    if (n.type === AST_NODE_TYPES.BinaryExpression && n.operator === '+') {
+      found = true
+      return
+    }
+
+    const keys = context.sourceCode.visitorKeys[n.type] ?? []
+    for (const key of keys) {
+      const value = (n as unknown as Record<string, unknown>)[key]
+      if (!value) continue
+
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (found) return
+          if (child && typeof child === 'object' && 'type' in (child as Record<string, unknown>)) {
+            visit(child as TSESTree.Node)
+          }
+        }
+        continue
+      }
+
+      if (value && typeof value === 'object' && 'type' in (value as Record<string, unknown>)) {
+        visit(value as TSESTree.Node)
+      }
+    }
+  }
+
+  visit(node)
+  return found
+}
+
+function isTranslatePipeExpression(node: TSESTree.Expression): boolean {
+  if (node.type !== AST_NODE_TYPES.BinaryExpression || node.operator !== '|') return false
+  const right = node.right
+  return right.type === AST_NODE_TYPES.Identifier && right.name === 'translate'
+}
+
+export const preferTranslateParams = createRule<Options, MessageIds>({
+  name: 'prefer-translate-params',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer translation parameters instead of concatenating translated strings (use e.g. `translate.get(key, { param })`).',
+    },
+    schema: [],
+    messages: {
+      preferTranslateParams:
+        'Avoid concatenating translated strings. Prefer translation parameters/placeholders instead (e.g. `translate.get(key, { value })`).',
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename
+    const allowed = isAllowedTestFile(filename)
+
+    if (allowed) {
+      return {}
+    }
+
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== '+') return
+        if (
+          isTranslateGetOrStreamCallExpression(node.left) ||
+          isTranslateGetOrStreamCallExpression(node.right) ||
+          isTranslateInstantCallExpression(node.left) ||
+          isTranslateInstantCallExpression(node.right) ||
+          isTranslatePipeExpression(node.left) ||
+          isTranslatePipeExpression(node.right)
+        ) {
+          context.report({ node, messageId: 'preferTranslateParams' })
+        }
+      },
+      TemplateLiteral(node) {
+        if (!node.expressions.some((expr) => isTranslateGetOrStreamCallExpression(expr) || isTranslateInstantCallExpression(expr))) {
+          return
+        }
+        context.report({ node, messageId: 'preferTranslateParams' })
+      },
+      CallExpression(node) {
+        if (!isTranslateGetOrStreamPipeCallExpression(node)) return
+        if (!containsBinaryPlus(context, node)) return
+        context.report({ node, messageId: 'preferTranslateParams' })
+      },
+    }
+  },
+})

package/src/lib/types.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from '@typescript-eslint/utils'
+
+export type AngularLinterRulesPlugin = {
+  rules: Record<string, TSESLint.RuleModule<string, readonly unknown[]>>
+  configs: Record<string, TSESLint.Linter.Config>
+}

package/src/lib/utils/type-utils.ts

@@ -0,0 +1,15 @@
+import type ts from 'typescript'
+
+export function isTranslateServiceType(typeChecker: ts.TypeChecker, type: ts.Type): boolean {
+  const symbol = type.getSymbol() ?? type.aliasSymbol
+  if (!symbol) return false
+
+  const name = symbol.getName()
+  if (name !== 'TranslateService') return false
+
+  const declarations = symbol.getDeclarations() ?? []
+  return declarations.some((decl) => {
+    const sourceFileName = decl.getSourceFile().fileName
+    return sourceFileName.includes('/@ngx-translate/core/') || sourceFileName.includes('\\@ngx-translate\\core\\')
+  })
+}

package/src/types/rule-tester.d.ts

@@ -0,0 +1,3 @@
+declare module '@typescript-eslint/rule-tester' {
+  export * from '@typescript-eslint/rule-tester/dist/index'
+}

package/src/version.ts

@@ -0,0 +1,2 @@
+export const LIB_NAME = '@onecx/angular-linter-rules'
+export const LIB_VERSION = '0.0.0-PLACEHOLDER'

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.rule-tester.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.spec.json",
+  "include": ["src/**/*.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/*.d.ts", "jest.config.ts"],
+  "exclude": []
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}