@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/unnecessaryCatches.test.js

@@ -1,210 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unnecessaryCatches.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-try {
-    doSomething();
-} catch (error) {
-    throw error;
-}
-`,
-            output: `
-try {
-    doSomething();
-}
-`,
-            snapshot: `
-try {
-    doSomething();
-} catch (error) {
-  ~~~~~
-  This catch clause is unnecessary, as it only rethrows the exception without modification.
-    throw error;
-}
-`,
-        },
-        {
-            code: `
-async function fetchData() {
-    try {
-        return await fetch("/api/data");
-    } catch (error) {
-        throw error;
-    }
-}
-`,
-            output: `
-async function fetchData() {
-    try {
-        return await fetch("/api/data");
-    }
-}
-`,
-            snapshot: `
-async function fetchData() {
-    try {
-        return await fetch("/api/data");
-    } catch (error) {
-      ~~~~~
-      This catch clause is unnecessary, as it only rethrows the exception without modification.
-        throw error;
-    }
-}
-`,
-        },
-        {
-            code: `
-try {
-    processData();
-} catch (exception) {
-    throw exception;
-}
-`,
-            output: `
-try {
-    processData();
-}
-`,
-            snapshot: `
-try {
-    processData();
-} catch (exception) {
-  ~~~~~
-  This catch clause is unnecessary, as it only rethrows the exception without modification.
-    throw exception;
-}
-`,
-        },
-        {
-            code: `
-function handleRequest() {
-    try {
-        const result = performOperation();
-        return result;
-    } catch (err) {
-        throw err;
-    }
-}
-`,
-            output: `
-function handleRequest() {
-    try {
-        const result = performOperation();
-        return result;
-    }
-}
-`,
-            snapshot: `
-function handleRequest() {
-    try {
-        const result = performOperation();
-        return result;
-    } catch (err) {
-      ~~~~~
-      This catch clause is unnecessary, as it only rethrows the exception without modification.
-        throw err;
-    }
-}
-`,
-        },
-        {
-            code: `
-try {
-    doSomething();
-} catch (error) {
-    throw error;
-} finally {
-    cleanup();
-}
-`,
-            output: `
-try {
-    doSomething();
-} finally {
-    cleanup();
-}
-`,
-            snapshot: `
-try {
-    doSomething();
-} catch (error) {
-  ~~~~~
-  This catch clause is unnecessary, as it only rethrows the exception without modification.
-    throw error;
-} finally {
-    cleanup();
-}
-`,
-        },
-    ],
-    valid: [
-        `try { doSomething(); } catch (error) { console.error(error); throw error; }`,
-        `try { doSomething(); } catch (error) { throw new Error("Failed"); }`,
-        `try { doSomething(); } catch (error) { logError(error); throw error; }`,
-        `try { doSomething(); } catch { throw new Error("Something went wrong"); }`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    console.error("An error occurred:", error);
-    throw error;
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    throw new Error("Operation failed: " + error.message);
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    cleanup();
-    throw error;
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    throw error.originalError;
-}
-`,
-        `
-async function fetchData() {
-    try {
-        return await fetch("/api/data");
-    } catch (error) {
-        await logError(error);
-        throw error;
-    }
-}
-`,
-        `
-try {
-    doSomething();
-} catch ({ message }) {
-    throw message;
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-}
-`,
-        `
-try {
-    doSomething();
-} catch (error) {
-    console.log("error");
-    cleanup();
-    throw error;
-}
-`,
-    ],
-});

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

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

package/lib/rules/unnecessaryConcatenation.test.js

@@ -1,87 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unnecessaryConcatenation.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-const message = "Hello" + "World";
-`,
-            snapshot: `
-const message = "Hello" + "World";
-                        ~
-                        This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const path = 'foo' + 'bar';
-`,
-            snapshot: `
-const path = 'foo' + 'bar';
-                   ~
-                   This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const result = "abc" + "def" + "ghi";
-`,
-            snapshot: `
-const result = "abc" + "def" + "ghi";
-                     ~
-                     This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const text = "first" + "second";
-`,
-            snapshot: `
-const text = "first" + "second";
-                     ~
-                     This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const mixed = 'single' + "double";
-`,
-            snapshot: `
-const mixed = 'single' + "double";
-                       ~
-                       This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const withSpace = "Hello " + "World";
-`,
-            snapshot: `
-const withSpace = "Hello " + "World";
-                           ~
-                           This string concatenation can be streamlined into a single string literal.
-`,
-        },
-        {
-            code: `
-const longString = "This is a very long string that " +
-    "continues on the next line";
-`,
-            snapshot: `
-const longString = "This is a very long string that " +
-                                                      ~
-                                                      This string concatenation can be streamlined into a single string literal.
-    "continues on the next line";
-`,
-        },
-    ],
-    valid: [
-        `const message = "Hello" + variable;`,
-        `const message = variable + "World";`,
-        `const result = variable1 + variable2;`,
-        `const template = \`Hello\${name}World\`;`,
-        `const number = 1 + 2;`,
-        `const mixed = "Hello" + getName() + "World";`,
-        `const value = "prefix" + getValue();`,
-    ],
-});

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

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

