are custom (function) types possible?

[samuelstroschein]

Problem

Sometimes custom types (type casts) are easier to work:

// 1. Need to define pattern to enforce camelCase but it's also a template literal string
const T = Type.String({
pattern: "^(?:[a-z0-9]+(?:[A-Z][a-z0-9]+)*)\\.lintRule[A-Z][a-zA-Z0-9]*$",
}) as unknown as TTemplateLiteral<[TLiteral<`${string}.lintRule${string}`>]>,

// 2. Typing functions is complex and validation not required
const T = Type.Object({
  type: Type.Literal("MessageLintRule"),
  defaultLevel: Type.String(),
  message: Type.Function()
})

Question

Are custom (function) types possible?

// 1. Need to define pattern to enforce camelCase but it's also a template literal string
const T = Type.String<`${string}.lintRule${string}`>({
pattern: "^(?:[a-z0-9]+(?:[A-Z][a-z0-9]+)*)\\.lintRule[A-Z][a-zA-Z0-9]*$",
}) 

// 2. Typing functions is complex and validation not required
const T = Type.Object({
  type: Type.Literal("MessageLintRule"),
  defaultLevel: Type.String(),
  message: Type.Function<(args: { path: string } => string) >()
})

[sinclairzx81]

@samuelstroschein Hi,

TypeBox supports Function and Constructor types, but they are not very useful for validation (as JavaScript provides no specification or metadata to check a functions arguments or return types). Rather TypeBox includes them for use in interface definitions (think IDL) for describing callable interface methods (see this project for an example of their usage)

const Add = Type.Function([Type.Number(), Type.Number()], Type.Number()])

type Add = Static<typeof Add> // type Add = (arg0: number, arg1: number) => number

With regards to their construction, it's not possible to construct Functions using TypeScript syntax alone (as TS will erase types on compilation), so the following won't work.

const T = Type.Function<(a: number, b: number) => number>() // types are erased on compile

But you can use Type.Unsafe which will infer as any type you give it...however you will lose the metadata to describe the function (which may be ok depending on your usecase). Information on using Unsafe can be found here

const T = Type.Unsafe<(a: number, b: number) => number>({ ... })

Hope this helps!
S

[samuelstroschein]

To clarify, the use case is not to validate but get TS type inference.

Hence, JSON schema, registering types, etc. is all too complicated to type functions with TS.

[sinclairzx81]

@samuelstroschein

To clarify, the use case is not to validate but get TS type inference.

If you only need type inference, the Unsafe type is all you need. You would only register the Unsafe type if you intend to validate data with it.

const T = Type.Unsafe<{ x: 1, y: 2 }>({}) // only register with [Kind] if you intend to validate.

type T = Static<typeof T> // type T = { x: 1, y: 2 }

[samuelstroschein]

@sinclairzx81

Clarification: The use case is not to validate function props/validate certain props and get TS type inference for all props.

Problem

Registering the unsafe type is a) unexpected (coming form zod) and b) unsuitable because the Unsafe type would leak to external validators which all need to register the unsafe type.

Proposal

Have a type that is ignored for validation to increase the usability of typebox without the need to register types.

• Either introduce a new primitive like Type.Infer() or extend Type.Unsafe() to not require the registration of the unsafe type.

[sinclairzx81]

Would the following work?

const T = Type.Unsafe<{x: 1, y: 2}>(Type.Any()) // a TAny type that infers as { x: 1, y: 2 }

Value.Check(T, 1)                               // true
Value.Check(T, false)                           // true
Value.Check(T, () => true)                      // true

[samuelstroschein]

Works!

Adding it to the docs would likely be a good idea. Many thanks!