Here is an alternative approach:

let output: any[] = [];

The unusual behavior seen in typescript is a result of legacy constraints that developers are forced to work with. Consider the following code snippet:

const result = []

Normally, this would be interpreted as:

const result:any[] = []

However, if both noImplicitAny is set to FALSE, AND strictNullChecks is set to TRUE in your tsconfig file, it is handled like this:

const result:never[] = []

This behavior may seem counterintuitive. Enabling null checks alters the array's entry types? Furthermore, enabling noImplicitAny unexpectedly allows the use of any without any warnings?

It can be perplexing that adding an extra type check (noImplicitAny) leads to more relaxed type validation, particularly when it introduces the very thing you were trying to eradicate.

I encountered a similar issue while working with a React function component and utilizing the useState hook.

To resolve it, I found that specifying the type of useState during initialization using angle brackets was the key:

// For example: specify the type of useState as an array of strings
const [items , setItems] = useState<string[]>([]); 

Encountered a similar error while working with ReactJS stateless function and using the useState hook to set the state of an object array.

const [items , setItems] = useState([]);

The issue arose when trying to update the state in this manner:

 const item = { id : new Date().getTime() , text : 'New Text' };
 setItems([ item , ...items ]);

This resulted in the following error:

Argument of type '{ id: number; text: any }' is not assignable to parameter of type 'never'

However, by initializing the state like this:

const [items , setItems] = useState([{}]);

The error disappeared, but there was an empty item at the 0 index, which was undesirable.

To resolve this issue, I discovered the solution:

const [items , setItems] = useState([] as any);

function addStringToArray(input: string) {
  const newStringsArray: string[] = []
  newStringsArray.push(input)
}

It's important to specify the type of array being used, as declaring result = [] will default to a return type of any[]. It is best practice to avoid using any types in code, as they are typically considered an "Escape hatch" by Microsoft.

The outcome here is an entity that represents an array filled with string values.

I came across a resolution which involved using the following code:

const [files, setFiles] = useState([] as any);

To overcome this hurdle, I found success by utilizing the Array keyword instead of using empty brackets:

const boosters: Array<any> = [];

Implementation:

if (typeof extension === 'function') {
  boosters.push(extension())
}

An issue occurred: The argument of type 'any' cannot be assigned to a parameter of type 'never'.

Check the tsconfig.json file for -

  "noImplicitReturns": false,

   "strictNullChecks":false,

https://i.sstatic.net/hLgbO.png

To resolve this, update the type as 'never'

https://i.sstatic.net/huAF7.png

To fix the compilation errors in your Ng app, either remove or set "strictNullChecks": true to false in the tsconfig.json file. This simple adjustment will result in a successful compilation without any errors.

Disclaimer: Please note that this solution is just a workaround. It is important to handle null checks properly in order to avoid encountering such errors in the first place.

Here's another issue to consider.

If you encounter a typescript error when exporting after using connect()() with your component, it may be due to props.
Solution: Instead of investigating further, I opted to replace the connect function with the useSelector hook
for instance

/* Comp.tsx */
interface IComp {
 a: number
}

const Comp = ({a}:IComp) => <div>{a}</div>

/* ** 

The problem lies in this line, where you export default the return 
value of Connect and there are no specified types for that return
value of connect()(Comp) 

** */

export default connect()(Comp)


--
/* App.tsx */
const App = () => {
/**  This line produces a similar error 
[ts] Argument of type 'number' is not assignable to 
parameter of type 'never' */
 return <Comp a={3} />
}

Encountered an issue while initializing an array in the following manner:

let mainMenu: menuObjectInterface[] | [] = [];

The problematic code snippet is:

let mainMenu: menuObjectInterface[] | [] = [];
dbresult.rows.forEach((m) => {
    if (!mainMenu.find((e) => e.menucode === m.menucode)) {
        // Not found in mainMenu, yet
        mainMenu.push({menucode: m.menucode, menudescription: m.menudescription})  // Here the error
    }
})

An error occurred with message: TS2322: Type 'any' is not assignable to type 'never'

This was due to initializing the array with the possibility of it being empty. Typescript detected a push operation on a type that could potentially be empty, triggering the error.

Resolved the error by modifying the line to:

let mainMenu: menuObjectInterface[] = [];

To store the output in an array of strings, declare a constant named result like this: const result: string[] = [];.

My temporary solution involved performing the following:

let arr = new Array()
arr.push(123)
console.log(arr) // => [123]

If you are working with TypeScript and Vue and encountering issues with data initialization in variables, you can consider using {} as any.

export default defineComponent({
name: "Student",
 data() {
    return {
       studentList: {} as any,
    }
}
......
})

Note: It is generally recommended to avoid using any, so it's better to replace 'any' with your Object model, for example, studentList: {} as StudentModel. You can create a StudentModel Interface like this:

export interface StudentModel {
    studentId: number,
    fullName: string,
    grade: string
}

you can also include as string[]

const bar = (bar: string) => {
  const list = [];
  (list as string[]).push(bar);
}

I used this method when it was part of a larger object

let myObject = {
dataList : [],
secondKey: secondValue
...
}
(dataList as string[]).push('new text')

If you are working with Vue 3 and typescript, you can create a definition like this:

const output = ref<string[]>([]);

const bar = (bar:string)=>{
    output.value.push(bar as string)
}

I encountered a similar issue

Received error: Argument of type 'string' is not assignable to parameter of type 'never'.

This occurred during a jasmine test:

When I tried to spy on the 'toggleUpload' method in the component, an error was thrown due to it not existing.

It took me a while to realize that the component did not actually have a 'toggleUpload' method. 😂

When working with the latest versions of Angular, it is important to explicitly specify the type of variables:

1. If the variable is a string, you should declare it like this:

   public message: string = "";

2. If the variable is a number:

   public n: number = 0;

3. If the variable is an array of strings:

   public tab: string[] = [];

4. If the variable is an array of numbers:

   public tab: number[] = [];

5. If the variable is a mixed array:

   public tab: any[] = []; .......etc (for other types of variables)

6. If you do not specify the type of variable, by default it will be 'never'

Note: It is essential to determine the type of variables that your array will contain and choose the appropriate option (like options 3, 4, 5).

This issue arises when attempting to assign a value to a property within an object before defining the properties of the object itself. To resolve this, designate a type for the object along with its properties, and then specify the type during instantiation. This will allow you to set the property values without encountering any errors.

One day, while working on my project, I encountered an issue with the useRef hook.

I was facing the following error:

const revealRefs = useRef([]);

  const addToRefs = (el) => {
    if (el && !revealRefs.current.includes(el)) {
      revealRefs.current.push(el);
    }
  };

Fortunately, I was able to resolve it and the error disappeared by making the following changes:

const revealRefs = useRef<HTMLElement[]>([]);

  const addToRefs = (el: HTMLElement | null) => {
    if (el && !revealRefs.current.includes(el)) {
      revealRefs.current.push(el);
    }
  };