@flint.fyi/ts 0.15.0 → 0.18.1

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

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

package/lib/rules/functionAssignments.test.js

@@ -1,210 +0,0 @@
-import rule from "./functionAssignments.js";
-import { ruleTester } from "./ruleTester.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-function myFunction() {}
-myFunction = function() {};
-`,
-            snapshot: `
-function myFunction() {}
-myFunction = function() {};
-~~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function myFunction() {}
-myFunction = 123;
-`,
-            snapshot: `
-function myFunction() {}
-myFunction = 123;
-~~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function myFunction() {}
-myFunction += 1;
-`,
-            snapshot: `
-function myFunction() {}
-myFunction += 1;
-~~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function myFunction() {}
-myFunction++;
-`,
-            snapshot: `
-function myFunction() {}
-myFunction++;
-~~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function myFunction() {}
-++myFunction;
-`,
-            snapshot: `
-function myFunction() {}
-++myFunction;
-  ~~~~~~~~~~
-  Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function myFunction() {
-    return 42;
-}
-myFunction = () => 100;
-`,
-            snapshot: `
-function myFunction() {
-    return 42;
-}
-myFunction = () => 100;
-~~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function outer() {
-    function inner() {}
-    inner = function() {};
-}
-`,
-            snapshot: `
-function outer() {
-    function inner() {}
-    inner = function() {};
-    ~~~~~
-    Variables declared with function declarations should not be reassigned.
-}
-`,
-        },
-        {
-            code: `
-function myFunction() {}
-if (condition) {
-    myFunction = null;
-}
-`,
-            snapshot: `
-function myFunction() {}
-if (condition) {
-    myFunction = null;
-    ~~~~~~~~~~
-    Variables declared with function declarations should not be reassigned.
-}
-`,
-        },
-        {
-            code: `
-function getValue() {
-    return 1;
-}
-getValue ??= function() { return 0; };
-`,
-            snapshot: `
-function getValue() {
-    return 1;
-}
-getValue ??= function() { return 0; };
-~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function getValue() {
-    return true;
-}
-getValue &&= false;
-`,
-            snapshot: `
-function getValue() {
-    return true;
-}
-getValue &&= false;
-~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function getValue() {
-    return false;
-}
-getValue ||= () => true;
-`,
-            snapshot: `
-function getValue() {
-    return false;
-}
-getValue ||= () => true;
-~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-        {
-            code: `
-function calculate(value: number): number {
-    return value * 2;
-}
-calculate = (value: number) => value * 3;
-`,
-            snapshot: `
-function calculate(value: number): number {
-    return value * 2;
-}
-calculate = (value: number) => value * 3;
-~~~~~~~~~
-Variables declared with function declarations should not be reassigned.
-`,
-        },
-    ],
-    valid: [
-        `function myFunction() { return 42; }`,
-        `function myFunction() {} const result = myFunction();`,
-        `const myFunction = function() {}; myFunction = () => {};`,
-        `const myFunction = () => {}; myFunction = function() {};`,
-        `let myFunction = function() {}; myFunction = () => {};`,
-        `function outer() { const inner = function() {}; inner = () => {}; }`,
-        `
-function outer() {
-    const myFunction = "shadowed variable";
-    myFunction = "reassigning shadowed variable is ok";
-}
-`,
-        `
-let myFunction = "outer variable";
-function scope() {
-    function myFunction() {}
-    console.log(myFunction);
-}
-myFunction = "reassigning outer is ok";
-`,
-        `function myFunction() {} const copy = myFunction;`,
-        `function myFunction() {} if (condition) { callWith(myFunction); }`,
-        `
-function myFunction() {
-    return function nested() {
-        return 42;
-    };
-}
-`,
-    ],
-});
-//# sourceMappingURL=functionAssignments.test.js.map

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

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

package/lib/rules/functionCurryingRedundancy.test.js

