`CastArray` type

[Laurens256]

Type description + examples

CastArray is the return type of this util function:

const castArray = <T>(value: T | T[]): T[] => {
  return Array.isArray(value) ? value : [value];
};

import type { CastArray } from 'type-fest';

type Foo = string;
type FooArr = string[];

type CastFoo = CastArray<Foo>; // -> string[];
type CastFooArr = CastArray<FooArr>; // -> string[]

Type source

Could be something like this. Not completely sure if this covers all edge cases someone might want to use this for. For example if you want the return type [T] instead of T[]

type CastArray<T> = T extends any[] ? T : T[];

Search existing types and issues first

• I tried my best to look for it

[sindresorhus]

CastArray is already covered by Arrayable.

[Laurens256]

They are not the same because Arrayable returns T | T[] instead of T[]. See this example

type Foo = string;

type CastFoo = Arrayable<Foo>;

// type is string[] | string instead of string[]
const foo: CastFoo = ''; // this should not be valid
const fooArr: CastFoo = []; // this should be valid (it is)

To be fair, the CastArray type is a bit more niche and easy to write yourself so I could see the motivation of not adding it to the library

[som-sm]

They are not the same because Arrayable returns T | T[] instead of T[].

@Laurens256 Yeah, it is different than Arrayable, but I am not sure if this is useful enough. In your castArray example, is this how you're planning to use the CastType type?

type CastArray<T> = T extends any[] ? T : T[];

const castArray = <T,>(value: T) => {
  return (Array.isArray(value) ? value : [value]) as CastArray<T>;
};

const t1 = castArray("foo"); //=> string[]
const t2 = castArray(["foo", "bar"] as const); //=> (readonly ["foo", "bar"])[]

Do you have any other use cases?

[Laurens256]

the specific use case I used this for was a function which accepts a generic argument to type a function's parameters:

const createQueryOptions = <
  Fn extends (...args: any[]) => Promise<unknown>, 
  Args = Parameters<Fn>
>(
  baseKey: readonly string[],
  cb: (...args: CastArray<Args>) => QueryOptions
) => {
  // ...
};

For the args spread to work args needs to be an array. Admittedly, this could be solved by using Args extends any[], this CastArray is purely a helper out of laziness so I can call this function like so:

createQueryOptions<Fn, { id: number }>(...)

Instead of like so (notice array brackets around id type):

createQueryOptions<Fn, [{ id: number }]>(...)

I know this is a super specific (lazy) example so feel free to close this issue if you think this helper does not fit in the library. Thanks for the nice utility types anyway!

[Laurens256]

I'll close this as I can't really think of another use case where this type would be useful