@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/selfComparisons.test.js

@@ -1,298 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./selfComparisons.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-if (value === value) {
-	console.log("always true");
-}
-`,
-            snapshot: `
-if (value === value) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-        },
-        {
-            code: `
-if (value == value) {
-	console.log("always true");
-}
-`,
-            snapshot: `
-if (value == value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-        },
-        {
-            code: `
-if (value !== value) {
-	console.log("always false");
-}
-`,
-            snapshot: `
-if (value !== value) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-        },
-        {
-            code: `
-if (value != value) {
-	console.log("always false");
-}
-`,
-            snapshot: `
-if (value != value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-        },
-        {
-            code: `
-if (value < value) {
-	console.log("always false");
-}
-`,
-            snapshot: `
-if (value < value) {
-    ~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-        },
-        {
-            code: `
-if (value <= value) {
-	console.log("always true");
-}
-`,
-            snapshot: `
-if (value <= value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-        },
-        {
-            code: `
-if (value > value) {
-	console.log("always false");
-}
-`,
-            snapshot: `
-if (value > value) {
-    ~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-        },
-        {
-            code: `
-if (value >= value) {
-	console.log("always true");
-}
-`,
-            snapshot: `
-if (value >= value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-        },
-        {
-            code: `
-const result = object.property === object.property;
-`,
-            snapshot: `
-const result = object.property === object.property;
-               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-        },
-        {
-            code: `
-const result = array[0] === array[0];
-`,
-            snapshot: `
-const result = array[0] === array[0];
-               ~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-        },
-        {
-            code: `
-if (calculate() === calculate()) {
-	console.log("functions");
-}
-`,
-            snapshot: `
-if (calculate() === calculate()) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("functions");
-}
-`,
-        },
-        {
-            code: `
-if (value /* comment */ === value) {
-	console.log("with comment");
-}
-`,
-            snapshot: `
-if (value /* comment */ === value) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment");
-}
-`,
-        },
-        {
-            code: `
-if (object.property /* comment */ === object.property) {
-	console.log("with comment in property access");
-}
-`,
-            snapshot: `
-if (object.property /* comment */ === object.property) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment in property access");
-}
-`,
-        },
-        {
-            code: `
-if (array /* comment */ [0] === array[0]) {
-	console.log("with comment in array access");
-}
-`,
-            snapshot: `
-if (array /* comment */ [0] === array[0]) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment in array access");
-}
-`,
-        },
-        {
-            code: `
-if (value === value /* comment */) {
-	console.log("comment on right side");
-}
-`,
-            snapshot: `
-if (value === value /* comment */) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right side");
-}
-`,
-        },
-        {
-            code: `
-if (value /* left */ === value /* right */) {
-	console.log("comments on both sides");
-}
-`,
-            snapshot: `
-if (value /* left */ === value /* right */) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comments on both sides");
-}
-`,
-        },
-        {
-            code: `
-if (object.property === object /* comment */ .property) {
-	console.log("comment on right property access");
-}
-`,
-            snapshot: `
-if (object.property === object /* comment */ .property) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right property access");
-}
-`,
-        },
-        {
-            code: `
-if (array[0] === array /* comment */ [0]) {
-	console.log("comment on right array access");
-}
-`,
-            snapshot: `
-if (array[0] === array /* comment */ [0]) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right array access");
-}
-`,
-        },
-        {
-            code: `
-if (/* before */ value === value /* after */) {
-	console.log("comments before and after");
-}
-`,
-            snapshot: `
-if (/* before */ value === value /* after */) {
-                 ~~~~~~~~~~~~~~~
-                 Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comments before and after");
-}
-`,
-        },
-        {
-            code: `
-const result = value /* a */ /* b */ === value /* c */ /* d */;
-`,
-            snapshot: `
-const result = value /* a */ /* b */ === value /* c */ /* d */;
-               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-        },
-    ],
-    valid: [
-        `if (value1 === value2) { console.log("different values"); }`,
-        `if (value === other) { console.log("different values"); }`,
-        `if (object.property === object.otherProperty) { console.log("different properties"); }`,
-        `if (array[0] === array[1]) { console.log("different elements"); }`,
-        `const result = value1 == value2;`,
-        `const result = value1 != value2;`,
-        `const result = value1 !== value2;`,
-        `const result = value1 < value2;`,
-        `const result = value1 <= value2;`,
-        `const result = value1 > value2;`,
-        `const result = value1 >= value2;`,
-        `if (Number.isNaN(value)) { console.log("checking for NaN correctly"); }`,
-        `if (value1 /* comment */ === value2) { console.log("different with comment on left"); }`,
-        `if (value1 === value2 /* comment */) { console.log("different with comment on right"); }`,
-        `if (value1 /* left */ === value2 /* right */) { console.log("different with comments on both"); }`,
-        `if (object /* comment */ .property === object.otherProperty) { console.log("different properties with comment"); }`,
-        `if (object.property === object /* comment */ .otherProperty) { console.log("different properties with comment on right"); }`,
-        `if (array /* comment */ [0] === array[1]) { console.log("different elements with comment on left"); }`,
-        `if (array[0] === array /* comment */ [1]) { console.log("different elements with comment on right"); }`,
-        `if (/* before */ value1 === value2 /* after */) { console.log("different with surrounding comments"); }`,
-        `const result = value1 /* a */ /* b */ === value2 /* c */ /* d */;`,
-    ],
-});
-//# sourceMappingURL=selfComparisons.test.js.map