@@ -1,172 +0,0 @@
-import rule from "./functionCurryingRedundancy.js";
-import { ruleTester } from "./ruleTester.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.call(undefined, 1, 2);
-`,
-            output: `
-function add(a, b) {
-    return a + b;
-}
-const result = add(1, 2);
-`,
-            snapshot: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.call(undefined, 1, 2);
-                  ~~~~~~~~~~~~~~~~~~~~~~
-                  This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-        {
-            code: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.call(null, 1, 2);
-`,
-            output: `
-function add(a, b) {
-    return a + b;
-}
-const result = add(1, 2);
-`,
-            snapshot: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.call(null, 1, 2);
-                  ~~~~~~~~~~~~~~~~~
-                  This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-        {
-            code: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.apply(undefined, [1, 2]);
-`,
-            output: `
-function add(a, b) {
-    return a + b;
-}
-const result = add(...[1, 2]);
-`,
-            snapshot: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.apply(undefined, [1, 2]);
-                  ~~~~~~~~~~~~~~~~~~~~~~~~~
-                  This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-        {
-            code: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.apply(null, [1, 2]);
-`,
-            output: `
-function add(a, b) {
-    return a + b;
-}
-const result = add(...[1, 2]);
-`,
-            snapshot: `
-function add(a, b) {
-    return a + b;
-}
-const result = add.apply(null, [1, 2]);
-                  ~~~~~~~~~~~~~~~~~~~~
-                  This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-        {
-            code: `
-const fn = (x: number) => x * 2;
-const value = fn.call(undefined, 5);
-`,
-            output: `
-const fn = (x: number) => x * 2;
-const value = fn(5);
-`,
-            snapshot: `
-const fn = (x: number) => x * 2;
-const value = fn.call(undefined, 5);
-                ~~~~~~~~~~~~~~~~~~~
-                This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-        {
-            code: `
-const callback = function(name: string) {
-    return name.toUpperCase();
-};
-callback.apply(null, ["test"]);
-`,
-            output: `
-const callback = function(name: string) {
-    return name.toUpperCase();
-};
-callback(...["test"]);
-`,
-            snapshot: `
-const callback = function(name: string) {
-    return name.toUpperCase();
-};
-callback.apply(null, ["test"]);
-        ~~~~~~~~~~~~~~~~~~~~~~
-        This "currying" of a function without a defined context does nothing and can be simplified.
-`,
-        },
-    ],
-    valid: [
-        `function add(a, b) { return a + b; } const result = add(1, 2);`,
-        `const obj = { value: 10, getValue: function() { return this.value; } }; obj.getValue();`,
-        `const obj = { value: 10 }; function getValue() { return this.value; } const result = getValue.call(obj);`,
-        `const obj1 = { method: function() { return 42; } }; const obj2 = {}; obj1.method.call(obj2);`,
-        `
-function greet() {
-    return this.name;
-}
-const person = { name: "Alice" };
-const result = greet.call(person);
-`,
-        `
-const obj = {
-    value: 42,
-    getValue: function() {
-        return this.value;
-    }
-};
-const result = obj.getValue.call(obj);
-`,
-        // Test case for the bug: interface with apply/call methods that aren't from Function.prototype
-        `
-interface CustomInterface {
-    apply(...args: unknown[]): void;
-}
-
-declare const customObj: CustomInterface;
-customObj.apply(null, "abc");
-`,
-        `
-interface CustomInterface {
-    call(...args: unknown[]): void;
-}
-
-declare const customObj: CustomInterface;
-customObj.call(null, "abc");
-`,
-    ],
-});
-//# sourceMappingURL=functionCurryingRedundancy.test.js.map

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

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

package/lib/rules/functionNewCalls.test.js