package/lib/rules/unsafeNegations.test.js

@@ -1,63 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unsafeNegations.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-!key in object;
-`,
-            snapshot: `
-!key in object;
-~
-This negation applies before the \`in\` operator.
-`,
-        },
-        {
-            code: `
-!object instanceof Constructor;
-`,
-            snapshot: `
-!object instanceof Constructor;
-~
-This negation applies before the \`instanceof\` operator.
-`,
-        },
-        {
-            code: `
-(!key) in object;
-`,
-            snapshot: `
-(!key) in object;
- ~
- This negation applies before the \`in\` operator.
-`,
-        },
-        {
-            code: `
-(!object) instanceof Constructor;
-`,
-            snapshot: `
-(!object) instanceof Constructor;
- ~
- This negation applies before the \`instanceof\` operator.
-`,
-        },
-        {
-            code: `
-const exists = !key in object;
-`,
-            snapshot: `
-const exists = !key in object;
-               ~
-               This negation applies before the \`in\` operator.
-`,
-        },
-    ],
-    valid: [
-        `!(key in object);`,
-        `!(object instanceof Constructor);`,
-        `key in object;`,
-        `object instanceof Constructor;`,
-        `!flag && key in object;`,
-    ],
-});

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

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

package/lib/rules/variableDeletions.test.js

@@ -1,75 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./variableDeletions.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-delete value;
-`,
-            snapshot: `
-delete value;
-~~~~~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-        },
-        {
-            code: `
-let x = 5;
-delete x;
-`,
-            snapshot: `
-let x = 5;
-delete x;
-~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-        },
-        {
-            code: `
-const variable = 10;
-delete variable;
-`,
-            snapshot: `
-const variable = 10;
-delete variable;
-~~~~~~~~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-        },
-        {
-            code: `
-function test(parameter: number) {
-  delete parameter;
-}
-`,
-            snapshot: `
-function test(parameter: number) {
-  delete parameter;
-  ~~~~~~~~~~~~~~~~
-  Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-}
-`,
-        },
-        {
-            code: `
-for (let index = 0; index < 10; index++) {
-  delete index;
-}
-`,
-            snapshot: `
-for (let index = 0; index < 10; index++) {
-  delete index;
-  ~~~~~~~~~~~~
-  Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-}
-`,
-        },
-    ],
-    valid: [
-        `const obj = { prop: 1 }; delete obj.prop;`,
-        `delete obj.property;`,
-        `delete obj["property"];`,
-        `const obj = { nested: { prop: 1 } }; delete obj.nested.prop;`,
-        `const array = [1, 2, 3]; delete array[0];`,
-    ],
-});

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

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

package/lib/rules/voidOperator.test.js

@@ -1,98 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./voidOperator.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-void 0;
-`,
-            snapshot: `
-void 0;
-~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-const value = void 0;
-`,
-            snapshot: `
-const value = void 0;
-              ~~~~~~
-              Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-void someFunction();
-`,
-            snapshot: `
-void someFunction();
-~~~~~~~~~~~~~~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-return void calculate();
-`,
-            snapshot: `
-return void calculate();
-       ~~~~~~~~~~~~~~~~
-       Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-const result = void (a + b);
-`,
-            snapshot: `
-const result = void (a + b);
-               ~~~~~~~~~~~~
-               Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-void expression, anotherExpression;
-`,
-            snapshot: `
-void expression, anotherExpression;
-~~~~~~~~~~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-        {
-            code: `
-function process() {
-	void doSomething();
-}
-`,
-            snapshot: `
-function process() {
-	void doSomething();
-	~~~~~~~~~~~~~~~~~~
-	Prefer an explicit value over using the void operator to produce undefined.
-}
-`,
-        },
-        {
-            code: `
-const callback = () => void action();
-`,
-            snapshot: `
-const callback = () => void action();
-                       ~~~~~~~~~~~~~
-                       Prefer an explicit value over using the void operator to produce undefined.
-`,
-        },
-    ],
-    valid: [
-        `const value = undefined;`,
-        `return undefined;`,
-        `someFunction();`,
-        `const result = doSomething();`,
-        `if (value === undefined) {}`,
-        `function returns() { return; }`,
-    ],
-});

package/lib/utils/declarationIncludesGlobal.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function declarationIncludesGlobal(declaration: ts.Declaration): boolean;

package/lib/utils/declarationIncludesGlobal.js

@@ -1,5 +0,0 @@
-export function declarationIncludesGlobal(declaration) {
-    const sourceFile = declaration.getSourceFile();
-    return (sourceFile.hasNoDefaultLib ||
-        /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName));
-}