package/lib/rules/sequences.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sequences.test.d.ts.map

package/lib/rules/sequences.test.js

@@ -1,49 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./sequences.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-const a = (1, 2);
-`,
-            snapshot: `
-const a = (1, 2);
-            ~
-            The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-`,
-        },
-        {
-            code: `
-function f() {
-    return (g(), h());
-}
-`,
-            snapshot: `
-function f() {
-    return (g(), h());
-               ~
-               The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-}
-`,
-        },
-        {
-            code: `
-for ((a = 1, b = 2); ; ) {
-}
-`,
-            snapshot: `
-for ((a = 1, b = 2); ; ) {
-           ~
-           The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-}
-`,
-        },
-    ],
-    valid: [
-        `const a = [1, 2];`,
-        `const a = (1 + 2);`,
-        `function f() { g(); h(); }`,
-        `for (let i = 0; i < 10; i += 1) {}`,
-    ],
-});
-//# sourceMappingURL=sequences.test.js.map

package/lib/rules/shadowedRestrictedNames.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=shadowedRestrictedNames.test.d.ts.map

package/lib/rules/shadowedRestrictedNames.test.js

@@ -1,148 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./shadowedRestrictedNames.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-let undefined = 5;
-`,
-            snapshot: `
-let undefined = 5;
-    ~~~~~~~~~
-    This variable misleadingly shadows the global \`undefined\`.
-`,
-        },
-        {
-            code: `
-const NaN = 123;
-`,
-            snapshot: `
-const NaN = 123;
-      ~~~
-      This variable misleadingly shadows the global \`NaN\`.
-`,
-        },
-        {
-            code: `
-var Infinity = 100;
-`,
-            snapshot: `
-var Infinity = 100;
-    ~~~~~~~~
-    This variable misleadingly shadows the global \`Infinity\`.
-`,
-        },
-        {
-            code: `
-function test(arguments) {
-    return arguments.length;
-}
-`,
-            snapshot: `
-function test(arguments) {
-              ~~~~~~~~~
-              This variable misleadingly shadows the global \`arguments\`.
-    return arguments.length;
-}
-`,
-        },
-        {
-            code: `
-function eval() {
-    return 42;
-}
-`,
-            snapshot: `
-function eval() {
-         ~~~~
-         This variable misleadingly shadows the global \`eval\`.
-    return 42;
-}
-`,
-        },
-        {
-            code: `
-const arrowFunc = (undefined) => undefined;
-`,
-            snapshot: `
-const arrowFunc = (undefined) => undefined;
-                   ~~~~~~~~~
-                   This variable misleadingly shadows the global \`undefined\`.
-`,
-        },
-        {
-            code: `
-class NaN {
-    constructor() {}
-}
-`,
-            snapshot: `
-class NaN {
-      ~~~
-      This variable misleadingly shadows the global \`NaN\`.
-    constructor() {}
-}
-`,
-        },
-        {
-            code: `
-const obj = {
-    method(eval) {
-        return eval;
-    }
-};
-`,
-            snapshot: `
-const obj = {
-    method(eval) {
-           ~~~~
-           This variable misleadingly shadows the global \`eval\`.
-        return eval;
-    }
-};
-`,
-        },
-        {
-            code: `
-function test() {
-    const { undefined } = obj;
-}
-`,
-            snapshot: `
-function test() {
-    const { undefined } = obj;
-            ~~~~~~~~~
-            This variable misleadingly shadows the global \`undefined\`.
-}
-`,
-        },
-        {
-            code: `
-function test() {
-    const [NaN] = array;
-}
-`,
-            snapshot: `
-function test() {
-    const [NaN] = array;
-           ~~~
-           This variable misleadingly shadows the global \`NaN\`.
-}
-`,
-        },
-    ],
-    valid: [
-        `let value = undefined;`,
-        `const result = NaN;`,
-        `const max = Infinity;`,
-        `function test() { return arguments; }`,
-        `const code = eval("1 + 1");`,
-        `let myValue = 5;`,
-        `function myFunction() {}`,
-        `class MyClass {}`,
-        `const obj = { undefined: 5 };`,
-        `const key = "undefined";`,
-        `obj.undefined = 5;`,
-    ],
-});
-//# sourceMappingURL=shadowedRestrictedNames.test.js.map

