5.0.0-alpha.12 (2022-01-24)

Bug Fixes

• deps: update dependency @typescript-eslint/eslint-plugin to v5 (#73) (400699c)
• deps: update dependency @typescript-eslint/parser to v5 (#74) (655cff1)
• deps: update dependency eslint-plugin-jsdoc to v37 (#75) (4847a7e)
• deps: update dependency eslint-plugin-sonarjs to ^0.10.0 || ^0.11.0 (#55) (d0ed5eb)

4.3.5 (2022-01-24)

Bug Fixes

• deps: update dependency eslint-plugin-jsdoc to v37 (#75) (4847a7e)

4.3.4 (2022-01-24)

Bug Fixes

• deps: update dependency @typescript-eslint/eslint-plugin to v5 (#73) (400699c)

4.3.3 (2022-01-23)

Bug Fixes

• deps: update dependency @typescript-eslint/parser to v5 (#74) (655cff1)

5.0.0-alpha.11 (2022-01-23)

Bug Fixes

• deps: support eslint v8 (#64) (701bda4)

4.3.2 (2021-12-13)

Bug Fixes

• deps: update dependency eslint-plugin-sonarjs to ^0.10.0 || ^0.11.0 (#55) (d0ed5eb)

5.0.0-alpha.10 (2021-12-03)

Bug Fixes

• deps: update dependency eslint-plugin-sonarjs to ^0.10.0 || ^0.11.0 (#56) (afeb8d6)

5.0.0-alpha.9 (2021-11-09)

Features

• treat all source files in test subdirectories as automated tests (f2346be)

BREAKING CHANGES

• Source files in subdirectories named "test" are now treated as automated tests.

5.0.0-alpha.8 (2021-11-08)

Features

• deps: update dependency eslint to v8 (f22c703)

BREAKING CHANGES

• deps: eslint is updated to v8 which includes breaking changes, see
  https://github.com/eslint/eslint/releases/v8.0.0
• deps: eslint-plugin-jsdoc is updated to v37, which includes
  breaking changes, see https://github.com/gajus/eslint-plugin-jsdoc/releases/v37.0.0

5.0.0-alpha.7 (2021-10-30)

Bug Fixes

• naming-convention: fix naming convention rule for type parameters (911d565)

5.0.0-alpha.6 (2021-10-30)

Bug Fixes

• naming-convention: fix naming convention rule for type parameters (1fbb478)

5.0.0-alpha.5 (2021-10-03)

Features

• naming-convention: in tsx files, allow functions to have PascalCase names (7ca06ce)

5.0.0-alpha.4 (2021-10-03)

Bug Fixes

• don't require tsconfig to check js files (1ddd484)

5.0.0-alpha.3 (2021-09-10)

Bug Fixes

• deps: require newer typescript-eslint, fixing missing rule 'prefer-return-this-type' (163ad79)

5.0.0-alpha.2 (2021-09-09)

Features

• no-unneeded-ternary: disallow ternary expressions where simpler alternatives exist (73caf43)
• no-useless-computed-key: disallow unnecessary use of computed keys (cd2c1ec)
• no-useless-rename: disallow renaming import/export/destructured assignments to the same name (7fd3267)
• no-var: disallow use of var in plain JavaScript (c1ebd98)
• prefer-const: require variables to be declared with const if they are not reassigned (7f2f62d)
• prefer-exponentiation-operator: disallow use of Math.pow function (15c8d0b)
• prefer-numeric-literals: prefer numeric literals to parseInt where possible (fb205a5)
• prefer-rest-params: disallow use of arguments in favour of rest params (44a7db7)
• prefer-spread: disallow calls to function.apply() where spread params could be used (2e106ff)

BREAKING CHANGES

• prefer-spread: In plain JS, it is now considered an error to call function.apply() in cases
  where the spread operator could be used instead.
• prefer-rest-params: In plain JS, it is now considered an error to use the arguments variable. Use
  rest params instead.
• prefer-numeric-literals: It is now considered an error to call parseInt to convert a static value from
  binary, octal or hexadecimal. Use a binary, octal or hexadecimal literal instead.
• prefer-const: In plain JS, it is now considered an error to declare a variable using let if it
  is never reassigned. Use const instead.
• no-var: Use of var to declare variables is now considered an error in plain JS. Use let
  or const instead.
• no-useless-rename: Renaming references in import/export statements and destructured assignments is now
  considered an error if the new name is the same as the old name.
• no-useless-computed-key: Unnecessary use of computed keys in object literals and classes is now disallowed.
• prefer-exponentiation-operator: Use of the Math.pow function is now disallowed in favour of the exponentiation
  operator **.
• no-unneeded-ternary: Ternary expressions are now disallowed in cases where a simpler alternative could
  be used instead.

5.0.0-alpha.1 (2021-09-07)

Bug Fixes

• deps: use latest versions of dependencies (930885d)
• esm: don't parse CommonJS as ESM (e637bbc)
• no-duplicate-imports: don't complain in case where duplicate imports are required (58a67a2)

Features

• array-callback-return: require array callbacks return a value (except forEach) (b2ae4a8)
• ban-tslint-comment: enable rule (1e0ea6b)
• ban-types: update to more closely match typescript-eslint recommended configuration (0fd05e4)
• consistent-return: require functions to always or never return an explicit value (5c7888c)
• consistent-type-assertions: enforce use of "as", disallow object literal type assertions (9cfec1c)
• consistent-type-definitions: prefer "interface" over "type" where possible (9812a01)
• consistent-type-imports: enforce rule with default settings (f1fb31d)
• esm: add additional set of rules for ESM projects (6e60cde)
• explicit-module-boundary-types: exported variables must now specify an explicit type (dcd1234)
• method-signature-style: enforce property/lambda-style syntax for methods (337caec)
• naming-convention: enforce some naming conventions (fb0e22b)
• no-alert: disallow calls to alert, confirm, or prompt (d116bc5)
• no-all-duplicated-branches: disallow conditionals with duplicated branches (af8034e)
• no-base-to-string: disallow calling the base implementation of Object.toString (6bb6cc6)
• no-collapsible-if: disallow nested collapsible if statements (00f2fba)
• no-collection-size-mischeck: disallow meaningless collection size checks (a482481)
• no-confusing-non-null-assertion: disallow confusing non-null assertions (ca89b31)
• no-confusing-void-expression: disallow confusing void expressions (c152caf)
• no-constructor-return: disallow returning a value from a constructor (12db42d)
• no-duplicated-branches: disallow duplicate branches in conditional statements (8952277)
• no-element-overwrite: disallow unconditional overwrite of previously set collection element (166155d)
• no-empty-collection: disallow access or iteration of collections that are definitely empty (6d31e0d)
• no-explicit-any: disallow use of any type (5864f89)
• no-extend-native: disallow modifying the prototypes of built-in types (0e44e39)
• no-extra-arguments: disallow passing extra unused arguments to a function in plain JS (07d200b)
• no-extra-semi: disable rule, prettier handles this (0cae947)
• no-gratuitous-expressions: disallow boolean expressions that have no effect (38baddd)
• no-identical-conditions: disallow related if/else if statements with identical conditions (867c013)
• no-identical-expressions: disallow identical expressions either side of some binary operators (1bb86e0)
• no-identical-functions: disallow identical functions (f9a3ed0)
• no-ignored-return: disallow ignoring the return value of functions that have no side effects (50b62a5)
• no-implicit-any-catch: disallow use of any type in catch clause (249eb6f)
• no-implicit-coercion: disallow confusing implicit coercions (099420a)
• no-invalid-this: disallow use of this keyword outside classes or class-like objects (e44f9c0)
• no-invalid-void-type: disallow use of void type outside generic or return types (7046a8b)
• no-inverted-boolean-check: disallow needlessly complex inverted boolean checks (f35ce7d)
• no-irregular-whitespace: also enforce rule in string literals (942909b)
• no-iterator: disallow use of obsolete __iterator__ extension (db2c93e)
• no-lone-blocks: disallow unnecessary nested blocks (4d6f66e)
• no-loop-func: disallow function declarations with unsafe references inside loop statements (4e722b5)
• no-loss-of-precision: disallow literal numbers that lose precision (687f30a)
• no-non-null-assertion: disallow use of the non-null assertion ! (2038b6c)
• no-nonoctal-decimal-escape: disallow useless \8 and \9 escape sequences in strings (b140eef)
• no-octal-escape: disallow octal escapes in string literals (81d793f)
• no-one-iteration-loop: disallow loops that iterate at most once (4857ac0)
• no-param-reassign: disallow function parameter reassignment (383edb5)
• no-promise-executor-return: disallow returning a value from a promise executor (f2f2366)
• no-redundant-boolean: disallow redundant boolean literals (9f2629d)
• no-redundant-jump: disallow redundant jump statements (c6f1943)
• no-return-assign: disallow assignment in return statement (fa4d55a)
• no-sequences: disallow use of the comma operator (aa4ec94)
• no-unnecessary-qualifier: disallow unnecessary namespace or enum qualifiers (992cc96)
• no-unnecessary-type-arguments: disallow type arguments that match the default (a13ec0c)
• no-unnecessary-type-assertion: disallow unnecessary type assertions (bc47992)
• no-unnecessary-type-constraint: disallow unnecessary type constraints (9e148de)
• no-unsafe-argument: disallow passing any to a function that expects a specific type (1196da3)
• no-unsafe-assignment: disallow assigning any to a variable with a specific type (42d9e96)
• no-unsafe-member-access: disallow unsafe member access of any (71cba5b)
• no-unsafe-optional-chaining: disallow optional chaining in unsafe contexts (0eb95dc)
• no-unsafe-return: disallow returning any from a function that declares a specific type (e7daa78)
• no-unused-collection: disallow unused collections (46986a1)
• no-unused-expressions: disallow unused JSX expressions (4f27b27)
• no-use-of-empty-return-value: disallow use of empty return value (965f71b)
• no-useless-backreference: disallow useless regex backreferences (3d21906)
• no-useless-call: disallow useless invocation of function.call() and .apply() (abf826b)
• no-useless-catch: disallow catch clauses that do nothing but rethrow the exception (77cbeb6)
• no-useless-concat: disallow useless concatenation of string literals (29b28a2)
• non-existent-operator: disallow confusing assignment operations (a236986)
• non-nullable-type-assertion-style: disallow type casts that only remove null or undefined (b726bc1)
• prefer-includes: disallow use of indexOf or regular expressions where includes() could be used (8921a85)
• prefer-nullish-coalescing: disallow use of boolean operators to coalesce nullish values (290e1dc)
• prefer-object-literal: disallow assigning to an object when an object literal could be used (371125e)
• prefer-optional-chain: disallow chained logical ands where optional chains could be used (eee19e3)
• prefer-promise-reject-errors: require use of Error objects as Promise rejection reasons (8d84095)
• prefer-readonly: require private members to be marked readonly where possible (a8c2ae2)
• prefer-regex-literals: disallow unnecessary use of the RegExp constructor (cd5d112)
• prefer-return-this-type: enforce functions that return this are typed as this (5d16a78)
• prefer-string-starts-ends-with: require use of startsWith and endsWith string methods (cb70b88)
• prefer-while: apply rule to JavaScript as well as TypeScript (7224fec)
• require-array-sort-compare: require a compare function when calling array.sort() (4321d77)
• require-atomic-updates: disallow async assignments that can cause race conditions (39a79d3)
• require-unicode-regexp: require regular expressions to use the u flag (605cb8f)
• strict: require "use strict" directive where it is not already implied (00c2199)
• strict-boolean-expressions: disallow any type other than boolean in boolean contexts (3c9b976)

BREAKING CHANGES

• strict: Code must now begin with the "use strict" directive in contexts where it is not
  implied. In contexts such as ESM and TypeScript where "use strict" is implied, explicit use of
  "use strict" is disallowed.
• require-unicode-regexp: Regular expressions are now required to include the u flag.
• prefer-regex-literals: Calling the RegExp constructor with a string literal or regexp literal as its
  argument is now disallowed. Use a regexp literal directly instead.
• prefer-promise-reject-errors: It is now considered an error to pass a value that is not an Error to the
  reject function of a Promise executor.
• no-useless-concat: Concatenation of string literals on a single line is now considered an error.
  Combine the literals into one string.
• no-useless-call: Invocation of function.call() and .apply() is now disallowed in cases where the
  function could just be called directly.
• no-sequences: Use of the comma operator is now disallowed, except in the initialization or update
  portions of a for statement.
• no-return-assign: Assigning to a variable within a return statement is now considered an error.
• no-param-reassign: Reassigning function parameters is now considered an error.
• no-octal-escape: Octal escape sequences are no longer allowed in string literals. Use unicode escape
  sequences instead.
• no-nonoctal-decimal-escape: The useless escape sequences \8 and \9 are no longer allowed in strings. Write
  just 8 or 9 instead.
• no-lone-blocks: Unnecessary nested blocks are now disallowed. See
  no-lone-blocks.
• no-iterator: Use of the obsolete SpiderMonkey extension __iterator__ is now disallowed.
• no-invalid-this: In plain JS, the this keyword is no longer allowed outside classes or class-like
  objects. See no-invalid-this.
• no-implicit-coercion: Certain confusing implicit conversions are now disallowed. See
  no-implicit-coercion.
• no-extend-native: It is now considered an error to modify the prototypes of built-in types such as
  Array or Object.
• no-constructor-return: It is now considered an error to return a value from a constructor.
• no-alert: It is now considered an error to call alert(), confirm(), or prompt().
• consistent-return: In plain JS, it is now considered an error if one code path through a function
  returns an explicit value, but another does not.
• array-callback-return: In plain JS, callbacks passed to array functions such as reduce() are now checked
  to ensure they return a value. If you don't need to return a value, use forEach instead.
• require-atomic-updates: Certain patterns of assignment in asynchronous code are disallowed because they can
  lead to race conditions. See
  require-atomic-updates.
• no-useless-backreference: Useless backreferences in regular expressions are now disallowed. See
  no-useless-backreference.
• no-unsafe-optional-chaining: In plain JS code, it is now considered an error to use optional chaining in a
  context where undefined is not allowed. See
  no-unsafe-optional-chaining.
• no-promise-executor-return: It is now considered an error to return a value from a Promise executor.
• prefer-object-literal: It is now considered an error to create an object and then unconditionally assign
  properties to it. Use an object literal instead.
• no-useless-catch: Catch clauses that do nothing but rethrow the exception are now disallowed.
• no-unused-collection: It is now considered an error to populate a collection but then never use its
  contents.
• no-redundant-jump: Redundant return, break, or continue statements are now considered an error
  in most cases. See
  no-redundant-jump.
• no-redundant-boolean: Redundant boolean literals are now disallowed. See
  no-redundant-boolean.
• no-inverted-boolean-check: Needlessly complex inverted boolean checks are now disallowed. See
  no-inverted-boolean-check.
• no-identical-functions: Functions of three lines or longer with identical implementations are now
  disallowed.
• no-gratuitous-expressions: Boolean expressions that have no effect are now considered an error. See
  no-gratuitous-expressions.
• no-duplicated-branches: Duplicate branches in conditional statements are now considered an error.
• no-collection-size-mischeck: It is now considered an error to test the size of a collection in a way that does
  not make sense. See
  no-collection-size-mischeck.
• no-collapsible-if: It is now considered an error to write nested if statements that could be collapsed
  into a single statement.
• non-existent-operator: Use of the assignment operator = paired with +, - or ! is now disallowed in
  contexts where the pairing could be confused for +=, -=, or !=.
• no-use-of-empty-return-value: Using the return value of a void function is now disallowed.
• no-one-iteration-loop: Loops that iterate at most once are now considered to be an error.
• no-ignored-return: It is now considered an error to ignore the return value of certain functions that
  are known to have no side-effects.
• no-empty-collection: It is now considered an error to access or iterate a collection that is definitely
  empty.
• no-identical-expressions: It is now considered an error to specify identical expressions on either side of a
  binary operator where it makes little sense to do so. See
  no-identical-expressions.
• no-identical-conditions: Related if/else if statements with identical conditions are no longer allowed.
• no-extra-arguments: In plain JS (not TypeScript), it is now considered an error to pass extra unused
  arguments to a function.
• no-element-overwrite: It is now considered an error to unconditionally overwrite an element in a
  collection that was previously set.
• no-all-duplicated-branches: Conditional statements or expressions where all branches have the same
  implementation are now considered to be an error.
• prefer-while: The prefer-while rule now applies to plain JavaScript as well as TypeScript.
• strict-boolean-expressions: It is no longer permitted to perform implicit casts to boolean. Non-boolean
  expressions may not be used the argument of a conditional statement, or as the argument of a boolean
  operator.
• require-array-sort-compare: Calls to array.sort() must now provide a compare function, unless the array is an
  array of strings.
• prefer-string-starts-ends-with: Code that compares the start or end of a string to a value must now use the
  startsWith or endsWith functions.
• prefer-return-this-type: Functions that always return this must be typed as returning this.
• prefer-readonly: Private class members must now be marked readonly if they are not modified outside
  the constructor.
• prefer-optional-chain: Chains of logical and expressions are now disallowed where optional chain
  expressions could be used instead.
• prefer-nullish-coalescing: Use of boolean operators to coalesce nullish values is no longer allowed. Use the
  nullish coalescing operator ?? instead.
• prefer-includes: Use of indexOf or regular expressions is no longer allowed in cases where
  includes() could be used instead.
• non-nullable-type-assertion-style: Type casts that only remove null and/or undefined from the type are no longer
  allowed. Use notNull() from @softwareventures/nullable instead.
• no-unused-expressions: Unused JSX expressions are no longer allowed.
• no-unsafe-return: Returning any from a function that declares a specific return type is no longer
  allowed. Cast the value to unknown and narrow its type using type guards instead.
• no-unsafe-member-access: Member access to any types is no longer allowed. Cast the value to unknown and
  narrow its type using type guards instead.
• no-unsafe-assignment: Assigning any to a variable with a specific type is no longer allowed. Cast the
  value to unknown and then narrow its type using type guards instead.
• no-unsafe-argument: Passing any to a function that expects a specific type is no longer allowed.
  Cast the value to unknown and then narrow its type using type guards instead.
• no-unnecessary-type-constraint: Generic type constraints that extend unknown are no longer allowed. These are
  useless and can be omitted.
• no-unnecessary-type-assertion: Type assertions that do not change the type of the expression are no longer
  allowed.
• no-unnecessary-type-arguments: Unnecessary type arguments (that match the default) are no longer allowed.
• no-unnecessary-qualifier: Unnecessary namespace or enum qualifiers are no longer allowed.
• no-loss-of-precision: Numeric literals that cannot be precisely represented as Number values are no
  longer allowed.
• no-loop-func: Functions declared inside loop statements may not reference variables from the loop
  scope declared with var, or variables declared with let or var from any parent scope where the
  variable is modified inside or outside the loop. Such code is unlikely to behave as the author
  intended and is usually indicative of an error.
• no-invalid-void-type: Use of the type void is no longer allowed except as a function return type or as
  a generic type parameter. Outside of these contexts, undefined is more appropriate.
• no-implicit-any-catch: Use of the any type in a catch clause is no longer allowed. This is the default
  type for the catch clause variable, and the only other permissible type is unknown, so catch
  clause variables must be explicitly typed as unknown. The error can then be handled by narrowing
  the type using type guards.
• no-explicit-any: Use of the any type is no longer allowed. Use the actual type if possible, or use
  unknown in combination with type guards if not.
• no-confusing-void-expression: Void expressions are now disallowed in certain contexts. Void expressions may not
  be returned from a function, assigned to a variable, or passed as a parameter, unless explicitly
  marked as void using the void operator to make the intent clear. See
  no-confusing-void-expressions
  for rationale.
• no-non-null-assertion: Use of the non-null assertion ! is now disallowed. Use optional chaining ?. or
  the notNull() assertion from @softwareventures/nullable instead.
• no-base-to-string: Calling the base Object.toString method (explicitly or implicitly) is now
  disallowed.
• naming-convention: Some naming conventions are now enforced. Variables, functions, parameters and enum
  members must be named in camelCase. Types must be named in PascalCase. Property and method names
  should be in camelCase but are not enforced because that would prevent the use of many third-party
  libraries.
• method-signature-style: The
  method-signature-style
  rule is now enforced with option "property". Method signatures must be expressed as properties
  with function types, instead of using method syntax. This style enables more correct typechecking.
  See the documentation of the rule for more.
• explicit-module-boundary-types: Exported variables must now specify an explicit type.
• consistent-type-imports: Type-only imports are now required wherever possible. Dynamic-style imports of
  types are disallowed. See
  consistent-type-imports.
  The rule is enforced with its default settings.
• consistent-type-definitions: The rule
  consistent-type-definitions
  is now enforced. "interface" is preferred over "type" wherever possible.
• consistent-type-assertions: The rule
  consistent-type-assertions
  is now enforced, with configuration {{assertionStyle: "as", objectLiteralTypeAssertions: "never"}.
• no-irregular-whitespace: The
  no-irregular-whitespace rule is now
  enforced for string literals as well as in all other contexts (skipStrings: false). If you need
  irregular whitespace characters in a string literal, use a Unicode escape instead.
• ban-types: The type {} is now disallowed by the ban-types rule.
• ban-tslint-comment: The
  ban-tslint-comment
  rule is now enforced.

4.3.1 (2021-09-06)

Bug Fixes

• no-unused-expressions: fix incorrect errors reported for TypeScript in some cases (e1a2916)

4.3.0 (2021-09-04)

Bug Fixes

• arrow-parens: delete unused configuration option (6ec7909)

Features

• brace-style: disable rule, prettier handles this (0a284c3)
• member-delimiter-style: disable rule, prettier handles this (e8cfcb3)

4.2.0 (2021-09-04)

Features

• comma-dangle: disable rule, this is handled by prettier (f95907a)

4.1.0 (2021-09-04)

Bug Fixes

• no-restricted-imports: restrict import of config or test files with explicit file extension (5fdb890)

Features

• no-mergeable-namespace: disable rule and remove dependency on tslint (9886997)