resolution of Literal Types.Union from const

[ahhmarr]

I've my const such as

const Allowed = ["chips", "banana", "apple"] as const

need to convert it into

Types.Union([
  Type.Literal("chips"),
  Type.Literal("banana"),
  Type.Literal("apple"),
])

is it possible with generic helpers provided by TypeBox ?

[sinclairzx81]

@ahhmarr Hi, you can try something like the following

TypeScript Link Here

import { Type, Static, SchemaOptions } from '@sinclair/typebox'

export function UnionOfString<T extends string[]>(values: readonly [...T], options: SchemaOptions = {}) {
  return Type.Union(values.map(value => Type.Literal(value)), options)
}

const Allowed = ["chips", "banana", "apple"] as const 

const T = UnionOfString(Allowed)

type T = Static<typeof T> // type T = "chips" | "banana" | "apple"

Hope this helps
S

[thes01]

There's one issue with this approach - it doesn't work with StaticDecode as the inferred type is never. I consider this being a bug @sinclairzx81. So far, I have been successful with this:

function TLiterals<const T extends string[]>(...literal_values: T) {
	return literal_values.map((v) => Type.Literal(v)) as {
		[Key in keyof T]: TLiteral<T[Key]>;
	};
}

and then using Type.Union(TLiterals('a', 'b', 'c'))

[sinclairzx81]

@thes01 Hi,

You can try the following revised pattern. This pattern generally recommended for applying .map operations in the type system where the updated type is mapping from string[] to TLiteral[]. The technique is tail safe recursive, with the accumulator (Acc) tending to scale better for larger tuples in the TS type system.

TypeScript Link Here

import { Type, Static, StaticDecode, SchemaOptions, TSchema, TUnion, TLiteral } from '@sinclair/typebox'

// use this pattern to .map() string[] into TLiteral[]
export type TUnionOfString<T extends string[], Acc extends TSchema[] = []> = 
  T extends [infer L extends string, ...infer R extends string[]]
    ? TUnionOfString<R, [...Acc, TLiteral<L>]>
    : Acc

export function UnionOfString<const T extends string[]>(values: [...T], options: SchemaOptions = {}): TUnion<TUnionOfString<T>>  {
  return Type.Union(values.map(value => Type.Literal(value)), options) as never // safe
}

const T = UnionOfString(["chips", "banana", "apple"] )
type S = Static<typeof T>       
type D = StaticDecode<typeof T> // type T = "chips" | "banana" | "apple"

I use this technique internal to TypeBox.

Hope this helps
S

[thes01]

Thank you!