linting

Author: ziad-saab

src/struct.ts

@@ -170,7 +170,10 @@ export function mask<T, S, C>(
  * Check if a value passes a struct.
  */
 
-export function is<T, S, C>(value: unknown, struct: Struct<T, S, C>): value is T {
+export function is<T, S, C>(
+  value: unknown,
+  struct: Struct<T, S, C>
+): value is T {
   const result = validate(value, struct)
   return !result[0]
 }
@@ -228,8 +231,8 @@ export type Infer<T extends Struct<any, any, any>> = T['TYPE']
  * A type utility to extract the type from a `Struct` class before coercion
  */
 
-export type InferUncoerced<T extends Struct<any, any, any>> = T['UNCOERCED_TYPE']
-
+export type InferUncoerced<T extends Struct<any, any, any>> =
+  T['TYPE'] | T['UNCOERCED_TYPE']
 
 /**
  * A type utility to describe that a struct represents a TypeScript type.

src/structs/coercions.ts

@@ -13,11 +13,11 @@ import { string, unknown } from './types'
  * take effect! Using simply `assert()` or `is()` will not use coercion.
  */
 
-export function coerce<T, S, C, CT>(
-  struct: Struct<T, S, CT>,
+export function coerce<T, S, C>(
+  struct: Struct<T, S>,
   condition: Struct<C, any>,
   coercer: Coercer<C>
-): Struct<T, S, CT> {
+): Struct<T, S, C> {
   return new Struct({
     ...struct,
     coercer: (value, ctx) => {
@@ -35,8 +35,8 @@ export function coerce<T, S, C, CT>(
  * take effect! Using simply `assert()` or `is()` will not use coercion.
  */
 
-export function defaulted<T, S, C>(
-  struct: Struct<T, S, C>,
+export function defaulted<T, S>(
+  struct: Struct<T, S>,
   fallback: any,
   options: {
     strict?: boolean
@@ -76,6 +76,6 @@ export function defaulted<T, S, C>(
  * take effect! Using simply `assert()` or `is()` will not use coercion.
  */
 
-export function trimmed<T, S, C>(struct: Struct<T, S, C>): Struct<T, S, C> {
+export function trimmed<T, S>(struct: Struct<T, S>): Struct<T, S, string> {
   return coerce(struct, string(), (x) => x.trim())
 }

src/structs/types.ts

@@ -29,7 +29,9 @@ export function any(): Struct<any, null> {
  * and it is preferred to using `array(any())`.
  */
 
-export function array<T extends Struct<any>>(Element: T): Struct<Infer<T>[], T, InferUncoerced<T>[]>
+export function array<T extends Struct<any>>(
+  Element: T
+): Struct<Infer<T>[], T, InferUncoerced<T>[]>
 export function array(): Struct<unknown[], undefined>
 export function array<T extends Struct<any>>(Element?: T): any {
   return new Struct({
@@ -172,7 +174,11 @@ export function integer(): Struct<number, null> {
 
 export function intersection<A extends AnyStruct, B extends AnyStruct[]>(
   Structs: [A, ...B]
-): Struct<Infer<A> & UnionToIntersection<InferStructTuple<B>[number]>, null, InferUncoerced<A> & UnionToIntersection<InferStructTupleUncoerced<B>[number]>> {
+): Struct<
+  Infer<A> & UnionToIntersection<InferStructTuple<B>[number]>,
+  null,
+  InferUncoerced<A> & UnionToIntersection<InferStructTupleUncoerced<B>[number]>
+> {
   return new Struct({
     type: 'intersection',
     schema: null,
@@ -264,7 +270,9 @@ export function never(): Struct<never, null> {
  * Augment an existing struct to allow `null` values.
  */
 
-export function nullable<T, S, C>(struct: Struct<T, S, C>): Struct<T | null, S> {
+export function nullable<T, S, C>(
+  struct: Struct<T, S, C>
+): Struct<T | null, S> {
   return new Struct({
     ...struct,
     validator: (value, ctx) => value === null || struct.validator(value, ctx),
@@ -434,7 +442,11 @@ export function string(): Struct<string, null> {
 
 export function tuple<A extends AnyStruct, B extends AnyStruct[]>(
   Structs: [A, ...B]
-): Struct<[Infer<A>, ...InferStructTuple<B>], null, [InferUncoerced<A>, ...InferStructTupleUncoerced<B>]> {
+): Struct<
+  [Infer<A>, ...InferStructTuple<B>],
+  null,
+  [InferUncoerced<A>, ...InferStructTupleUncoerced<B>]
+> {
   const Never = never()
 
   return new Struct({
@@ -496,7 +508,11 @@ export function type<S extends ObjectSchema>(
 
 export function union<A extends AnyStruct, B extends AnyStruct[]>(
   Structs: [A, ...B]
-): Struct<Infer<A> | InferStructTuple<B>[number], null, InferUncoerced<A> | InferStructTupleUncoerced<B>[number]> {
+): Struct<
+  Infer<A> | InferStructTuple<B>[number],
+  null,
+  InferUncoerced<A> | InferStructTupleUncoerced<B>[number]
+> {
   const description = Structs.map((s) => s.type).join(' | ')
   return new Struct({
     type: 'union',

src/structs/utilities.ts

@@ -1,6 +1,12 @@
 import { Struct, Context, Validator } from '../struct'
 import { object, optional, type } from './types'
-import { ObjectSchema, Assign, ObjectType, PartialObjectSchema, ObjectTypeUncoerced } from '../utils'
+import {
+  ObjectSchema,
+  Assign,
+  ObjectType,
+  PartialObjectSchema,
+  ObjectTypeUncoerced,
+} from '../utils'
 
 /**
  * Create a new struct that combines the properties properties from multiple

src/utils.ts

@@ -1,4 +1,11 @@
-import { Struct, Infer, Result, Context, Describe, InferUncoerced } from './struct'
+import {
+  Struct,
+  Infer,
+  Result,
+  Context,
+  Describe,
+  InferUncoerced,
+} from './struct'
 import { Failure } from './error'
 
 /**
@@ -299,7 +306,6 @@ export type ObjectTypeUncoerced<S extends ObjectSchema> = Simplify<
   Optionalize<{ [K in keyof S]: InferUncoerced<S[K]> }>
 >
 
-
 /**
  * Omit properties from a type that extend from a specific type.
  */
@@ -424,26 +430,26 @@ type _InferTuple<
   ? Accumulated
   : _InferTuple<Tuple, Length, [...Accumulated, Infer<Tuple[Index]>]>
 
-  /**
+/**
  * Infer a tuple of types from a tuple of `Struct`s.
  *
  * This is used to recursively retrieve the type from `union` `intersection` and
  * `tuple` structs.
  */
 
 export type InferStructTupleUncoerced<
-Tuple extends AnyStruct[],
-Length extends number = Tuple['length']
+  Tuple extends AnyStruct[],
+  Length extends number = Tuple['length']
 > = Length extends Length
-? number extends Length
-  ? Tuple
-  : _InferTupleUncoerced<Tuple, Length, []>
-: never
+  ? number extends Length
+    ? Tuple
+    : _InferTupleUncoerced<Tuple, Length, []>
+  : never
 type _InferTupleUncoerced<
-Tuple extends AnyStruct[],
-Length extends number,
-Accumulated extends unknown[],
-Index extends number = Accumulated['length']
+  Tuple extends AnyStruct[],
+  Length extends number,
+  Accumulated extends unknown[],
+  Index extends number = Accumulated['length']
 > = Index extends Length
-? Accumulated
-: _InferTuple<Tuple, Length, [...Accumulated, InferUncoerced<Tuple[Index]>]>
+  ? Accumulated
+  : _InferTuple<Tuple, Length, [...Accumulated, InferUncoerced<Tuple[Index]>]>