248968596

Build Type

github

Committed by GitHub

Commit Message

Merge e8c23a402 into 64a93ecf1

Pull Request Pull Request #17: feat: ParsedValue type

Run Details

401 of 429 branches covered (93.47%)

Branch coverage included in aggregate %.

320 of 338 new or added lines in 25 files covered. (94.67%)

1 existing line in 1 file now uncovered.

616 of 634 relevant lines covered (97.16%)

1471.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.57

/src/runtype.ts

import { Result, Union, Intersect, Constraint, ConstraintCheck, Brand, Failure } from './index';
import show from './show';
import { ValidationError } from './errors';
import { ParsedValue, ParsedValueConfig } from './types/ParsedValue';

export type InnerValidateHelper = <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>;
declare const internalSymbol: unique symbol;
const internal: typeof internalSymbol = ('__internal__' as unknown) as typeof internalSymbol;

export type ResultWithCycle<T> = (Result<T> & { cycle?: false }) | Cycle<T>;
export interface InternalValidation<TParsed> {
  validate(
    x: any,
    innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>,
    innerValidateToPlaceholder: <T>(runtype: RuntypeBase<T>, value: unknown) => ResultWithCycle<T>,
  ): ResultWithCycle<TParsed>;
  test?: (
    x: any,
    innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Failure | undefined,
  ) => Failure | undefined;
  serialize?: (
    x: any,
    innerSerialize: (runtype: RuntypeBase, value: unknown) => Result<any>,
    innerSerializeToPlaceholder: (runtype: RuntypeBase, value: unknown) => ResultWithCycle<any>,
  ) => ResultWithCycle<any>;
}
/**
 * A runtype determines at runtime whether a value conforms to a type specification.
 */
export interface RuntypeBase<A = unknown> {
  readonly tag: string;

  show?: (ctx: {
    needsParens: boolean;
    parenthesize: (str: string) => string;
    showChild: (rt: RuntypeBase, needsParens: boolean) => string;
  }) => string;

  [internal]: InternalValidation<A>;
}

/**
 * A runtype determines at runtime whether a value conforms to a type specification.
 */
export interface Runtype<TParsed> extends RuntypeBase<TParsed> {
  /**
   * Verifies that a value conforms to this runtype. When given a value that does
   * not conform to the runtype, throws an exception.
   */
  assert(x: any): asserts x is TParsed;

  /**
   * A type guard for this runtype.
   */
  test(x: any): x is TParsed;

  /**
   * @deprecated use Runtype.test
   */
  guard(x: any): x is TParsed;

  /**
   * Verifies that a value conforms to this runtype. If so, returns the same value,
   * statically typed. Otherwise throws an exception.
   */
  parse(x: any): TParsed;

  /**
   * @deprecated use Runtype.parse
   */
  check(x: any): TParsed;

  /**
   * Validates that a value conforms to this type, and returns a result indicating
   * success or failure (does not throw).
   */
  safeParse(x: any): Result<TParsed>;

  /**
   * @deprecated use Runtype.safeParse
   */
  validate(x: any): Result<TParsed>;

  /**
   * Union this Runtype with another.
   */
  Or<B extends RuntypeBase>(B: B): Union<[this, B]>;

  /**
   * Intersect this Runtype with another.
   */
  And<B extends RuntypeBase>(B: B): Intersect<[this, B]>;

  /**
   * Use an arbitrary constraint function to validate a runtype, and optionally
   * to change its name and/or its static type.
   *
   * @template T - Optionally override the static type of the resulting runtype
   * @param {(x: Static<this>) => boolean | string} constraint - Custom function
   * that returns `true` if the constraint is satisfied, `false` or a custom
   * error message if not.
   * @param [options]
   * @param {string} [options.name] - allows setting the name of this
   * constrained runtype, which is helpful in reflection or diagnostic
   * use-cases.
   */
  withConstraint<T extends Static<this>, K = unknown>(
    constraint: ConstraintCheck<this>,
    options?: { name?: string; args?: K },
  ): Constraint<this, T, K>;

  /**
   * Helper function to convert an underlying Runtype into another static type
   * via a type guard function.  The static type of the runtype is inferred from
   * the type of the test function.
   *
   * @template T - Typically inferred from the return type of the type guard
   * function, so usually not needed to specify manually.
   * @param {(x: Static<this>) => x is T} test - Type test function (see
   * https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards)
   *
   * @param [options]
   * @param {string} [options.name] - allows setting the name of this
   * constrained runtype, which is helpful in reflection or diagnostic
   * use-cases.
   */
  withGuard<T extends Static<this>, K = unknown>(
    test: (x: Static<this>) => x is T,
    options?: { name?: string; args?: K },
  ): Constraint<this, T, K>;

