@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/sparseArrays.test.js

@@ -1,110 +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, ""];`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/symbolDescriptions.test.js

@@ -1,89 +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")`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/typeofComparisons.test.js

@@ -1,85 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./typeofComparisons.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-if (typeof value === "") {
-    process();
-}
-`,
-            snapshot: `
-if (typeof value === "") {
-                     ~~
-                     This string literal is not one that the typeof operator will ever produce.
-    process();
-}
-`,
-        },
-        {
-            code: `
-if (typeof data != "invalid") {
-    reject();
-}
-`,
-            snapshot: `
-if (typeof data != "invalid") {
-                   ~~~~~~~~~
-                   This string literal is not one that the typeof operator will ever produce.
-    reject();
-}
-`,
-        },
-        {
-            code: `
-if ("invalid" === typeof flag) {
-    toggle();
-}
-`,
-            snapshot: `
-if ("invalid" === typeof flag) {
-    ~~~~~~~~~
-    This string literal is not one that the typeof operator will ever produce.
-    toggle();
-}
-`,
-        },
-        {
-            code: `
-if (typeof value === "String") {
-    process();
-}
-`,
-            snapshot: `
-if (typeof value === "String") {
-                     ~~~~~~~~
-                     This string literal is not one that the typeof operator will ever produce.
-    process();
-}
-`,
-        },
-        {
-            code: `
-const isValid = typeof input !== "array";
-`,
-            snapshot: `
-const isValid = typeof input !== "array";
-                                 ~~~~~~~
-                                 This string literal is not one that the typeof operator will ever produce.
-`,
-        },
-    ],
-    valid: [
-        `if (typeof value === "string") { process(); }`,
-        `if (typeof variable == "undefined") { handle(); }`,
-        `if (typeof data != "number") { reject(); }`,
-        `if (typeof callback !== "function") { throw new Error("Invalid callback"); }`,
-        `if (typeof flag === "boolean") { toggle(); }`,
-        `if (typeof value === "object") { parse(); }`,
-        `if (typeof value === "symbol") { handle(); }`,
-        `if (typeof value === "bigint") { compute(); }`,
-        `if (typeof value === other) { process(); }`,
-        `if (typeof value === typeof other) { compare(); }`,
-        `const type = typeof value;`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/unassignedVariables.test.js

@@ -1,72 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unassignedVariables.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-let value;
-`,
-            snapshot: `
-let value;
-    ~~~~~
-    Variable 'value' is declared but never assigned a value.
-`,
-        },
-        {
-            code: `
-var variable;
-console.log(variable);
-`,
-            snapshot: `
-var variable;
-    ~~~~~~~~
-    Variable 'variable' is declared but never assigned a value.
-console.log(variable);
-`,
-        },
-        {
-            code: `
-let unassigned: number;
-console.log(unassigned);
-`,
-            snapshot: `
-let unassigned: number;
-    ~~~~~~~~~~
-    Variable 'unassigned' is declared but never assigned a value.
-console.log(unassigned);
-`,
-        },
-        {
-            code: `
-function example() {
-    let local;
-    return local;
-}
-`,
-            snapshot: `
-function example() {
-    let local;
-        ~~~~~
-        Variable 'local' is declared but never assigned a value.
-    return local;
-}
-`,
-        },
-    ],
-    valid: [
-        `let assigned = 5;`,
-        `const constant = 10;`,
-        `var variable = "hello";`,
-        `let value: number = 42;`,
-        `let x; x = 5;`,
-        `let y; y = 10; console.log(y);`,
-        `var z; z += 1;`,
-        `let counter; counter++;`,
-        `let value; value--;`,
-        `for (let index = 0; index < 10; index++) {}`,
-        `for (let item; item < 10; item++) {}`,
-        `let result; result ||= "default";`,
-        `let data; data &&= "value";`,
-        `let nullish; nullish ??= "fallback";`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/undefinedVariables.test.js

@@ -1,80 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./undefinedVariables.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-console.log(undefinedVar);
-`,
-            snapshot: `
-console.log(undefinedVar);
-            ~~~~~~~~~~~~
-            Variable 'undefinedVar' is used but was never defined.
-`,
-        },
-        {
-            code: `
-function test() {
-    return notDefined;
-}
-`,
-            snapshot: `
-function test() {
-    return notDefined;
-           ~~~~~~~~~~
-           Variable 'notDefined' is used but was never defined.
-}
-`,
-        },
-        {
-            code: `
-const value = unknownVariable;
-`,
-            snapshot: `
-const value = unknownVariable;
-              ~~~~~~~~~~~~~~~
-              Variable 'unknownVariable' is used but was never defined.
-`,
-        },
-        {
-            code: `
-if (condition) {
-    doSomething();
-}
-`,
-            snapshot: `
-if (condition) {
-    ~~~~~~~~~
-    Variable 'condition' is used but was never defined.
-    doSomething();
-    ~~~~~~~~~~~
-    Variable 'doSomething' is used but was never defined.
-}
-`,
-        },
-        {
-            code: `
-const result = first + second;
-`,
-            snapshot: `
-const result = first + second;
-               ~~~~~
-               Variable 'first' is used but was never defined.
-                       ~~~~~~
-                       Variable 'second' is used but was never defined.
-`,
-        },
-    ],
-    valid: [
-        `const value = 5; console.log(value);`,
-        `function test(parameter: number) { return parameter; }`,
-        `let count = 0; count++;`,
-        `const obj = { prop: 1 }; console.log(obj.prop);`,
-        `typeof undefinedVar === "undefined"`,
-        `const obj = {}; const { prop } = obj;`,
-        `function fn() { return 1; } fn();`,
-        `class MyClass {} const instance = new MyClass();`,
-        `import { value } from "module"; console.log(value);`,
-        `const array = [1, 2, 3]; array.forEach(item => console.log(item));`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/unicodeBOMs.test.js

@@ -1,66 +0,0 @@
-// flint-disable-file invalidCodeLines -- This rule checks the first character of code files.
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unicodeBOMs.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `\uFEFFconst value = 1;
-`,
-            snapshot: `\uFEFFconst value = 1;
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-`,
-            suggestions: [
-                {
-                    id: "removeBOM",
-                    updated: `const value = 1;
-`,
-                },
-            ],
-        },
-        {
-            code: `\uFEFF// Comment
-const value = 1;
-`,
-            snapshot: `\uFEFF// Comment
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-const value = 1;
-`,
-            suggestions: [
-                {
-                    id: "removeBOM",
-                    updated: `// Comment
-const value = 1;
-`,
-                },
-            ],
-        },
-        {
-            code: `\uFEFF
-const value = 1;
-`,
-            snapshot: `\uFEFF
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-const value = 1;
-`,
-            suggestions: [
-                {
-                    id: "removeBOM",
-                    updated: `
-const value = 1;
-`,
-                },
-            ],
-        },
-    ],
-    valid: [
-        `const value = 1;`,
-        `// Comment at the start
-const value = 1;`,
-        `
-const value = 1;`,
-        `function test() { return 42; }`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};

package/lib/rules/unnecessaryBlocks.test.js

@@ -1,147 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unnecessaryBlocks.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-{
-    const x = 1;
-}
-`,
-            snapshot: `
-{
-~
-This standalone block statement is unnecessary and doesn't change any variable scopes.
-    const x = 1;
-}
-`,
-        },
-        {
-            code: `
-function test() {
-    {
-        const y = 2;
-    }
-}
-`,
-            snapshot: `
-function test() {
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        const y = 2;
-    }
-}
-`,
-        },
-        {
-            code: `
-if (condition) {
-    doSomething();
-    {
-        const nested = true;
-    }
-}
-`,
-            snapshot: `
-if (condition) {
-    doSomething();
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        const nested = true;
-    }
-}
-`,
-        },
-        {
-            code: `
-{
-    console.log("standalone");
-}
-`,
-            snapshot: `
-{
-~
-This standalone block statement is unnecessary and doesn't change any variable scopes.
-    console.log("standalone");
-}
-`,
-        },
-        {
-            code: `
-function outer() {
-    {
-        console.log("inner");
-    }
-    {
-        console.log("another");
-    }
-}
-`,
-            snapshot: `
-function outer() {
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        console.log("inner");
-    }
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        console.log("another");
-    }
-}
-`,
-        },
-    ],
-    valid: [
-        `if (condition) { doSomething(); }`,
-        `for (let i = 0; i < 10; i++) { console.log(i); }`,
-        `while (condition) { doWork(); }`,
-        `do { doWork(); } while (condition);`,
-        `function test() { return 42; }`,
-        `const arrow = () => { return 1; };`,
-        `
-switch (value) {
-    case 1: {
-        const x = 1;
-        break;
-    }
-    case 2: {
-        const y = 2;
-        break;
-    }
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    handleError(error);
-}
-`,
-        `
-class MyClass {
-    method() {
-        return 1;
-    }
-}
-`,
-        `
-for (const item of items) {
-    processItem(item);
-}
-`,
-        `
-for (const key in object) {
-    processKey(key);
-}
-`,
-        `
-label: {
-    break label;
-}
-`,
-    ],
-});

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

@@ -1 +0,0 @@
-export {};