@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/unnecessaryConcatenation.test.js

@@ -1,88 +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();`,
-    ],
-});
-//# sourceMappingURL=unnecessaryConcatenation.test.js.map

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

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

package/lib/rules/unsafeNegations.test.js

@@ -1,64 +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;`,
-    ],
-});
-//# sourceMappingURL=unsafeNegations.test.js.map

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

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

package/lib/rules/variableDeletions.test.js

@@ -1,76 +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];`,
-    ],
-});
-//# sourceMappingURL=variableDeletions.test.js.map

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

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

package/lib/rules/voidOperator.test.js

@@ -1,99 +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; }`,
-    ],
-});
-//# sourceMappingURL=voidOperator.test.js.map

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

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

package/lib/rules/withStatements.test.js

@@ -1,27 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./withStatements.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-with (container.property) {
-  property.value = true;
-}
-`,
-            snapshot: `
-with (container.property) {
-~~~~
-\`with\` statements are deprecated, unreliable, and difficult to reason about.
-  property.value = true;
-}
-`,
-        },
-    ],
-    valid: [
-        `
-let property = container.property;
-property.value = true;
-`,
-    ],
-});
-//# sourceMappingURL=withStatements.test.js.map

package/lib/utils/declarationIncludesGlobal.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function declarationIncludesGlobal(declaration: ts.Declaration): boolean;
-//# sourceMappingURL=declarationIncludesGlobal.d.ts.map

package/lib/utils/declarationIncludesGlobal.js

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

package/lib/utils/declarationsIncludeGlobal.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function declarationsIncludeGlobal(declarations: ts.Declaration[]): boolean;
-//# sourceMappingURL=declarationsIncludeGlobal.d.ts.map

package/lib/utils/declarationsIncludeGlobal.js

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

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function getDeclarationsIfGlobal(node: ts.Expression, typeChecker: ts.TypeChecker): ts.Declaration[] | undefined;
-//# sourceMappingURL=getDeclarationsIfGlobal.d.ts.map

package/lib/utils/getDeclarationsIfGlobal.js

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

package/lib/utils/getModifyingReferences.d.ts

@@ -1,9 +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[];
-//# sourceMappingURL=getModifyingReferences.d.ts.map

package/lib/utils/getModifyingReferences.js

@@ -1,43 +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;
-}
-//# sourceMappingURL=getModifyingReferences.js.map

package/lib/utils/hasSameTokens.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function hasSameTokens(nodeA: ts.Node, nodeB: ts.Node, sourceFile: ts.SourceFile): boolean;
-//# sourceMappingURL=hasSameTokens.d.ts.map

package/lib/utils/hasSameTokens.js

@@ -1,31 +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;
-}
-//# sourceMappingURL=hasSameTokens.js.map

package/lib/utils/isFunction.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function isFunction(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;
-//# sourceMappingURL=isFunction.d.ts.map

package/lib/utils/isFunction.js

@@ -1,6 +0,0 @@
-export function isFunction(node, typeChecker) {
-    const objectType = typeChecker.getTypeAtLocation(node);
-    const callSignatures = objectType.getCallSignatures();
-    return !!callSignatures.length;
-}
-//# sourceMappingURL=isFunction.js.map

package/lib/utils/isGlobalDeclaration.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function isGlobalDeclaration(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;
-//# sourceMappingURL=isGlobalDeclaration.d.ts.map

package/lib/utils/isGlobalDeclaration.js

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

package/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -1,6 +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;
-//# sourceMappingURL=isGlobalDeclarationOfName.d.ts.map

package/lib/utils/isGlobalDeclarationOfName.js

@@ -1,36 +0,0 @@
-import * as ts from "typescript";
-import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
-/**
- * TODO: Use a scope analyzer (#400).
- */
-export function isGlobalDeclarationOfName(node, name, typeChecker) {
-    const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
-    if (!declarations) {
-        return false;
-    }
-    return declarations.every((declaration) => {
-        // Special case: a variable set to a known identifier. E.g.:
-        // const CustomFunction = Function;
-        if (ts.isVariableDeclaration(declaration) &&
-            declaration.initializer &&
-            declaration.initializer.kind === ts.SyntaxKind.Identifier) {
-            return isGlobalDeclarationOfName(declaration.initializer, name, typeChecker);
-        }
-        // Special case: a property of an interface
-        if (ts.isPropertySignature(declaration)) {
-            return isGlobalDeclarationOfName(declaration.parent, name, typeChecker);
-        }
-        return (isDeclarationOfName(declaration, name) &&
-            declarationIncludesGlobal(declaration));
-    });
-}
-function isDeclarationOfName(node, name) {
-    if (ts.isClassDeclaration(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isInterfaceDeclaration(node) ||
-        ts.isVariableDeclaration(node)) {
-        return node.name && ts.isIdentifier(node.name) && node.name.text === name;
-    }
-    return false;
-}
-//# sourceMappingURL=isGlobalDeclarationOfName.js.map

package/lib/utils/isGlobalVariable.d.ts

@@ -1,9 +0,0 @@
-import * as ts from "typescript";
-/**
- * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
- * Global variables are those declared in TypeScript's lib files or are global identifiers
- * like undefined which have symbols but no user-defined declarations.
- * TODO: Use a scope manager (#400).
- */
-export declare function isGlobalVariable(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;
-//# sourceMappingURL=isGlobalVariable.d.ts.map

package/lib/utils/isGlobalVariable.js

@@ -1,22 +0,0 @@
-import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
-/**
- * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
- * Global variables are those declared in TypeScript's lib files or are global identifiers
- * like undefined which have symbols but no user-defined declarations.
- * TODO: Use a scope manager (#400).
- */
-export function isGlobalVariable(node, typeChecker) {
-    const symbol = typeChecker.getSymbolAtLocation(node);
-    if (!symbol) {
-        return false;
-    }
-    const declarations = symbol.getDeclarations();
-    // undefined, NaN, Infinity etc. may have no declarations in some contexts
-    // but are still global identifiers. Check if they're global scope symbols.
-    if (!declarations?.length) {
-        // If there are no declarations, it's likely a built-in global like undefined
-        return true;
-    }
-    return declarationsIncludeGlobal(declarations);
-}
-//# sourceMappingURL=isGlobalVariable.js.map

package/lib/utils/unwrapParentParenthesizedExpressions.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function unwrapParenthesizedExpressionsParent(node: ts.Node): ts.Node;
-//# sourceMappingURL=unwrapParentParenthesizedExpressions.d.ts.map

package/lib/utils/unwrapParentParenthesizedExpressions.js

@@ -1,7 +0,0 @@
-import * as ts from "typescript";
-export function unwrapParenthesizedExpressionsParent(node) {
-    return ts.isParenthesizedExpression(node.parent)
-        ? unwrapParenthesizedExpressionsParent(node.parent)
-        : node.parent;
-}
-//# sourceMappingURL=unwrapParentParenthesizedExpressions.js.map

package/lib/utils/unwrapParenthesizedExpression.d.ts

@@ -1,3 +0,0 @@
-import * as ts from "typescript";
-export declare function unwrapParenthesizedExpression(expression: ts.Expression): ts.Expression;
-//# sourceMappingURL=unwrapParenthesizedExpression.d.ts.map

package/lib/utils/unwrapParenthesizedExpression.js

@@ -1,7 +0,0 @@
-import * as ts from "typescript";
-export function unwrapParenthesizedExpression(expression) {
-    return ts.isParenthesizedExpression(expression)
-        ? unwrapParenthesizedExpression(expression.expression)
-        : expression;
-}
-//# sourceMappingURL=unwrapParenthesizedExpression.js.map