  /**
   * Adds a brand to the type.
   */
  withBrand<B extends string>(brand: B): Brand<B, this>;

  /**
   * Apply conversion functions when parsing/serializing this value
   */
  withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): ParsedValue<this, TParsed>;
}

export interface Codec<TParsed, TSerialized = TParsed> extends Runtype<TParsed> {
  serialize: (x: TParsed) => TSerialized;
  safeSerialize: (x: TParsed) => Result<TSerialized>;
}
/**
 * Obtains the static type associated with a Runtype.
 */
export type Static<A extends RuntypeBase<any>> = A extends RuntypeBase<infer T> ? T : unknown;

export function create<TConfig extends Codec<any, any>>(
  internalImplementation:
    | InternalValidation<Static<TConfig>>
    | InternalValidation<Static<TConfig>>['validate'],
  config: Omit<
    TConfig,
    | 'assert'
    | 'check'
    | 'test'
    | 'guard'
    | 'parse'
    | 'check'
    | 'safeParse'
    | 'validate'
    | 'serialize'
    | 'safeSerialize'
    | 'Or'
    | 'And'
    | 'withConstraint'
    | 'withGuard'
    | 'withBrand'
    | 'withParser'
    | typeof internal
  >,
): TConfig {
  const A: Codec<Static<TConfig>> = {
    ...config,
    assert,
    parse,
    check: parse,
    safeParse,
    validate: safeParse,
    test,
    guard: test,
    serialize,
    safeSerialize,
    Or,
    And,
    withConstraint,
    withGuard,
    withBrand,
    withParser,
    toString: () => `Runtype<${show(A)}>`,
    [internal]:
      typeof internalImplementation === 'function'
        ? {
            validate: internalImplementation,
          }
        : internalImplementation,
  };

  return (A as unknown) as TConfig;

  function safeParse(x: any) {
    return innerValidate(A, x, createVisitedState());
  }
  function safeSerialize(x: any) {
    return innerSerialize(A, x, createVisitedState());
  }
  function parse(x: any) {
    const validated = safeParse(x);
    if (!validated.success) {
      throw new ValidationError(validated.message, validated.key);
    }
    return validated.value;
  }
  function serialize(x: any) {
    const validated = safeSerialize(x);
    if (!validated.success) {
      throw new ValidationError(validated.message, validated.key);
    }
    return validated.value;
  }

  function assert(x: any): asserts x is Static<TConfig> {
    const validated = innerGuard(A, x, createGuardVisitedState());
    if (validated) {
      throw new ValidationError(validated.message, validated.key);
    }
  }
  function test(x: any): x is Static<TConfig> {
    const validated = innerGuard(A, x, createGuardVisitedState());
    return validated === undefined;
  }

  function Or<B extends RuntypeBase>(B: B): Union<[Codec<Static<TConfig>>, B]> {
    return Union(A, B);
  }

  function And<B extends RuntypeBase>(B: B): Intersect<[Codec<Static<TConfig>>, B]> {
    return Intersect(A, B);
  }

  function withConstraint<T extends Static<TConfig>, K = unknown>(
    constraint: ConstraintCheck<Codec<Static<TConfig>>>,
    options?: { name?: string; args?: K },
  ): Constraint<Codec<Static<TConfig>>, T, K> {
    return Constraint<Codec<Static<TConfig>>, T, K>(A, constraint, options);
  }

  function withGuard<T extends Static<TConfig>, K = unknown>(
    test: (x: Static<TConfig>) => x is T,
    options?: { name?: string; args?: K },
  ): Constraint<Codec<Static<TConfig>>, T, K> {
    return Constraint<Codec<Static<TConfig>>, T, K>(A, test, options);
  }

  function withBrand<B extends string>(B: B): Brand<B, Codec<Static<TConfig>>> {
    return Brand<B, Codec<Static<TConfig>>>(B, A);
  }

  function withParser<TParsed>(
    config: ParsedValueConfig<Codec<Static<TConfig>>, TParsed>,
  ): ParsedValue<Codec<Static<TConfig>>, TParsed> {
    return ParsedValue(A as any, config);
  }
}

export type Cycle<T> = {
  success: true;
  cycle: true;
  placeholder: Partial<T>;
  populate: () => Result<T>;
  unwrap: () => Result<T>;
};

function attemptMixin<T>(placehoder: any, value: T): Result<T> {
  if (placehoder === value) {
    return { success: true, value };
  }
  if (Array.isArray(placehoder) && Array.isArray(value)) {
    placehoder.splice(0, placehoder.length, ...value);
    return { success: true, value: placehoder as any };
  }
  if (
    placehoder &&
    typeof placehoder === 'object' &&
    !Array.isArray(placehoder) &&
    value &&
    typeof value === 'object' &&
    !Array.isArray(value)
  ) {
    Object.assign(placehoder, value);
    return { success: true, value: placehoder };
  }
  return {
    success: false,
    message: `Cannot convert a value of type "${
      Array.isArray(placehoder) ? 'Array' : typeof placehoder
    }" into a value of type "${
      value === null ? 'null' : Array.isArray(value) ? 'Array' : typeof value
    }" when it contains cycles.`,
  };
}