package/lib/rules/sparseArrays.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sparseArrays.test.d.ts.map

package/lib/rules/sparseArrays.test.js

@@ -1,111 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./sparseArrays.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-const array = [1, , 3];
-`,
-            snapshot: `
-const array = [1, , 3];
-                  ~
-                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-        },
-        {
-            code: `
-const array = [, 2, 3];
-`,
-            snapshot: `
-const array = [, 2, 3];
-               ~
-               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-        },
-        {
-            code: `
-const array = [1, , , 4];
-`,
-            snapshot: `
-const array = [1, , , 4];
-                  ~
-                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-                    ~
-                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-        },
-        {
-            code: `
-const nested = [[1, , 3], [4, 5, 6]];
-`,
-            snapshot: `
-const nested = [[1, , 3], [4, 5, 6]];
-                    ~
-                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-        },
-        {
-            code: `
-const result = [
-    1,
-    ,
-    3
-];
-`,
-            snapshot: `
-const result = [
-    1,
-    ,
-    ~
-    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-    3
-];
-`,
-        },
-        {
-            code: `
-const matrix = [
-    [1, 2, 3],
-    [4, , 6],
-    [7, 8, 9]
-];
-`,
-            snapshot: `
-const matrix = [
-    [1, 2, 3],
-    [4, , 6],
-        ~
-        Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-    [7, 8, 9]
-];
-`,
-        },
-        {
-            code: `
-function getArray() {
-    return [1, , 3];
-}
-`,
-            snapshot: `
-function getArray() {
-    return [1, , 3];
-               ~
-               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-}
-`,
-        },
-    ],
-    valid: [
-        `const array = [1, 2, 3];`,
-        `const array = [];`,
-        `const array = [1];`,
-        `const array = [1, undefined, 3];`,
-        `const array = [undefined, 2, 3];`,
-        `const array = [1, 2, undefined];`,
-        `const array = [1, 2, 3,];`,
-        `const nested = [[1, undefined, 3], [4, 5, 6]];`,
-        `const matrix = [[1, 2, 3], [4, undefined, 6], [7, 8, 9]];`,
-        `const values = [null, undefined, 0, false, ""];`,
-    ],
-});
-//# sourceMappingURL=sparseArrays.test.js.map

package/lib/rules/symbolDescriptions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=symbolDescriptions.test.d.ts.map

package/lib/rules/symbolDescriptions.test.js

@@ -1,90 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./symbolDescriptions.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-const symbol = Symbol();
-`,
-            snapshot: `
-const symbol = Symbol();
-               ~~~~~~~~
-               Symbols without descriptions are more difficult to debug or reason about.
-`,
-        },
-        {
-            code: `
-const uniqueKey = Symbol();
-`,
-            snapshot: `
-const uniqueKey = Symbol();
-                  ~~~~~~~~
-                  Symbols without descriptions are more difficult to debug or reason about.
-`,
-        },
-        {
-            code: `
-const symbols = [Symbol(), Symbol()];
-`,
-            snapshot: `
-const symbols = [Symbol(), Symbol()];
-                 ~~~~~~~~
-                 Symbols without descriptions are more difficult to debug or reason about.
-                           ~~~~~~~~
-                           Symbols without descriptions are more difficult to debug or reason about.
-`,
-        },
-        {
-            code: `
-function createSymbol() {
-	return Symbol();
-}
-`,
-            snapshot: `
-function createSymbol() {
-	return Symbol();
-	       ~~~~~~~~
-	       Symbols without descriptions are more difficult to debug or reason about.
-}
-`,
-        },
-        {
-            code: `
-const obj = {
-	key: Symbol(),
-};
-`,
-            snapshot: `
-const obj = {
-	key: Symbol(),
-	     ~~~~~~~~
-	     Symbols without descriptions are more difficult to debug or reason about.
-};
-`,
-        },
-        {
-            code: `
-const value = condition ? Symbol() : null;
-`,
-            snapshot: `
-const value = condition ? Symbol() : null;
-                          ~~~~~~~~
-                          Symbols without descriptions are more difficult to debug or reason about.
-`,
-        },
-    ],
-    valid: [
-        `const symbol = Symbol("description");`,
-        `const uniqueKey = Symbol("uniqueKey");`,
-        `const mySymbol = Symbol("my symbol");`,
-        `const symbols = [Symbol("first"), Symbol("second")];`,
-        `function createSymbol() { return Symbol("created"); }`,
-        `const obj = { key: Symbol("key") };`,
-        `const value = Symbol.for("global");`,
-        `const iterator = Symbol.iterator;`,
-        `const hasInstance = Symbol.hasInstance;`,
-        `const primitiveValue = Symbol.toPrimitive;`,
-        `Symbol("valid")`,
-    ],
-});
-//# sourceMappingURL=symbolDescriptions.test.js.map

package/lib/rules/typeofComparisons.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=typeofComparisons.test.d.ts.map