package/lib/utils/declarationsIncludeGlobal.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function declarationsIncludeGlobal(declarations: ts.Declaration[]): boolean;

package/lib/utils/declarationsIncludeGlobal.js

@@ -1,4 +0,0 @@
-import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
-export function declarationsIncludeGlobal(declarations) {
-    return declarations.some(declarationIncludesGlobal);
-}

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function getDeclarationsIfGlobal(node: ts.Expression, typeChecker: ts.TypeChecker): ts.Declaration[] | undefined;

package/lib/utils/getDeclarationsIfGlobal.js

@@ -1,7 +0,0 @@
-import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
-export function getDeclarationsIfGlobal(node, typeChecker) {
-    const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
-    return !!declarations && declarationsIncludeGlobal(declarations)
-        ? declarations
-        : undefined;
-}

package/lib/utils/getModifyingReferences.d.ts

@@ -1,8 +0,0 @@
-import * as ts from "typescript";
-/**
- * Gets all references to a variable that modify it (assignments, increments, decrements).
- *
- * TODO: Replace with a proper scope manager when available (see #400).
- * @returns An array of identifier nodes that modify the variable.
- */
-export declare function getModifyingReferences(identifier: ts.Identifier, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): ts.Identifier[];

package/lib/utils/getModifyingReferences.js

@@ -1,42 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-/**
- * Gets all references to a variable that modify it (assignments, increments, decrements).
- *
- * TODO: Replace with a proper scope manager when available (see #400).
- * @returns An array of identifier nodes that modify the variable.
- */
-export function getModifyingReferences(identifier, sourceFile, typeChecker) {
-    const symbol = typeChecker.getSymbolAtLocation(identifier);
-    if (!symbol?.valueDeclaration) {
-        return [];
-    }
-    const valueDeclaration = symbol.valueDeclaration;
-    const modifyingReferences = [];
-    function visit(node) {
-        // Check if this is an identifier that refers to the same symbol
-        if (ts.isIdentifier(node)) {
-            const nodeSymbol = typeChecker.getSymbolAtLocation(node);
-            if (nodeSymbol?.valueDeclaration &&
-                nodeSymbol.valueDeclaration === valueDeclaration) {
-                // Check if this identifier is being modified
-                const parent = node.parent;
-                // Assignment expressions (=, +=, -=, etc.)
-                if (ts.isBinaryExpression(parent) &&
-                    tsutils.isAssignmentKind(parent.operatorToken.kind) &&
-                    parent.left === node) {
-                    modifyingReferences.push(node);
-                }
-                // Unary expressions (++, --)
-                else if ((ts.isPostfixUnaryExpression(parent) ||
-                    ts.isPrefixUnaryExpression(parent)) &&
-                    parent.operand === node) {
-                    modifyingReferences.push(node);
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return modifyingReferences;
-}

package/lib/utils/hasSameTokens.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function hasSameTokens(nodeA: ts.Node, nodeB: ts.Node, sourceFile: ts.SourceFile): boolean;

package/lib/utils/hasSameTokens.js

@@ -1,30 +0,0 @@
-import * as ts from "typescript";
-export function hasSameTokens(nodeA, nodeB, sourceFile) {
-    const queueA = [nodeA];
-    const queueB = [nodeB];
-    while (true) {
-        const currentA = queueA.shift();
-        const currentB = queueB.shift();
-        if (!currentA || !currentB) {
-            break;
-        }
-        if (currentA.kind !== currentB.kind) {
-            return false;
-        }
-        if (currentA.kind >= ts.SyntaxKind.FirstToken &&
-            currentA.kind <= ts.SyntaxKind.LastToken) {
-            if (currentA.getText(sourceFile) !== currentB.getText(sourceFile)) {
-                return false;
-            }
-            continue;
-        }
-        const childrenA = currentA.getChildren(sourceFile);
-        const childrenB = currentB.getChildren(sourceFile);
-        if (childrenA.length !== childrenB.length) {
-            return false;
-        }
-        queueA.push(...childrenA);
-        queueB.push(...childrenB);
-    }
-    return queueA.length === queueB.length;
-}

package/lib/utils/isGlobalDeclaration.d.ts

@@ -1,2 +0,0 @@
-import * as ts from "typescript";
-export declare function isGlobalDeclaration(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;

package/lib/utils/isGlobalDeclaration.js

@@ -1,4 +0,0 @@
-import { getDeclarationsIfGlobal } from "./getDeclarationsIfGlobal.js";
-export function isGlobalDeclaration(node, typeChecker) {
-    return !!getDeclarationsIfGlobal(node, typeChecker);
-}

package/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -1,5 +0,0 @@
-import * as ts from "typescript";
-/**
- * TODO: Use a scope analyzer (#400).
- */
-export declare function isGlobalDeclarationOfName(node: ts.Node, name: string, typeChecker: ts.TypeChecker): boolean;