export function createValidationPlaceholder<T>(
  placeholder: T,
  fn: (placehoder: T) => Result<T> | undefined,
): Cycle<T> {
  let unwrapped = false;
  let populating = false;
  let cache: Result<T> | undefined;
  const populateUncached = (): Result<T> => {
    const result = fn(placeholder);
    if (result) {
      if (!result.success) {
        return result;
      }
      if (unwrapped) {
        return attemptMixin(placeholder, result.value);
      } else {
        cycle.placeholder = result.value;
        return result;
      }
    }
    return { success: true, value: placeholder };
  };
  const cycle: Cycle<T> = {
    success: true,
    cycle: true,
    placeholder,
    populate: () => {
      if (cache) return cache;
      if (populating) {
        return {
          success: false,
          message: 'Cyclic data structure could not be handled by this set of parsers.',
        };
      }
      populating = true;
      const result = populateUncached();
      cache = result;
      return result;
    },
    unwrap: () => {
      if (cache) return cache;
      if (populating) {
        unwrapped = true;
        return {
          success: true,
          value: cycle.placeholder as T,
        };
      }
      populating = true;
      const result = populateUncached();
      cache = result;
      return result;
    },
  };
  return cycle;
}

export function mapValidationPlaceholder<T, S>(
  source: ResultWithCycle<T>,
  fn: (placehoder: T) => Result<S>,
  extraGuard?: RuntypeBase<S>,
): ResultWithCycle<S> {
  if (!source.success) return source;
  if (!source.cycle) return fn(source.value);
  const sourceCycle = source;
  const placeholder: Partial<S> = (Array.isArray(sourceCycle.placeholder)
    ? [...sourceCycle.placeholder]
    : { ...sourceCycle.placeholder }) as any;

  let unwrapped = false;
  let populating = false;
  let cache: Result<S> | undefined;
  const populateUncached = (): Result<S> => {
    const sourceResult = sourceCycle.populate();
    if (!sourceResult.success) return sourceResult;
    const result = fn(sourceResult.value);
    if (!result.success) {
      return result;
    }
    if (unwrapped) {
      const unwrapResult = attemptMixin(placeholder, result.value);
      const guardFailure =
        unwrapResult.success &&
        extraGuard &&
        innerGuard(extraGuard, unwrapResult.value, createGuardVisitedState());
      return guardFailure || unwrapResult;
    } else {
      const guardFailure =
        extraGuard && innerGuard(extraGuard, result.value, createGuardVisitedState());
      cycle.placeholder = result.value;
      return guardFailure || result;
    }
  };
  const cycle: Cycle<S> = {
    success: true,
    cycle: true,
    placeholder,
    populate: () => {
      if (cache) return cache;
      if (populating) {
        return {
          success: false,
          message: 'Cyclic data structure could not be handled by this set of parsers.',
        };
      }
      populating = true;
      const result = populateUncached();
      cache = result;
      if (result.success) {
        cycle.placeholder = result.value;
      }
      return result;
    },
    unwrap: () => {
      if (cache) return cache;
      if (populating) {
        unwrapped = true;
        return {
          success: true,
          value: placeholder as S,
        };
      }
      populating = true;
      const result = populateUncached();
      cache = result;
      if (result.success) {
        cycle.placeholder = result.value;
      }
      return result;
    },
  };
  return cycle;
}

declare const OpaqueVisitedState: unique symbol;
export type OpaqueVisitedState = typeof OpaqueVisitedState;
type VisitedState = Map<RuntypeBase<unknown>, Map<any, Cycle<any>>>;

function unwrapVisitedState(o: OpaqueVisitedState): VisitedState {
  return o as any;
}
function wrapVisitedState(o: VisitedState): OpaqueVisitedState {
  return o as any;
}

export function createVisitedState(): OpaqueVisitedState {
  return wrapVisitedState(new Map());
}

declare const OpaqueGuardVisitedState: unique symbol;
export type OpaqueGuardVisitedState = typeof OpaqueGuardVisitedState;
type GuardVisitedState = Map<RuntypeBase<unknown>, Set<any>>;

function unwrapGuardVisitedState(o: OpaqueGuardVisitedState): GuardVisitedState {
  return o as any;
}
function wrapGuardVisitedState(o: GuardVisitedState): OpaqueGuardVisitedState {
  return o as any;
}