@@ -1,116 +0,0 @@
-import rule from "./functionNewCalls.js";
-import { ruleTester } from "./ruleTester.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-const fn = new Function("a", "b", "return a + b");
-`,
-            snapshot: `
-const fn = new Function("a", "b", "return a + b");
-               ~~~~~~~~
-               Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = Function("a", "return a");
-`,
-            snapshot: `
-const fn = Function("a", "return a");
-           ~~~~~~~~
-           Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = new Function("return 1");
-`,
-            snapshot: `
-const fn = new Function("return 1");
-               ~~~~~~~~
-               Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = Function();
-`,
-            snapshot: `
-const fn = Function();
-           ~~~~~~~~
-           Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = new globalThis.Function("return 1");
-`,
-            snapshot: `
-const fn = new globalThis.Function("return 1");
-               ~~~~~~~~~~~~~~~~~~~
-               Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = globalThis.Function("return 1");
-`,
-            snapshot: `
-const fn = globalThis.Function("return 1");
-           ~~~~~~~~~~~~~~~~~~~
-           Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = new window.Function("return 1");
-`,
-            snapshot: `
-const fn = new window.Function("return 1");
-               ~~~~~~~~~~~~~~~
-               Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const fn = window.Function("return 1");
-`,
-            snapshot: `
-const fn = window.Function("return 1");
-           ~~~~~~~~~~~~~~~
-           Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const result = new Function("a", "b", "return a + b")(1, 2);
-`,
-            snapshot: `
-const result = new Function("a", "b", "return a + b")(1, 2);
-                   ~~~~~~~~
-                   Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-        {
-            code: `
-const CustomFunction = Function;
-const fn = new CustomFunction();
-`,
-            snapshot: `
-const CustomFunction = Function;
-const fn = new CustomFunction();
-               ~~~~~~~~~~~~~~
-               Dynamically creating functions with the Function constructor is insecure and slow.
-`,
-        },
-    ],
-    valid: [
-        `const fn = function(a, b) { return a + b; };`,
-        `const fn = (a, b) => a + b;`,
-        `function add(a, b) { return a + b; }`,
-        `class MyFunction {}`,
-        `const fn = new MyFunction();`,
-    ],
-});
-//# sourceMappingURL=functionNewCalls.test.js.map

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

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

package/lib/rules/generatorFunctionYields.test.js

@@ -1,152 +0,0 @@
-import rule from "./generatorFunctionYields.js";
-import { ruleTester } from "./ruleTester.js";
-ruleTester.describe(rule, {
-    invalid: [
-        {
-            code: `
-function* emptyGenerator() {
-    console.log("No yield here");
-}
-`,
-            snapshot: `
-function* emptyGenerator() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    console.log("No yield here");
-}
-`,
-        },
-        {
-            code: `
-const generator = function* () {
-    return 42;
-};
-`,
-            snapshot: `
-const generator = function* () {
-                          ~
-                          Generator functions must contain at least one yield expression to produce values.
-    return 42;
-};
-`,
-        },
-        {
-            code: `
-class MyClass {
-    *generatorMethod() {
-        this.doSomething();
-    }
-}
-`,
-            snapshot: `
-class MyClass {
-    *generatorMethod() {
-    ~
-    Generator functions must contain at least one yield expression to produce values.
-        this.doSomething();
-    }
-}
-`,
-        },
-        {
-            code: `
-function* generatorWithNestedFunction() {
-    function inner() {
-        yield 42;
-    }
-}
-`,
-            snapshot: `
-function* generatorWithNestedFunction() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    function inner() {
-        yield 42;
-    }
-}
-`,
-        },
-        {
-            code: `
-function* generatorWithNestedGeneratorFunction() {
-    function* inner() {
-        yield 42;
-    }
-}
-`,
-            snapshot: `
-function* generatorWithNestedGeneratorFunction() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    function* inner() {
-        yield 42;
-    }
-}
-`,
-        },
-    ],
-    valid: [
-        `
-function* validGenerator() {
-    yield 1;
-}
-`,
-        `
-function* validGeneratorMultiple() {
-    yield 1;
-    yield 2;
-    yield 3;
-}
-`,
-        `
-const generator = function* () {
-    yield 42;
-};
-`,
-        `
-class MyClass {
-    *generatorMethod() {
-        yield this.value;
-    }
-}
-`,
-        `
-function* conditionalYield(condition: boolean) {
-    if (condition) {
-        yield 1;
-    }
-}
-`,
-        `
-function* yieldInLoop() {
-    for (let i = 0; i < 10; i++) {
-        yield i;
-    }
-}
-`,
-        `
-function* yieldDelegate() {
-    yield* [1, 2, 3];
-}
-`,
-        `
-function regularFunction() {
-    return 42;
-}
-`,
-        `
-const arrow = () => {
-    return 42;
-};
-`,
-        `
-function* generatorWithNestedGenerator() {
-    yield 1;
-    function* inner() {
-        yield 2;
-    }
-}
-`,
-    ],
-});
-//# sourceMappingURL=generatorFunctionYields.test.js.map

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

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