fix: remove all anys

Author: The-Code-Monkey

packages/components/src/atoms/input/Input.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useState, useContext } from 'react';
+import { useCallback, useState, useContext, ChangeEvent } from 'react';
 import { ThemeContext } from 'styled-components';
 
 import { BoxProps } from '../../primal';
@@ -15,7 +15,7 @@ const Input = ({ onChange, type, value, name, ...rest }: Props) => {
   const [v, setValue] = useState<string | number | undefined | unknown>(value);
 
   const handleOnChange = useCallback(
-    (event: any) => {
+    (event: boolean | ChangeEvent<HTMLInputElement>) => {
       if (typeof event !== 'boolean') {
         setValue(event.target.value);
       } else {

packages/components/src/atoms/input/types.ts

@@ -1,8 +1,10 @@
+import { ChangeEvent } from 'react';
+
 import type { CheckboxProps } from './checkbox';
 
 type DefaultProps = {
   name?: string;
-  onChange?: (e: any) => void;
+  onChange?: (e: boolean | ChangeEvent<HTMLInputElement>) => void;
 };
 
 type TextInputProps = {
@@ -13,4 +15,4 @@ type TextInputProps = {
 
 export type InputPropsUnion =
   | (DefaultProps & TextInputProps)
-  | (Omit<DefaultProps, 'onChange'> & CheckboxProps & { type: 'checkbox' });
+  | (DefaultProps & CheckboxProps & { type: 'checkbox' });

packages/memoize/src/index.ts

@@ -1,7 +1,7 @@
 import areInputsEqual from './are-inputs-equal';
 import type { EqualityFn, MemoizedFn, Cache } from './types';
 
-function index<TFunc extends (this: any, ...newArgs: any[]) => any>(
+function index<TFunc extends (this: unknown, ...newArgs: unknown[]) => unknown>(
   resultFn: TFunc,
   isEqual: EqualityFn<TFunc> = areInputsEqual
 ): MemoizedFn<TFunc> {

packages/memoize/src/types.ts

@@ -1,9 +1,11 @@
-export type EqualityFn<TFunc extends (...args: any[]) => any> = (
+export type EqualityFn<TFunc extends (...args: unknown[]) => unknown> = (
   newArgs: Parameters<TFunc>,
   lastArgs: Parameters<TFunc>
 ) => boolean;
 
-export type MemoizedFn<TFunc extends (this: any, ...args: any[]) => any> = {
+export type MemoizedFn<
+  TFunc extends (this: unknown, ...args: unknown[]) => unknown
+> = {
   clear: () => void;
   (
     this: ThisParameterType<TFunc>,
@@ -12,7 +14,9 @@ export type MemoizedFn<TFunc extends (this: any, ...args: any[]) => any> = {
 };
 
 // internal type
-export type Cache<TFunc extends (this: any, ...args: any[]) => any> = {
+export type Cache<
+  TFunc extends (this: unknown, ...args: unknown[]) => unknown
+> = {
   lastThis: ThisParameterType<TFunc>;
   lastArgs: Parameters<TFunc>;
   lastResult: ReturnType<TFunc>;

packages/memoize/test/memoize-one.spec.ts

@@ -265,7 +265,7 @@ describe('respecting "this" context', () => {
       const Foo = function (this: HasBar, bar: string): void {
         this.bar = bar;
       };
-      const memoized = memoize(function (bar) {
+      const memoized = memoize(function (bar: string) {
         return new Foo(bar);
       });
 

packages/memoize/test/types-test.spec.ts

@@ -6,8 +6,7 @@ import memoize from '../src';
 import type { EqualityFn, MemoizedFn } from '../src';
 
 it('should maintain the types of the original function', () => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  function getLocation(this: Window, value: number) {
+  function getLocation(this: Window) {
     return this.location;
   }
   const memoized = memoize(getLocation);
@@ -47,7 +46,7 @@ it('should return a `MemoizedFn<T>`', () => {
 });
 
 it('should allow you to leverage the MemoizedFn generic to allow many memoized functions', () => {
-  function withDeepEqual<TFunc extends (...args: any[]) => any>(
+  function withDeepEqual<TFunc extends (...args: unknown[]) => unknown>(
     fn: TFunc
   ): MemoizedFn<TFunc> {
     return memoize(fn, isEqual);
@@ -223,49 +222,55 @@ it('should allow weaker equality function types', () => {
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ✅ tuple of 'any'
+  // ✅ tuple of 'unknown'
   {
-    const isEqual = function (first: [any, any], second: [any, any]) {
+    const isEqual = function (
+      first: [unknown, unknown],
+      second: [unknown, unknown]
+    ) {
       return true;
     };
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ❌ tuple of 'any' or incorrect size
+  // ❌ tuple of 'unknown' or incorrect size
   {
-    const isEqual = function (first: [any, any, any], second: [any, any]) {
+    const isEqual = function (
+      first: [unknown, unknown, unknown],
+      second: [unknown, unknown]
+    ) {
       return true;
     };
     expectTypeOf<typeof isEqual>().not.toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ✅ array of 'any'
+  // ✅ array of 'unknown'
   {
-    const isEqual = function (first: any[], second: any[]) {
+    const isEqual = function (first: unknown[], second: unknown[]) {
       return true;
     };
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ✅ two arguments of type any
+  // ✅ two arguments of type unknown
   {
-    const isEqual = function (first: any, second: any) {
+    const isEqual = function (first: unknown, second: unknown) {
       return true;
     };
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ✅ a single argument of type any
+  // ✅ a single argument of type unknown
   {
-    const isEqual = function (first: any) {
+    const isEqual = function (first: unknown) {
       return true;
     };
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();
   }
 
-  // ✅ spread of any type
+  // ✅ spread of unknown type
   {
-    const isEqual = function (...first: any[]) {
+    const isEqual = function (...first: unknown[]) {
       return true;
     };
     expectTypeOf<typeof isEqual>().toMatchTypeOf<EqualityFn<typeof add>>();

packages/react-lazy-named/src/index.spec.tsx

@@ -5,8 +5,12 @@ import lazy from './';
 
 const { Suspense } = React;
 
-function Text(props) {
-  return props.text;
+interface Props {
+  text: string;
+}
+
+function Text(props: Props) {
+  return <>{props.text}</>;
 }
 
 async function fakeImport(result) {

packages/react-lazy-named/src/index.ts

@@ -1,17 +1,4 @@
-/**
- * Improvement on top of React.lazy() that allows lazy rendering of named imports
- * Usage:
- *
- *  -- alternative to import { primary } from './Button'
- *  const PrimaryButton = lazier(() => import('./Button'), 'primary');
- *
- *  -- get the default import
- *  lazier(() => import('./Button'), 'default');
- *
- *  -- or
- *  lazier(() => import('./Button'));
- *
- */
+/* eslint @typescript-eslint/no-explicit-any: 0 */
 import { get } from 'lodash';
 import * as React from 'react';