Is there a method to accurately pinpoint the specific type?

Question

Is there a method to accurately pinpoint the specific type?

Is there a way to optimize the validateField function to narrow down the type more effectively?

type TStringValidator = (v: string) => void;
type TNumberValidator = (v: number) => void;

type TFields = 'inn' | 'amount';

interface IValidators {
  inn: TStringValidator[];
  amount: TNumberValidator[];
}

const handleString: TStringValidator = (value: string) => {};
const handleNumber: TNumberValidator = (value: number) => {};

const validators = {
  inn: [handleString],
  amount: [handleNumber],
} satisfies IValidators;

function validateField(field: TFields, value: string | number) {
  const fieldValidators = validators[field];

  for (const validator of fieldValidators) {
    // The issue lies here
    const result = validator(value);
  }

  return;
}

Link to the TS playground.

Expect validator(value) call not to throw TS error:

Argument of type 'string | number' is not assignable to parameter of type 'never'.
  Type 'string' is not assignable to type 'never'.(2345)
(parameter) value: string | number

The TypeScript compiler seems to struggle with inferring the type for the dynamic validator based on the field value. Perhaps some refactoring of the validateField function could help.

typescript

Answer 1

Answer №1

To prevent the never type, you can establish a list of all approved types in the validator

type AllowedTypes = string & number;

then when calling the generic validator function, simply convert the variable to the allowed type

const result = validator(value as AllowedTypes);

here is a complete example

type TStringValidator = (v: string) => void;
type TNumberValidator = (v: number) => void;

type TFields = 'inn' | 'amount';
type AllowedTypes = string & number;

interface IValidators {
  inn: TStringValidator[];
  amount: TNumberValidator[];
}

const handleString: TStringValidator = (value: string) => {};
const handleNumber: TNumberValidator = (value: number) => {};

const validators = {
  inn: [handleString],
  amount: [handleNumber],
}
satisfies IValidators;

function validateField(field: TFields, value: string | number) {
  const fieldValidators: (TNumberValidator | TStringValidator)[] = validators[field];

  for (const validator of fieldValidators) {
    const result = validator(value as AllowedTypes);
  }

  return;

Answer 2

To prevent the never type, you can establish a list of all approved types in the validator

type AllowedTypes = string & number;

then when calling the generic validator function, simply convert the variable to the allowed type

const result = validator(value as AllowedTypes);

here is a complete example

type TStringValidator = (v: string) => void;
type TNumberValidator = (v: number) => void;

type TFields = 'inn' | 'amount';
type AllowedTypes = string & number;

interface IValidators {
  inn: TStringValidator[];
  amount: TNumberValidator[];
}

const handleString: TStringValidator = (value: string) => {};
const handleNumber: TNumberValidator = (value: number) => {};

const validators = {
  inn: [handleString],
  amount: [handleNumber],
}
satisfies IValidators;

function validateField(field: TFields, value: string | number) {
  const fieldValidators: (TNumberValidator | TStringValidator)[] = validators[field];

  for (const validator of fieldValidators) {
    const result = validator(value as AllowedTypes);
  }

  return;

Answer 3

Answer №2

It seems that the issue lies in the uncertain type of your value, whether it is a string or number, and TypeScript is unable to determine the specific type validator being used within the loop (either TStringValidator or TNumberValidator). While the structure may be a tad awkward, you can still address the problem with the following approach:

function validateField(field: TFields, value: string | number) {
  const fieldValidators = validators[field];

  Object.keys(validators).forEach(key => {
    if (key === 'inn' && typeof value === 'string') {
      const result = validators[key][0](value)
    }
  })

  return;
}

There's always room for improvement in the code snippet provided above, but the concept should be clear.

Answer 4

It seems that the issue lies in the uncertain type of your value, whether it is a string or number, and TypeScript is unable to determine the specific type validator being used within the loop (either TStringValidator or TNumberValidator). While the structure may be a tad awkward, you can still address the problem with the following approach:

function validateField(field: TFields, value: string | number) {
  const fieldValidators = validators[field];

  Object.keys(validators).forEach(key => {
    if (key === 'inn' && typeof value === 'string') {
      const result = validators[key][0](value)
    }
  })

  return;
}

There's always room for improvement in the code snippet provided above, but the concept should be clear.

Is there a method to accurately pinpoint the specific type?

Answer №1

Answer №2

Similar questions

Navigating the use of property annotations in Mapped Types with remapped keys

Implementing an All-Routes-Except-One CanActivate guard in Angular2

Creating a dynamic selection in Angular without duplicate values

Prevent accidental misuse of object[index] in Typescript

Parsing JSON objects with identifiers into TypeScript is a common task in web development

Unable to retrieve the third attribute of a Class using Angular2's toString method

Using Angular 8 for Filtering Firebase Data

defining data types based on specific conditions within an object {typescript}

utilizing routerLinks to transfer data and trigger a specific function

Creating a countdown clock in Angular 5

The reason for duplicating the import of an NPM package in TypeScript (specifically for Firebase Functions)

Exploring FileReader in conjunction with React and Typescript

I'm having trouble understanding why I can't access the properties of a class within a function that has been passed to an Angular

What is the best way to include a new property to an existing interface and then export the updated interface in Typescript?

A guide to simulating Custom Dialog in Angular for Unit Testing with Jest

NestJS is having trouble importing generated types from the Prisma client

How do I select all checkboxes in TypeScript when I only click on one of them?

Create a global variable by importing an external module in TypeScript

Different results are being obtained when destructuring props in a component

Ensuring the inclusion of library licenses in the production build is a crucial step