export function createGuardVisitedState(): OpaqueGuardVisitedState {
  return wrapGuardVisitedState(new Map());
}

export function innerValidate<T>(
  targetType: RuntypeBase<T>,
  value: any,
  $visited: OpaqueVisitedState,
): Result<T> {
  const result = innerValidateToPlaceholder(targetType, value, $visited);
  if (result.cycle) {
    return result.unwrap();
  }
  return result;
}

function innerValidateToPlaceholder<T>(
  targetType: RuntypeBase<T>,
  value: any,
  $visited: OpaqueVisitedState,
): ResultWithCycle<T> {
  const visited = unwrapVisitedState($visited);
  const validator = targetType[internal];
  const cached = visited.get(targetType)?.get(value);
  if (cached !== undefined) {
    return cached;
  }
  const result = validator.validate(
    value,
    (t, v) => innerValidate(t, v, $visited),
    (t, v) => innerValidateToPlaceholder(t, v, $visited),
  );
  if (result.cycle) {
    visited.set(targetType, (visited.get(targetType) || new Map()).set(value, result));
    return result;
  }
  return result;
}

export function innerSerialize<T>(
  targetType: RuntypeBase<T>,
  value: any,
  $visited: OpaqueVisitedState,
): Result<T> {
  const result = innerSerializeToPlaceholder(targetType, value, $visited);
  if (result.cycle) {
    return result.unwrap();
  }
  return result;
}
function innerSerializeToPlaceholder(
  targetType: RuntypeBase,
  value: any,
  $visited: OpaqueVisitedState,
): ResultWithCycle<any> {
  const visited = unwrapVisitedState($visited);
  const validator = targetType[internal];
  const cached = visited.get(targetType)?.get(value);
  if (cached !== undefined) {
    return cached;
  }
  let result = (validator.serialize || validator.validate)(
    value,
    (t, v) => innerSerialize(t, v, $visited),
    (t, v) => innerSerializeToPlaceholder(t, v, $visited),
  );
  if (result.cycle) {
    visited.set(targetType, (visited.get(targetType) || new Map()).set(value, result));
    return result;
  }
  return result;
}

export function innerGuard(
  targetType: RuntypeBase,
  value: any,
  $visited: OpaqueGuardVisitedState,
): Failure | undefined {
  const visited = unwrapGuardVisitedState($visited);
  const validator = targetType[internal];
  if (value && (typeof value === 'object' || typeof value === 'function')) {
    const cached = visited.get(targetType)?.has(value);
    if (cached) return undefined;
    visited.set(targetType, (visited.get(targetType) || new Set()).add(value));
  }
  if (validator.test) {
    return validator.test(value, (t, v) => innerGuard(t, v, $visited));
  }
  let result = validator.validate(
    value,
    (t, v) => innerGuard(t, v, $visited) || { success: true, value: v as any },
    (t, v) => innerGuard(t, v, $visited) || { success: true, value: v as any },
  );
  if (result.cycle) result = result.populate();
  if (result.success) return undefined;
  else return result;
}

