245569757

Build Type

github

Committed by GitHub

Commit Message

Merge 0cf1db434 into 64a93ecf1

Pull Request Pull Request #17: feat: ParsedValue type

Run Details

328 of 361 branches covered (90.86%)

Branch coverage included in aggregate %.

216 of 234 new or added lines in 24 files covered. (92.31%)

1 existing line in 1 file now uncovered.

513 of 531 relevant lines covered (96.61%)

1207.15 hits per line

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

78.0

/src/types/intersect.ts

import { Static, create, RuntypeBase, Codec, createValidationPlaceholder } from '../runtype';
import show from '../show';

// We use the fact that a union of functions is effectively an intersection of parameters
// e.g. to safely call (({x: 1}) => void | ({y: 2}) => void) you must pass {x: 1, y: 2}
export type StaticIntersect<TIntersectees extends readonly RuntypeBase<unknown>[]> = {
  [key in keyof TIntersectees]: TIntersectees[key] extends RuntypeBase
    ? (parameter: Static<TIntersectees[key]>) => any
    : unknown;
}[number] extends (k: infer I) => void
  ? I
  : never;

export interface Intersect<
  TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
> extends Codec<StaticIntersect<TIntersectees>> {
  readonly tag: 'intersect';
  readonly intersectees: TIntersectees;
}

/**
 * Construct an intersection runtype from runtypes for its alternatives.
 */
export function Intersect<
  TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
>(...intersectees: TIntersectees): Intersect<TIntersectees> {
  return create<Intersect<TIntersectees>>(
    (value, innerValidate) => {
      if (Array.isArray(value)) {
        return createValidationPlaceholder<any>([...value], placeholder => {
          for (const targetType of intersectees) {
            let validated = innerValidate(targetType, placeholder);
            if (!validated.success) {
              return validated;
            }
            if (!Array.isArray(validated.value)) {
              return {
                success: false,
                message: `The validator ${show(
                  targetType,
                )} attempted to convert the type of this value from an array to something else. That conversion is not valid as the child of an intersect`,
              };
            }
            placeholder.splice(0, placeholder.length, validated.value);
          }
        });
      } else if (value && typeof value === 'object') {
        return createValidationPlaceholder<any>({}, placeholder => {
          for (const targetType of intersectees) {
            let validated = innerValidate(targetType, value);
            if (!validated.success) {
              return validated;
            }
            if (!(validated.value && typeof validated.value === 'object')) {
              return {
                success: false,
                message: `The validator ${show(
                  targetType,
                )} attempted to convert the type of this value from an object to something else. That conversion is not valid as the child of an intersect`,
              };
            }
            Object.assign(placeholder, validated.value);
          }
        });
      }
      let result = value;
      for (const targetType of intersectees) {
        let validated = innerValidate(targetType, result);
        if (!validated.success) {
          return validated;
        }
        result = validated.value;
      }
      // TODO: merge the maps
      return { success: true, value: result };
    },
    {
      tag: 'intersect',
      intersectees,
      show({ parenthesize, showChild }) {
        return parenthesize(`${intersectees.map(v => showChild(v, true)).join(' & ')}`);
      },
    },
  );
}

1	import { Static, create, RuntypeBase, Codec, createValidationPlaceholder } from '../runtype';	54✔
2	import show from '../show';	54✔
3
4	// We use the fact that a union of functions is effectively an intersection of parameters
5	// e.g. to safely call (({x: 1}) => void \| ({y: 2}) => void) you must pass {x: 1, y: 2}
6	export type StaticIntersect<TIntersectees extends readonly RuntypeBase<unknown>[]> = {
7	[key in keyof TIntersectees]: TIntersectees[key] extends RuntypeBase
8	? (parameter: Static<TIntersectees[key]>) => any
9	: unknown;
10	}[number] extends (k: infer I) => void
11	? I
12	: never;
13
14	export interface Intersect<
15	TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
16	> extends Codec<StaticIntersect<TIntersectees>> {
17	readonly tag: 'intersect';
18	readonly intersectees: TIntersectees;
19	}
20
21	/**
22	* Construct an intersection runtype from runtypes for its alternatives.
23	*/
24	export function Intersect<	54✔
25	TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
26	>(...intersectees: TIntersectees): Intersect<TIntersectees> {	360✔
27	return create<Intersect<TIntersectees>>(	90✔
28	(value, innerValidate) => {
29	if (Array.isArray(value)) {	1,242✔
30	return createValidationPlaceholder<any>([...value], placeholder => {	288✔
31	for (const targetType of intersectees) {	576✔
32	let validated = innerValidate(targetType, placeholder);	288✔
33	if (!validated.success) {	288!
34	return validated;	288✔
35	}
NEW 36	if (!Array.isArray(validated.value)) {	×
NEW 37	return {	×
38	success: false,
39	message: `The validator ${show(
40	targetType,
41	)} attempted to convert the type of this value from an array to something else. That conversion is not valid as the child of an intersect`,
42	};
43	}
NEW 44	placeholder.splice(0, placeholder.length, validated.value);	×
45	}
46	});
47	} else if (value && typeof value === 'object') {	954✔
48	return createValidationPlaceholder<any>({}, placeholder => {	600✔
49	for (const targetType of intersectees) {	1,200✔
50	let validated = innerValidate(targetType, value);	882✔
51	if (!validated.success) {	882✔
52	return validated;	540✔
53	}
54	if (!(validated.value && typeof validated.value === 'object')) {	342!
NEW 55	return {	×
56	success: false,
57	message: `The validator ${show(
58	targetType,
59	)} attempted to convert the type of this value from an object to something else. That conversion is not valid as the child of an intersect`,
60	};
61	}
62	Object.assign(placeholder, validated.value);	342✔
63	}
64	});
65	}
66	let result = value;	354✔
67	for (const targetType of intersectees) {	708✔
68	let validated = innerValidate(targetType, result);	354✔
69	if (!validated.success) {	354!
70	return validated;	354✔
71	}
NEW 72	result = validated.value;	×
73	}
74	// TODO: merge the maps
NEW UNCOV 75	return { success: true, value: result };	×
76	},
77	{
78	tag: 'intersect',
79	intersectees,
80	show({ parenthesize, showChild }) {	450✔
81	return parenthesize(`${intersectees.map(v => showChild(v, true)).join(' & ')}`);	900✔
82	},
83	},
84	);
85	}

ForbesLindesay / funtypes / 245569757

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