240960510

Build Type

github

Committed by GitHub

Commit Message

Merge f8bbc4dea into 07906f0ce

Pull Request Pull Request #8: refactor: redesign internal types

Run Details

203 of 230 branches covered (88.26%)

Branch coverage included in aggregate %.

187 of 201 new or added lines in 24 files covered. (93.03%)

1 existing line in 1 file now uncovered.

380 of 395 relevant lines covered (96.2%)

1986.14 hits per line

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

66.67

/src/types/dictionary.ts

import { create, Static, innerValidate, RuntypeBase, Runtype } from '../runtype';
import show from '../show';
import { String } from './string';
import { Number } from './number';
import { Literal } from './literal';
import { Constraint } from './constraint';
import { Lazy, lazyValue } from './lazy';
import { Union } from './union';

export type KeyRuntypeBaseWithoutLazyOrUnion =
  | Pick<String, keyof RuntypeBase>
  | Pick<Number, keyof RuntypeBase>
  | Pick<Literal<string | number>, 'value' | keyof RuntypeBase>
  | Pick<Constraint<KeyRuntypeBase, string | number>, 'underlying' | keyof RuntypeBase>;

export type KeyRuntypeBaseWithoutLazy =
  | KeyRuntypeBaseWithoutLazyOrUnion
  | Pick<Union<KeyRuntypeBaseWithoutUnion[]>, 'alternatives' | keyof RuntypeBase>;

export type KeyRuntypeBaseWithoutUnion =
  | KeyRuntypeBaseWithoutLazyOrUnion
  | Pick<Lazy<KeyRuntypeBaseWithoutLazyOrUnion>, 'underlying' | keyof RuntypeBase>;
export type KeyRuntypeBase = KeyRuntypeBaseWithoutLazy | KeyRuntypeBaseWithoutUnion;

function getExpectedBaseType(key: KeyRuntypeBase): 'string' | 'number' | 'mixed' {
  switch (key.tag) {
    case 'string':
      return 'string';
    case 'number':
      return 'number';
    case 'literal':
      return typeof key.value as 'string' | 'number';
    case 'union':
      const baseTypes = key.alternatives.map(getExpectedBaseType);
      if (baseTypes.length === 1) return baseTypes[0];
      return baseTypes.reduce((a, b) => (a === b ? a : 'mixed'));
    case 'constraint':
      return getExpectedBaseType(key.underlying);
    case 'lazy':
      return getExpectedBaseType(key.underlying());
  }
}

export interface Dictionary<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>
  extends Runtype<{ [_ in Static<K>]: Static<V> }>,
    RuntypeBase<{ [_ in Static<K>]: Static<V> }> {
  readonly tag: 'dictionary';
  readonly key: K;
  readonly value: V;
}

/**
 * Construct a runtype for arbitrary dictionaries.
 */
export function Dictionary<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(
  key: K,
  value: V,
): Dictionary<K, V> {
  const expectedBaseType = lazyValue(() => getExpectedBaseType(key));
  const runtype: Dictionary<K, V> = create<Dictionary<K, V>>(
    (x, visited) => {
      if (x === null || x === undefined) {
        return { success: false, message: `Expected ${show(runtype)}, but was ${x}` };
      }

      if (typeof x !== 'object') {
        return { success: false, message: `Expected ${show(runtype)}, but was ${typeof x}` };
      }

      if (Object.getPrototypeOf(x) !== Object.prototype) {
        if (!Array.isArray(x)) {
          return {
            success: false,
            message: `Expected ${show(runtype)}, but was ${Object.getPrototypeOf(x)}`,
          };
        }
        return { success: false, message: 'Expected dictionary, but was array' };
      }

      for (const k in x) {
        if (expectedBaseType() === 'number') {
          if (isNaN(+k))
            return {
              success: false,
              message: 'Expected dictionary key to be a number, but was string',
            };
          const keyResult = key.validate(+k);
          if (!keyResult.success) return keyResult;
        } else if (expectedBaseType() === 'string') {
          const keyResult = key.validate(k);
          if (!keyResult.success) return keyResult;
        } else {
          const numResult = !isNaN(+k) && key.validate(+k);
          const strResult = key.validate(k);
          if (!(!numResult || numResult.success) && !strResult.success) return strResult;
        }

        const validated = innerValidate(value, (x as any)[k], visited);
        if (!validated.success) {
          return {
            success: false,
            message: validated.message,
            key: validated.key ? `${k}.${validated.key}` : k,
          };
        }
      }

      return { success: true, value: x };
    },
    {
      tag: 'dictionary',
      key,
      value,
      show({ showChild }) {
        return `{ [_: ${showChild(key, false)}]: ${showChild(value, false)} }`;
      },
    },
  );
  return runtype;
}

1	import { create, Static, innerValidate, RuntypeBase, Runtype } from '../runtype';	30✔
2	import show from '../show';	30✔
3	import { String } from './string';
4	import { Number } from './number';
5	import { Literal } from './literal';
6	import { Constraint } from './constraint';
7	import { Lazy, lazyValue } from './lazy';	30✔
8	import { Union } from './union';
9
10	export type KeyRuntypeBaseWithoutLazyOrUnion =
11	\| Pick<String, keyof RuntypeBase>
12	\| Pick<Number, keyof RuntypeBase>
13	\| Pick<Literal<string \| number>, 'value' \| keyof RuntypeBase>
14	\| Pick<Constraint<KeyRuntypeBase, string \| number>, 'underlying' \| keyof RuntypeBase>;
15
16	export type KeyRuntypeBaseWithoutLazy =
17	\| KeyRuntypeBaseWithoutLazyOrUnion
18	\| Pick<Union<KeyRuntypeBaseWithoutUnion[]>, 'alternatives' \| keyof RuntypeBase>;
19
20	export type KeyRuntypeBaseWithoutUnion =
21	\| KeyRuntypeBaseWithoutLazyOrUnion
22	\| Pick<Lazy<KeyRuntypeBaseWithoutLazyOrUnion>, 'underlying' \| keyof RuntypeBase>;
23	export type KeyRuntypeBase = KeyRuntypeBaseWithoutLazy \| KeyRuntypeBaseWithoutUnion;
24
25	function getExpectedBaseType(key: KeyRuntypeBase): 'string' \| 'number' \| 'mixed' {
26	switch (key.tag) {	48✔
27	case 'string':	48!
28	return 'string';	36✔
29	case 'number':
30	return 'number';	12✔
31	case 'literal':
NEW 32	return typeof key.value as 'string' \| 'number';	×
33	case 'union':
NEW 34	const baseTypes = key.alternatives.map(getExpectedBaseType);	×
NEW 35	if (baseTypes.length === 1) return baseTypes[0];	×
NEW 36	return baseTypes.reduce((a, b) => (a === b ? a : 'mixed'));	×
37	case 'constraint':
NEW 38	return getExpectedBaseType(key.underlying);	×
39	case 'lazy':
NEW 40	return getExpectedBaseType(key.underlying());	×
41	}
42	}
43
44	export interface Dictionary<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>
45	extends Runtype<{ [_ in Static<K>]: Static<V> }>,
46	RuntypeBase<{ [_ in Static<K>]: Static<V> }> {
47	readonly tag: 'dictionary';
48	readonly key: K;
49	readonly value: V;
50	}
51
52	/**
53	* Construct a runtype for arbitrary dictionaries.
54	*/
55	export function Dictionary<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(	30✔
56	key: K,
57	value: V,
58	): Dictionary<K, V> {
59	const expectedBaseType = lazyValue(() => getExpectedBaseType(key));	102✔
60	const runtype: Dictionary<K, V> = create<Dictionary<K, V>>(	102✔
61	(x, visited) => {
62	if (x === null \|\| x === undefined) {	1,470✔
63	return { success: false, message: `Expected ${show(runtype)}, but was ${x}` };	78✔
64	}
65
66	if (typeof x !== 'object') {	1,392✔
67	return { success: false, message: `Expected ${show(runtype)}, but was ${typeof x}` };	306✔
68	}
69
70	if (Object.getPrototypeOf(x) !== Object.prototype) {	1,086✔
71	if (!Array.isArray(x)) {	432✔
72	return {	90✔
73	success: false,
74	message: `Expected ${show(runtype)}, but was ${Object.getPrototypeOf(x)}`,
75	};
76	}
77	return { success: false, message: 'Expected dictionary, but was array' };	342✔
78	}
79
80	for (const k in x) {	654✔
81	if (expectedBaseType() === 'number') {	732✔
82	if (isNaN(+k))	144✔
83	return {	120✔
84	success: false,
85	message: 'Expected dictionary key to be a number, but was string',
86	};
87	const keyResult = key.validate(+k);	24✔
88	if (!keyResult.success) return keyResult;	24!
89	} else if (expectedBaseType() === 'string') {	588!
90	const keyResult = key.validate(k);	588✔
91	if (!keyResult.success) return keyResult;	588!
92	} else {
NEW 93	const numResult = !isNaN(+k) && key.validate(+k);	×
NEW 94	const strResult = key.validate(k);	×
NEW 95	if (!(!numResult \|\| numResult.success) && !strResult.success) return strResult;	×
96	}
97
98	const validated = innerValidate(value, (x as any)[k], visited);	612✔
99	if (!validated.success) {	612✔
100	return {	474✔
101	success: false,
102	message: validated.message,
103	key: validated.key ? `${k}.${validated.key}` : k,	474✔
104	};
105	}
106	}
107
108	return { success: true, value: x };	60✔
109	},
110	{
111	tag: 'dictionary',
112	key,
113	value,
114	show({ showChild }) {	510✔
115	return `{ [_: ${showChild(key, false)}]: ${showChild(value, false)} }`;	510✔
116	},
117	},
118	);
119	return runtype;	102✔
120	}

ForbesLindesay / funtypes / 240960510

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