1	import { Result, Union, Intersect, Constraint, ConstraintCheck, Brand, Failure } from './index';	60✔
2	import show from './show';	60✔
3	import { ValidationError } from './errors';	60✔
4	import { ParsedValue, ParsedValueConfig } from './types/ParsedValue';	60✔
5
6	export type InnerValidateHelper = <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>;
7	declare const internalSymbol: unique symbol;
8	const internal: typeof internalSymbol = ('__internal__' as unknown) as typeof internalSymbol;	60✔
9
10	export type ResultWithCycle<T> = (Result<T> & { cycle?: false }) \| Cycle<T>;
11	export interface InternalValidation<TParsed> {
12	validate(
13	x: any,
14	innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>,
15	innerValidateToPlaceholder: <T>(runtype: RuntypeBase<T>, value: unknown) => ResultWithCycle<T>,
16	): ResultWithCycle<TParsed>;
17	test?: (
18	x: any,
19	innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Failure \| undefined,
20	) => Failure \| undefined;
21	serialize?: (
22	x: any,
23	innerSerialize: (runtype: RuntypeBase, value: unknown) => Result<any>,
24	innerSerializeToPlaceholder: (runtype: RuntypeBase, value: unknown) => ResultWithCycle<any>,
25	) => ResultWithCycle<any>;
26	}
27	/**
28	* A runtype determines at runtime whether a value conforms to a type specification.
29	*/
30	export interface RuntypeBase<A = unknown> {
31	readonly tag: string;
32
33	show?: (ctx: {
34	needsParens: boolean;
35	parenthesize: (str: string) => string;
36	showChild: (rt: RuntypeBase, needsParens: boolean) => string;
37	}) => string;
38
39	[internal]: InternalValidation<A>;
40	}
41
42	/**
43	* A runtype determines at runtime whether a value conforms to a type specification.
44	*/
45	export interface Runtype<TParsed> extends RuntypeBase<TParsed> {
46	/**
47	* Verifies that a value conforms to this runtype. When given a value that does
48	* not conform to the runtype, throws an exception.
49	*/
50	assert(x: any): asserts x is TParsed;
51
52	/**
53	* A type guard for this runtype.
54	*/
55	test(x: any): x is TParsed;
56
57	/**
58	* @deprecated use Runtype.test
59	*/
60	guard(x: any): x is TParsed;
61
62	/**
63	* Verifies that a value conforms to this runtype. If so, returns the same value,
64	* statically typed. Otherwise throws an exception.
65	*/
66	parse(x: any): TParsed;
67
68	/**
69	* @deprecated use Runtype.parse
70	*/
71	check(x: any): TParsed;
72
73	/**
74	* Validates that a value conforms to this type, and returns a result indicating
75	* success or failure (does not throw).
76	*/
77	safeParse(x: any): Result<TParsed>;
78
79	/**
80	* @deprecated use Runtype.safeParse
81	*/
82	validate(x: any): Result<TParsed>;
83
84	/**
85	* Union this Runtype with another.
86	*/
87	Or<B extends RuntypeBase>(B: B): Union<[this, B]>;
88
89	/**
90	* Intersect this Runtype with another.
91	*/
92	And<B extends RuntypeBase>(B: B): Intersect<[this, B]>;
93
94	/**
95	* Use an arbitrary constraint function to validate a runtype, and optionally
96	* to change its name and/or its static type.
97	*
98	* @template T - Optionally override the static type of the resulting runtype
99	* @param {(x: Static<this>) => boolean \| string} constraint - Custom function
100	* that returns `true` if the constraint is satisfied, `false` or a custom
101	* error message if not.
102	* @param [options]
103	* @param {string} [options.name] - allows setting the name of this
104	* constrained runtype, which is helpful in reflection or diagnostic
105	* use-cases.
106	*/
107	withConstraint<T extends Static<this>, K = unknown>(
108	constraint: ConstraintCheck<this>,
109	options?: { name?: string; args?: K },
110	): Constraint<this, T, K>;
111
112	/**
113	* Helper function to convert an underlying Runtype into another static type
114	* via a type guard function. The static type of the runtype is inferred from
115	* the type of the test function.
116	*
117	* @template T - Typically inferred from the return type of the type guard
118	* function, so usually not needed to specify manually.
119	* @param {(x: Static<this>) => x is T} test - Type test function (see
120	* https://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards)
121	*
122	* @param [options]
123	* @param {string} [options.name] - allows setting the name of this
124	* constrained runtype, which is helpful in reflection or diagnostic
125	* use-cases.
126	*/
127	withGuard<T extends Static<this>, K = unknown>(
128	test: (x: Static<this>) => x is T,
129	options?: { name?: string; args?: K },
130	): Constraint<this, T, K>;
131
132	/**
133	* Adds a brand to the type.
134	*/
135	withBrand<B extends string>(brand: B): Brand<B, this>;
136
137	/**
138	* Apply conversion functions when parsing/serializing this value
139	*/
140	withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): ParsedValue<this, TParsed>;
141	}
142
143	export interface Codec<TParsed, TSerialized = TParsed> extends Runtype<TParsed> {
144	serialize: (x: TParsed) => TSerialized;
145	safeSerialize: (x: TParsed) => Result<TSerialized>;
146	}
147	/**
148	* Obtains the static type associated with a Runtype.
149	*/
150	export type Static<A extends RuntypeBase<any>> = A extends RuntypeBase<infer T> ? T : unknown;
151
152	export function create<TConfig extends Codec<any, any>>(	60✔
153	internalImplementation:
154	\| InternalValidation<Static<TConfig>>
155	\| InternalValidation<Static<TConfig>>['validate'],
156	config: Omit<
157	TConfig,
158	\| 'assert'
159	\| 'check'
160	\| 'test'
161	\| 'guard'
162	\| 'parse'
163	\| 'check'
164	\| 'safeParse'
165	\| 'validate'
166	\| 'serialize'
167	\| 'safeSerialize'
168	\| 'Or'
169	\| 'And'
170	\| 'withConstraint'
171	\| 'withGuard'
172	\| 'withBrand'
173	\| 'withParser'
174	\| typeof internal
175	>,
176	): TConfig {
177	const A: Codec<Static<TConfig>> = {	4,128✔
178	...config,
179	assert,
180	parse,
181	check: parse,
182	safeParse,
183	validate: safeParse,
184	test,
185	guard: test,
186	serialize,
187	safeSerialize,
188	Or,
189	And,
190	withConstraint,
191	withGuard,
192	withBrand,
193	withParser,
194	toString: () => `Runtype<${show(A)}>`,	246✔
195	[internal]:
196	typeof internalImplementation === 'function'
197	? {	4,128✔
198	validate: internalImplementation,
199	}
200	: internalImplementation,
201	};
202
203	return (A as unknown) as TConfig;	4,128✔
204
205	function safeParse(x: any) {
206	return innerValidate(A, x, createVisitedState());	14,586✔
207	}
208	function safeSerialize(x: any) {
209	return innerSerialize(A, x, createVisitedState());	84✔
210	}
211	function parse(x: any) {
212	const validated = safeParse(x);	198✔
213	if (!validated.success) {	198✔
214	throw new ValidationError(validated.message, validated.key);	162✔
215	}
216	return validated.value;	36✔
217	}
218	function serialize(x: any) {
219	const validated = safeSerialize(x);	24✔
220	if (!validated.success) {	24✔
221	throw new ValidationError(validated.message, validated.key);	6✔
222	}
223	return validated.value;	18✔
224	}
225
226	function assert(x: any): asserts x is Static<TConfig> {
227	const validated = innerGuard(A, x, createGuardVisitedState());	108✔
228	if (validated) {	108✔
229	throw new ValidationError(validated.message, validated.key);	66✔
230	}
231	}
232	function test(x: any): x is Static<TConfig> {
233	const validated = innerGuard(A, x, createGuardVisitedState());	1,716✔
234	return validated === undefined;	1,716✔
235	}
236
237	function Or<B extends RuntypeBase>(B: B): Union<[Codec<Static<TConfig>>, B]> {
238	return Union(A, B);	36✔
239	}
240
241	function And<B extends RuntypeBase>(B: B): Intersect<[Codec<Static<TConfig>>, B]> {
242	return Intersect(A, B);	54✔
243	}
244
245	function withConstraint<T extends Static<TConfig>, K = unknown>(
246	constraint: ConstraintCheck<Codec<Static<TConfig>>>,
247	options?: { name?: string; args?: K },
248	): Constraint<Codec<Static<TConfig>>, T, K> {
249	return Constraint<Codec<Static<TConfig>>, T, K>(A, constraint, options);	126✔
250	}
251
252	function withGuard<T extends Static<TConfig>, K = unknown>(
253	test: (x: Static<TConfig>) => x is T,
254	options?: { name?: string; args?: K },
255	): Constraint<Codec<Static<TConfig>>, T, K> {
256	return Constraint<Codec<Static<TConfig>>, T, K>(A, test, options);	24✔
257	}
258
259	function withBrand<B extends string>(B: B): Brand<B, Codec<Static<TConfig>>> {
260	return Brand<B, Codec<Static<TConfig>>>(B, A);	60✔
261	}
262
263	function withParser<TParsed>(
264	config: ParsedValueConfig<Codec<Static<TConfig>>, TParsed>,
265	): ParsedValue<Codec<Static<TConfig>>, TParsed> {
266	return ParsedValue(A as any, config);	30✔
267	}
268	}
269
270	export type Cycle<T> = {
271	success: true;
272	cycle: true;
273	placeholder: Partial<T>;
274	populate: () => Result<T>;
275	unwrap: () => Result<T>;
276	};
277
278	function attemptMixin<T>(placehoder: any, value: T): Result<T> {
279	if (placehoder === value) {	12!
NEW UNCOV 280	return { success: true, value };	×
281	}
282	if (Array.isArray(placehoder) && Array.isArray(value)) {	12✔
283	placehoder.splice(0, placehoder.length, ...value);	6✔
284	return { success: true, value: placehoder as any };	6✔
285	}
286	if (	6!
287	placehoder &&	18!
288	typeof placehoder === 'object' &&
289	!Array.isArray(placehoder) &&
290	value &&
291	typeof value === 'object' &&
292	!Array.isArray(value)
293	) {
NEW 294	Object.assign(placehoder, value);	×
NEW 295	return { success: true, value: placehoder };	×
296	}
297	return {	6✔
298	success: false,
299	message: `Cannot convert a value of type "${
300	Array.isArray(placehoder) ? 'Array' : typeof placehoder	6!
301	}" into a value of type "${
302	value === null ? 'null' : Array.isArray(value) ? 'Array' : typeof value	12!
303	}" when it contains cycles.`,
304	};
305	}
306
307	export function createValidationPlaceholder<T>(	60✔
308	placeholder: T,
309	fn: (placehoder: T) => Result<T> \| undefined,
310	): Cycle<T> {
311	let unwrapped = false;	5,826✔
312	let populating = false;	5,826✔
313	let cache: Result<T> \| undefined;
314	const populateUncached = (): Result<T> => {	5,826✔
315	const result = fn(placeholder);	5,826✔
316	if (result) {	5,826✔
317	if (!result.success) {	3,852!
318	return result;	3,852✔
319	}
NEW 320	if (unwrapped) {	×
NEW 321	return attemptMixin(placeholder, result.value);	×
322	} else {
NEW 323	cycle.placeholder = result.value;	×
NEW 324	return result;	×
325	}
326	}
327	return { success: true, value: placeholder };	1,974✔
328	};
329	const cycle: Cycle<T> = {	5,826✔
330	success: true,
331	cycle: true,
332	placeholder,
333	populate: () => {
334	if (cache) return cache;	270!
335	if (populating) {	270!
NEW 336	return {	×
337	success: false,
338	message: 'Cyclic data structure could not be handled by this set of parsers.',
339	};
340	}
341	populating = true;	270✔
342	const result = populateUncached();	270✔
343	cache = result;	270✔
344	return result;	270✔
345	},
346	unwrap: () => {
347	if (cache) return cache;	5,748✔
348	if (populating) {	5,664✔
349	unwrapped = true;	108✔
350	return {	108✔
351	success: true,
352	value: cycle.placeholder as T,
353	};
354	}
355	populating = true;	5,556✔
356	const result = populateUncached();	5,556✔
357	cache = result;	5,556✔
358	return result;	5,556✔
359	},
360	};
361	return cycle;	5,826✔
362	}
363
364	export function mapValidationPlaceholder<T, S>(	60✔
365	source: ResultWithCycle<T>,
366	fn: (placehoder: T) => Result<S>,
367	extraGuard?: RuntypeBase<S>,
368	): ResultWithCycle<S> {
369	if (!source.success) return source;	42!
370	if (!source.cycle) return fn(source.value);	42!
371	const sourceCycle = source;	42✔
372	const placeholder: Partial<S> = (Array.isArray(sourceCycle.placeholder)	42✔
373	? [...sourceCycle.placeholder]	42✔
374	: { ...sourceCycle.placeholder }) as any;
375
376	let unwrapped = false;	42✔
377	let populating = false;	42✔
378	let cache: Result<S> \| undefined;
379	const populateUncached = (): Result<S> => {	42✔
380	const sourceResult = sourceCycle.populate();	42✔
381	if (!sourceResult.success) return sourceResult;	42!
382	const result = fn(sourceResult.value);	42✔
383	if (!result.success) {	42!
NEW 384	return result;	×
385	}
386	if (unwrapped) {	42✔
387	const unwrapResult = attemptMixin(placeholder, result.value);	12✔
388	const guardFailure =
389	unwrapResult.success &&	12✔
390	extraGuard &&
391	innerGuard(extraGuard, unwrapResult.value, createGuardVisitedState());
392	return guardFailure \|\| unwrapResult;	12✔
393	} else {
394	const guardFailure =
395	extraGuard && innerGuard(extraGuard, result.value, createGuardVisitedState());	30✔
396	cycle.placeholder = result.value;	30✔
397	return guardFailure \|\| result;	30✔
398	}
399	};
400	const cycle: Cycle<S> = {	42✔
401	success: true,
402	cycle: true,
403	placeholder,
404	populate: () => {
NEW 405	if (cache) return cache;	×
NEW 406	if (populating) {	×
NEW 407	return {	×
408	success: false,
409	message: 'Cyclic data structure could not be handled by this set of parsers.',
410	};
411	}
NEW 412	populating = true;	×
NEW 413	const result = populateUncached();	×
NEW 414	cache = result;	×
NEW 415	if (result.success) {	×
NEW 416	cycle.placeholder = result.value;	×
417	}
NEW 418	return result;	×
419	},
420	unwrap: () => {
421	if (cache) return cache;	54!
422	if (populating) {	54✔
423	unwrapped = true;	12✔
424	return {	12✔
425	success: true,
426	value: placeholder as S,
427	};
428	}
429	populating = true;	42✔
430	const result = populateUncached();	42✔
431	cache = result;	42✔
432	if (result.success) {	42✔
433	cycle.placeholder = result.value;	36✔
434	}
435	return result;	42✔
436	},
437	};
438	return cycle;	42✔
439	}
440
441	declare const OpaqueVisitedState: unique symbol;
442	export type OpaqueVisitedState = typeof OpaqueVisitedState;
443	type VisitedState = Map<RuntypeBase<unknown>, Map<any, Cycle<any>>>;
444
445	function unwrapVisitedState(o: OpaqueVisitedState): VisitedState {
446	return o as any;	31,974✔
447	}
448	function wrapVisitedState(o: VisitedState): OpaqueVisitedState {
449	return o as any;	14,820✔
450	}
451
452	export function createVisitedState(): OpaqueVisitedState {	60✔
453	return wrapVisitedState(new Map());	14,820✔
454	}
455
456	declare const OpaqueGuardVisitedState: unique symbol;
457	export type OpaqueGuardVisitedState = typeof OpaqueGuardVisitedState;
458	type GuardVisitedState = Map<RuntypeBase<unknown>, Set<any>>;
459
460	function unwrapGuardVisitedState(o: OpaqueGuardVisitedState): GuardVisitedState {
461	return o as any;	2,538✔
462	}
463	function wrapGuardVisitedState(o: GuardVisitedState): OpaqueGuardVisitedState {
464	return o as any;	1,974✔
465	}
466
467	export function createGuardVisitedState(): OpaqueGuardVisitedState {	60✔
468	return wrapGuardVisitedState(new Map());	1,974✔
469	}
470
471	export function innerValidate<T>(	60✔
472	targetType: RuntypeBase<T>,
473	value: any,
474	$visited: OpaqueVisitedState,
475	): Result<T> {
476	const result = innerValidateToPlaceholder(targetType, value, $visited);	28,872✔
477	if (result.cycle) {	28,872✔
478	return result.unwrap();	5,748✔
479	}
480	return result;	23,124✔
481	}
482
483	function innerValidateToPlaceholder<T>(
484	targetType: RuntypeBase<T>,
485	value: any,
486	$visited: OpaqueVisitedState,
487	): ResultWithCycle<T> {
488	const visited = unwrapVisitedState($visited);	31,704✔
489	const validator = targetType[internal];	31,704✔
490	const cached = visited.get(targetType)?.get(value);	31,704✔
491	if (cached !== undefined) {	31,704✔
492	return cached;	186✔
493	}
494	const result = validator.validate(	31,518✔
495	value,
496	(t, v) => innerValidate(t, v, $visited),	14,154✔
497	(t, v) => innerValidateToPlaceholder(t, v, $visited),	2,832✔
498	);
499	if (result.cycle) {	31,518✔
500	visited.set(targetType, (visited.get(targetType) \|\| new Map()).set(value, result));	6,456✔
501	return result;	6,456✔
502	}
503	return result;	25,062✔
504	}
505
506	export function innerSerialize<T>(	60✔
507	targetType: RuntypeBase<T>,
508	value: any,
509	$visited: OpaqueVisitedState,
510	): Result<T> {
511	const result = innerSerializeToPlaceholder(targetType, value, $visited);	210✔
512	if (result.cycle) {	210✔
513	return result.unwrap();	54✔
514	}
515	return result;	156✔
516	}
517	function innerSerializeToPlaceholder(
518	targetType: RuntypeBase,
519	value: any,
520	$visited: OpaqueVisitedState,
521	): ResultWithCycle<any> {
522	const visited = unwrapVisitedState($visited);	270✔
523	const validator = targetType[internal];	270✔
524	const cached = visited.get(targetType)?.get(value);	270✔
525	if (cached !== undefined) {	270✔
526	return cached;	18✔
527	}
528	let result = (validator.serialize \|\| validator.validate)(	252✔
529	value,
530	(t, v) => innerSerialize(t, v, $visited),	126✔
531	(t, v) => innerSerializeToPlaceholder(t, v, $visited),	60✔
532	);
533	if (result.cycle) {	252✔
534	visited.set(targetType, (visited.get(targetType) \|\| new Map()).set(value, result));	66✔
535	return result;	66✔
536	}
537	return result;	186✔
538	}
539
540	export function innerGuard(	60✔
541	targetType: RuntypeBase,
542	value: any,
543	$visited: OpaqueGuardVisitedState,
544	): Failure \| undefined {
545	const visited = unwrapGuardVisitedState($visited);	2,538✔
546	const validator = targetType[internal];	2,538✔
547	if (value && (typeof value === 'object' \|\| typeof value === 'function')) {	2,538✔
548	const cached = visited.get(targetType)?.has(value);	432✔
549	if (cached) return undefined;	432✔
550	visited.set(targetType, (visited.get(targetType) \|\| new Set()).add(value));	402✔
551	}
552	if (validator.test) {	2,508✔
553	return validator.test(value, (t, v) => innerGuard(t, v, $visited));	72✔
554	}
555	let result = validator.validate(	2,436✔
556	value,
557	(t, v) => innerGuard(t, v, $visited) \|\| { success: true, value: v as any },	396✔
558	(t, v) => innerGuard(t, v, $visited) \|\| { success: true, value: v as any },	108✔
559	);
560	if (result.cycle) result = result.populate();	2,436✔
561	if (result.success) return undefined;	2,436✔
562	else return result;	1,806✔
563	}

ForbesLindesay / funtypes / 248968596

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous