funtypes - npm Package Compare versions

lib/chunk-c374952a.mjs

lib/chunk-dd209c8b.js

lib/readonly.d.ts

lib/readonly.js

lib/readonly.mjs

lib/types/Mutable.d.ts

lib/types/Sealed.d.ts

scripts/test-import.js

src/readonly.ts

src/types/Mutable.spec.ts

src/types/Mutable.ts

src/types/Sealed.spec.ts

src/types/Sealed.ts

54

.size-snapshot.json

		{
		"chunk-dd209c8b.js": {
		"bundled": 31236,
		"minified": 19651,
		"gzipped": 6098
		},
		"readonly.js": {
		"bundled": 1880,
		"minified": 1532,
		"gzipped": 529
		},
		"index.js": {
		"bundled": 27341,
		"minified": 17663,
		"gzipped": 5534
		"bundled": 1721,
		"minified": 1391,
		"gzipped": 482
		},
		"index.mjs": {
		"bundled": 26898,
		"minified": 17555,
		"gzipped": 5501,
		"bundled": 847,
		"minified": 703,
		"gzipped": 370,
		"treeshaked": {
		"rollup": {
		"code": 0,
		"code": 29,
		"import_statements": 29
		},
		"webpack": {
		"code": 1013
		}
		}
		},
		"chunk-c374952a.mjs": {
		"bundled": 31026,
		"minified": 19713,
		"gzipped": 6139,
		"treeshaked": {
		"rollup": {
		"code": 10493,
		"import_statements": 0
		},
		"webpack": {
		"code": 10513
		"code": 11444
		}
		}
		},
		"readonly.mjs": {
		"bundled": 991,
		"minified": 827,
		"gzipped": 432,
		"treeshaked": {
		"rollup": {
		"code": 136,
		"import_statements": 76
		},
		"webpack": {
		"code": 1099
		}
		}
		}
		}

12

lib/index.d.ts

		@@ -10,3 +10,8 @@ export { AsyncContract } from './asynccontract';
		export { default as showValue } from './showValue';
		export { Array, ReadonlyArray } from './types/array';
		export { Readonly } from './types/Readonly';
		export { Mutable } from './types/Mutable';
		export { Array, Array as MutableArray, ReadonlyArray } from './types/array';
		export { Object, Object as MutableObject, ReadonlyObject, Partial, Partial as MutablePartial, ReadonlyPartial, } from './types/Object';
		export { Record, Record as MutableRecord, ReadonlyRecord } from './types/Record';
		export { Tuple, Tuple as MutableTuple, ReadonlyTuple } from './types/tuple';
		export type { ConstraintCheck } from './types/constraint';
		@@ -23,7 +28,4 @@ export { Constraint, Guard } from './types/constraint';
		export { Never } from './types/never';
		export { Object, Partial } from './types/Object';
		export { Boolean, Function, Number, String, Symbol } from './types/primative';
		export { Readonly } from './types/Readonly';
		export { Record } from './types/Record';
		export { Tuple } from './types/tuple';
		export { Sealed } from './types/Sealed';
		export { Union } from './types/union';
		@@ -30,0 +32,0 @@ export { Unknown } from './types/unknown';

952

lib/index.js

		"use strict";
		function isParsedValueRuntype(e) {
		return "tag" in e && "parsed" === e.tag;
		}
		function ParsedValue(e, t) {
		return (
		assertRuntype(e),
		create(
		"parsed",
		{
		p: (r, n, s) =>
		((e, t, r) => {
		if (!e.success) return e;
		if (!e.cycle) {
		const n = t(e.value);
		return (n.success && r && innerGuard(r, n.value, createGuardVisitedState())) \|\| n;
		}
		return innerMapValidationPlaceholder(
		Array.isArray(e.placeholder) ? [...e.placeholder] : { ...e.placeholder },
		() => e.unwrap(),
		t,
		r,
		);
		})(s(e, r), e => t.parse(e), t.test),
		t(r, n) {
		return t.test
		? n(t.test, r)
		: failure((t.name \|\| `ParsedValue<${show(e)}>`) + " does not support Runtype.test");
		},
		s(r, n, s) {
		if (!t.serialize)
		return failure(
		(t.name \|\| `ParsedValue<${show(e)}>`) + " does not support Runtype.serialize",
		);
		const a = t.test ? innerGuard(t.test, r, createGuardVisitedState()) : void 0;
		if (a) return a;
		const o = t.serialize(r);
		return o.success ? s(e, o.value) : o;
		},
		},
		{
		underlying: e,
		config: t,
		show() {
		return t.name \|\| `ParsedValue<${show(e, !1)}>`;
		},
		},
		)
		);
		}
		function assertRuntype(...e) {
		for (const r of e) if (!r \|\| !r[t]) throw new Error("Expected Runtype but got " + showValue(r));
		}
		function create(e, r, n) {
		function safeParse(e) {
		return innerValidate(s, e, createVisitedState());
		}
		function safeSerialize(e) {
		return innerSerialize(s, e, createVisitedState());
		}
		const s = {
		...n,
		tag: e,
		assert(e) {
		const t = innerGuard(s, e, createGuardVisitedState());
		if (t) throw new ValidationError(t);
		},
		parse(e) {
		const t = safeParse(e);
		if (!t.success) throw new ValidationError(t);
		return t.value;
		},
		safeParse,
		test: e => void 0 === innerGuard(s, e, createGuardVisitedState()),
		serialize(e) {
		const t = safeSerialize(e);
		if (!t.success) throw new ValidationError(t);
		return t.value;
		},
		safeSerialize,
		Or: e => Union(s, e),
		And: e => Intersect(s, e),
		withConstraint: (e, t) => Constraint(s, e, t),
		withGuard: (e, t) => Constraint(s, e, t),
		withBrand: e => Brand(e, s),
		withParser: e => ParsedValue(s, e),
		toString: () => `Runtype<${show(s)}>`,
		[t]: "function" == typeof r ? { p: r } : r,
		};
		return s;
		}
		function createValidationPlaceholder(e, t) {
		return innerMapValidationPlaceholder(e, () => t(e) \|\| success(e));
		}
		function innerMapValidationPlaceholder(e, t, r, n) {
		let s,
		a = !1;
		const o = {
		success: !0,
		cycle: !0,
		placeholder: e,
		unwrap() {
		if (s) return (a = !0), s;
		s = success(e);
		const i = t(),
		l = i.success && r ? r(i.value) : i;
		if (!l.success) return (s = l);
		if (a) {
		const e = ((e, t) =>
		e === t
		? success(t)
		: Array.isArray(e) && Array.isArray(t)
		? (e.splice(0, e.length, ...t), success(e))
		: e &&
		"object" == typeof e &&
		!Array.isArray(e) &&
		t &&
		"object" == typeof t &&
		!Array.isArray(t)
		? (Object.assign(e, t), success(e))
		: failure(
		`Cannot convert a value of type "${
		Array.isArray(e) ? "Array" : typeof e
		}" into a value of type "${
		null === t ? "null" : Array.isArray(t) ? "Array" : typeof t
		}" when it contains cycles.`,
		))(s.value, l.value),
		t = e.success && n && innerGuard(n, e.value, createGuardVisitedState());
		s = t \|\| e;
		} else {
		const e = n && innerGuard(n, l.value, createGuardVisitedState());
		s = e \|\| l;
		}
		return s.success && (o.placeholder = s.value), s;
		},
		};
		return o;
		}
		function createVisitedState() {
		return new Map();
		}
		function createGuardVisitedState() {
		return new Map();
		}
		function innerValidate(e, t, r) {
		const n = innerValidateToPlaceholder(e, t, r);
		return n.cycle ? n.unwrap() : n;
		}
		function innerValidateToPlaceholder(e, r, n) {
		var s;
		const a = n,
		o = e[t],
		i = null === (s = a.get(e)) \|\| void 0 === s ? void 0 : s.get(r);
		if (void 0 !== i) return i;
		const l = o.p(
		r,
		(e, t) => innerValidate(e, t, n),
		(e, t) => innerValidateToPlaceholder(e, t, n),
		);
		return l.cycle ? (a.set(e, (a.get(e) \|\| new Map()).set(r, l)), l) : l;
		}
		function innerSerialize(e, t, r) {
		const n = innerSerializeToPlaceholder(e, t, r);
		return n.cycle ? n.unwrap() : n;
		}
		function innerSerializeToPlaceholder(e, r, n) {
		var s;
		const a = n,
		o = e[t],
		i = null === (s = a.get(e)) \|\| void 0 === s ? void 0 : s.get(r);
		if (void 0 !== i) return i;
		let l = (o.s \|\| o.p)(
		r,
		(e, t) => innerSerialize(e, t, n),
		(e, t) => innerSerializeToPlaceholder(e, t, n),
		);
		return l.cycle ? (a.set(e, (a.get(e) \|\| new Map()).set(r, l)), l) : l;
		}
		function innerGuard(e, r, n) {
		var s;
		const a = n,
		o = e[t];
		if (r && ("object" == typeof r \|\| "function" == typeof r)) {
		if (null === (s = a.get(e)) \|\| void 0 === s ? void 0 : s.has(r)) return;
		a.set(e, (a.get(e) \|\| new Set()).add(r));
		}
		if (o.t) return o.t(r, (e, t) => innerGuard(e, t, n));
		let i = o.p(
		r,
		(e, t) => innerGuard(e, t, n) \|\| success(t),
		(e, t) => innerGuard(e, t, n) \|\| success(t),
		);
		return i.cycle && (i = i.unwrap()), i.success ? void 0 : i;
		}
		function showValue(e, r = 3, n = 30) {
		switch (typeof e) {
		case "bigint":
		case "boolean":
		case "number":
		return "" + e;
		case "string":
		return JSON.stringify(e);
		case "object":
		if (null === e) return "null";
		if (Array.isArray(e)) {
		if (0 === r \|\| 0 === n) return "[Array]";
		{
		let t = "[",
		s = 0;
		for (s = 0; s < e.length && n > t.length; s++)
		0 !== s && (t += ", "), (t += showValue(e[s], r - 1, n - t.length));
		return s < e.length && (t += " ... "), (t += "]"), t;
		}
		}
		if ((e => "object" == typeof e && null != e && t in e)(e)) return e.toString();
		if (0 === r) return "{Object}";
		{
		const t = Object.entries(e);
		let s = "{",
		a = 0;
		for (a = 0; a < t.length && n > s.length; a++) {
		0 !== a && (s += ", ");
		const [e, o] = t[a];
		s += `${/\s/.test(e) ? JSON.stringify(e) : e}: ${showValue(o, r - 1, n - s.length)}`;
		}
		return a < t.length && (s += " ... "), (s += "}"), s;
		}
		case "function":
		case "symbol":
		case "undefined":
		default:
		return typeof e;
		}
		}
		function success(e) {
		return { success: !0, value: e };
		}
		function failure(e, t = {}) {
		return { success: !1, message: e, ...t };
		}
		function expected(e, t, r = {}) {
		return failure(`Expected ${"string" == typeof e ? e : show(e)}, but was ${showValue(t)}`, r);
		}
		function unableToAssign(e, t, ...r) {
		return [
		`Unable to assign ${showValue(e)} to ${"string" == typeof t ? t : show(t)}`,
		...r.map(toFullError),
		];
		}
		function andError([e, ...t]) {
		return [`And ${e[0].toLocaleLowerCase()}${e.substr(1)}`, ...t];
		}
		function typesAreNotCompatible(e, ...t) {
		return [`The types of ${e} are not compatible`, ...t.map(toFullError)];
		}
		function toFullError(e) {
		return "string" == typeof e ? [e] : Array.isArray(e) ? e : toFullError(e.fullError \|\| e.message);
		}
		function showError(e) {
		return e.fullError ? showFullError(e.fullError) : e.key ? `${e.message} in ${e.key}` : e.message;
		}
		function showFullError([e, ...t], r = "") {
		return [`${r}${e}`, ...t.map(e => showFullError(e, r + " "))].join("\n");
		}
		function InternalArr(e, t) {
		assertRuntype(e);
		const r = create(
		"array",
		(t, n) =>
		Array.isArray(t)
		? createValidationPlaceholder([...t], s => {
		let a,
		o = void 0;
		for (let i = 0; i < t.length; i++) {
		const l = n(e, t[i]);
		l.success
		? (s[i] = l.value)
		: (o \|\| (o = unableToAssign(t, r)),
		o.push(typesAreNotCompatible(`[${i}]`, l)),
		(a =
		a \|\|
		failure(l.message, {
		key: l.key ? `[${i}].${l.key}` : `[${i}]`,
		fullError: o,
		})));
		}
		return a;
		})
		: expected("an Array", t),
		{
		isReadonly: t,
		element: e,
		show() {
		return `${t ? "readonly " : ""}${show(e, !0)}[]`;
		},
		},
		);
		return t \|\| (r.asReadonly = () => InternalArr(e, !0)), r;
		}
		function Constraint(e, t, r) {
		assertRuntype(e);
		const n = create(
		"constraint",
		(s, a) => {
		const o = r && r.name,
		i = a(e, s);
		if (!i.success) return i;
		const l = t(i.value);
		if (!l \|\| "string" == typeof l) {
		const e = "string" == typeof l ? l : `${showValue(s)} failed ${o \|\| "constraint"} check`;
		return failure(e, { fullError: unableToAssign(s, n, e) });
		}
		return success(i.value);
		},
		{
		underlying: e,
		constraint: t,
		name: r && r.name,
		args: r && r.args,
		show(t) {
		return (r && r.name) \|\| `WithConstraint<${show(e, t)}>`;
		},
		},
		);
		return n;
		}
		function Intersect(...e) {
		return (
		assertRuntype(...e),
		create(
		"intersect",
		(t, r) => {
		if (Array.isArray(t))
		return createValidationPlaceholder([...t], t => {
		for (const n of e) {
		let e = r(n, t);
		if (!e.success) return e;
		if (!Array.isArray(e.value))
		return failure(
		`The validator ${show(
		n,
		)} 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`,
		);
		t.splice(0, t.length, ...e.value);
		}
		});
		if (t && "object" == typeof t)
		return createValidationPlaceholder(Object.create(null), n => {
		for (const s of e) {
		let e = r(s, t);
		if (!e.success) return e;
		if (!e.value \|\| "object" != typeof e.value)
		return failure(
		`The validator ${show(
		s,
		)} 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(n, e.value);
		}
		});
		let n = t;
		for (const t of e) {
		let e = r(t, n);
		if (!e.success) return e;
		n = e.value;
		}
		return success(n);
		},
		{
		intersectees: e,
		show(t) {
		return parenthesize("" + e.map(e => show(e, !0)).join(" & "), t);
		},
		},
		)
		);
		}
		function lazyValue(e) {
		let t;
		return () => t \|\| (t = e());
		}
		function Literal(e) {
		return create(
		"literal",
		t =>
		t === e
		? success(t)
		: failure(
		`Expected literal ${showValue(e)}, but was ${showValue(t)}${
		typeof t != typeof e ? ` (i.e. a ${typeof t})` : ""
		}`,
		),
		{
		value: e,
		show() {
		return showValue(e);
		},
		},
		);
		}
		function hasKey(e, t) {
		return "object" == typeof t && e in t;
		}
		function InternalObject(e, t, r) {
		assertRuntype(...Object.values(e));
		const n = create(
		"object",
		(r, s) =>
		null == r \|\| "object" != typeof r
		? expected(n, r)
		: Array.isArray(r)
		? failure(`Expected ${show(n)}, but was an Array`)
		: createValidationPlaceholder(Object.create(null), a => {
		let o,
		i = void 0;
		for (const l in e)
		if (!t \|\| (hasKey(l, r) && void 0 !== r[l])) {
		const u = t \|\| hasKey(l, r) ? r[l] : void 0;
		let c = s(e[l], u);
		c.success
		? (a[l] = c.value)
		: (i \|\| (i = unableToAssign(r, n)),
		i.push(typesAreNotCompatible(`"${l}"`, c)),
		(o =
		o \|\| failure(c.message, { key: c.key ? `${l}.${c.key}` : l, fullError: i })));
		}
		return o;
		}),
		{
		isPartial: t,
		isReadonly: r,
		fields: e,
		asPartial: () => InternalObject(n.fields, !0, n.isReadonly),
		asReadonly: () => InternalObject(n.fields, n.isPartial, !0),
		pick(...n) {
		const s = {};
		for (const t of n) s[t] = e[t];
		return InternalObject(s, t, r);
		},
		omit(...n) {
		const s = { ...e };
		for (const e of n) e in s && delete s[e];
		return InternalObject(s, t, r);
		},
		show() {
		const n = Object.keys(e);
		return n.length
		? `{ ${n
		.map(n => `${r ? "readonly " : ""}${n}${t ? "?" : ""}: ${show(e[n], !1)};`)
		.join(" ")} }`
		: "{}";
		},
		},
		);
		return n;
		}
		function createPrimative(e) {
		return create(
		e,
		t =>
		typeof t === e
		? success(t)
		: failure(
		`Expected ${e}, but was ${(e =>
		`${showValue(e)}${"string" == typeof e ? " (i.e. a string literal)" : ""}`)(t)}`,
		),
		{},
		);
		}
		function getExpectedBaseType(e) {
		switch (e.tag) {
		case "string":
		return "string";
		case "number":
		return "number";
		case "literal":
		return typeof e.value;
		case "union":
		const t = e.alternatives.map(getExpectedBaseType);
		return t.reduce((e, t) => (e === t ? e : "mixed"), t[0]);
		case "constraint":
		return getExpectedBaseType(e.underlying);
		}
		}
		function Brand(e, t) {
		return (
		assertRuntype(t),
		create("brand", (e, r, n) => n(t, e), {
		brand: e,
		entity: t,
		show(e) {
		return show(t, e);
		},
		})
		);
		}
		function isUnionType(e) {
		return "tag" in e && "union" === e.tag;
		}
		function resolveUnderlyingType(e, t) {
		return (e => "tag" in e && "lazy" === e.tag)(e)
		? resolveUnderlyingType(e.underlying(), t)
		: (e => "tag" in e && "brand" === e.tag)(e)
		? resolveUnderlyingType(e.entity, t)
		: (e => "tag" in e && "constraint" === e.tag)(e) \|\|
		(e => "tag" in e && "named" === e.tag)(e) \|\|
		("p" === t && isParsedValueRuntype(e))
		? resolveUnderlyingType(e.underlying, t)
		: "t" === t && isParsedValueRuntype(e)
		? e.config.test
		? resolveUnderlyingType(e.config.test, t)
		: a
		: "s" === t && isParsedValueRuntype(e)
		? e.config.serialize
		? e.config.test
		? resolveUnderlyingType(e.config.test, t)
		: e
		: a
		: e;
		}
		function mapGet(e) {
		return (t, r) => {
		const n = e.get(t);
		if (void 0 !== n) return n;
		const s = r();
		return e.set(t, s), s;
		};
		}
		function findFields(e, t) {
		const r = resolveUnderlyingType(e, t),
		n = [],
		pushField = (e, r) => {
		const s = resolveUnderlyingType(r, t);
		if (isUnionType(s)) for (const t of s.alternatives) pushField(e, t);
		else n.push([e, s]);
		};
		if ("tag" in (s = r) && "object" === s.tag && !r.isPartial)
		for (const e of Object.keys(r.fields)) pushField(e, r.fields[e]);
		var s;
		if (
		((e => "tag" in e && "tuple" === e.tag)(r) &&
		r.components.forEach((e, t) => {
		pushField("" + t, e);
		}),
		(e => "tag" in e && "intersect" === e.tag)(r))
		)
		for (const e of r.intersectees) n.push(...findFields(e, t));
		return n;
		}
		function Union(...e) {
		function validateWithKey(e, t) {
		const r =
		"" +
		Array.from(t.values())
		.map(e => show(e, !0))
		.join(" \| ");
		return (n, s) => {
		if (!n \|\| "object" != typeof n) return expected(r, n);
		const a = t.get(n[e]);
		if (a) {
		const t = s(a, n);
		return t.success
		? t
		: failure(t.message, {
		key: `<${/^\d+$/.test(e) ? `[${e}]` : e}: ${showValue(n[e])}>${
		t.key ? "." + t.key : ""
		}`,
		fullError: unableToAssign(n, r, t),
		});
		}
		{
		const s = expected(
		Array.from(t.keys())
		.map(e => ("string" == typeof e ? `'${e}'` : e))
		.join(" \| "),
		n[e],
		{ key: /^\d+$/.test(e) ? `[${e}]` : e },
		);
		return (
		(s.fullError = unableToAssign(
		n,
		r,
		typesAreNotCompatible(/^\d+$/.test(e) ? `[${e}]` : `"${e}"`, s.message),
		)),
		s
		);
		}
		};
		}
		function validateWithoutKey(e) {
		return (t, r) => {
		let s;
		for (const a of e) {
		const e = r(a, t);
		if (e.success) return e;
		s
		? s.push(andError(e.fullError \|\| unableToAssign(t, a, e)))
		: (s = unableToAssign(t, n, e.fullError \|\| unableToAssign(t, a, e)));
		}
		return expected(n, t, { fullError: s });
		};
		}
		assertRuntype(...e);
		const t = [];
		for (const r of e) isUnionType(r) ? t.push(...r.alternatives) : t.push(r);
		const validatorOf = e => {
		const r = t
		.filter(t => "never" !== resolveUnderlyingType(t, e).tag)
		.map(t => [t, findFields(t, e)]),
		n = r.filter(e => 0 !== e[1].length),
		s = r.filter(e => 0 === e[1].length),
		a = (e => {
		const t = (e => {
		const t = new Set(e[0]);
		for (const r of e) for (const e of t) r.has(e) \|\| t.delete(e);
		return t;
		})(e.map(([, e]) => new Set(e.map(([e]) => e)))),
		r = new Map(["type", "kind", "tag", "version"].map(e => [e, new Map()]));
		for (const [s, a] of e)
		for (const [e, o] of a)
		if ("tag" in (n = o) && "literal" === n.tag) {
		const n = mapGet(r)(e, () => new Map());
		n.has(o.value) ? t.delete(e) : n.set(o.value, s);
		} else t.delete(e);
		var n;
		for (const [e, n] of r) if (t.has(e)) return [e, n];
		})(n);
		if (a && s.length) {
		const e = a && validateWithKey(a[0], a[1]),
		t = validateWithoutKey(s.map(e => e[0]));
		return (r, n) => {
		const s = e(r, n);
		if (s.success) return s;
		const a = t(r, n);
		return (
		a.success \|\|
		a.fullError.push(andError(s.fullError ? s.fullError : unableToAssign(r, "Object"))),
		a
		);
		};
		}
		return a ? validateWithKey(a[0], a[1]) : validateWithoutKey(t);
		},
		r = lazyValue(() => ({ p: validatorOf("p"), s: validatorOf("s"), t: validatorOf("t") })),
		n = create(
		"union",
		{
		p: (e, t) => r().p(e, t),
		s: (e, t) => r().s(e, t),
		t(e, t) {
		const n = r().s(e, (e, r) => t(e, r) \|\| success(r));
		return n.success ? void 0 : n;
		},
		},
		{
		alternatives: t,
		match: (...t) => r => {
		const s = createVisitedState();
		for (let n = 0; n < e.length; n++) {
		const a = innerValidate(e[n], r, s);
		if (a.success) return t[n](a.value);
		}
		n.assert(r);
		},
		show(e) {
		return parenthesize("" + t.map(e => show(e, !0)).join(" \| "), e);
		},
		},
		);
		return n;
		}
		Object.defineProperty(exports, "__esModule", { value: !0 });
		const parenthesize = (e, t) => (t ? `(${e})` : e),
		e = new Set(),
		show = (t, r = !1) => {
		if (e.has(t) && "lazy" !== t.tag) return parenthesize("CIRCULAR " + t.tag, r);
		if (t.show) {
		e.add(t);
		try {
		return t.show(r);
		} finally {
		e.delete(t);
		}
		}
		return t.tag;
		},
		t = "__internal_runtype_methods__";
		class ValidationError extends Error {
		constructor(e) {
		super(showError(e)),
		(this.name = "ValidationError"),
		(this.shortMessage = e.message),
		(this.key = e.key),
		(this.fullError = e.fullError);
		}
		}
		const r = create("unknown", e => success(e), {}),
		n = Literal(void 0),
		s = Literal(null),
		a = create("never", e => expected("nothing", e), {}),
		o = createPrimative("boolean"),
		i = createPrimative("function"),
		l = createPrimative("number"),
		u = createPrimative("string"),
		c = createPrimative("symbol");
		(exports.Array = e => InternalArr(e, !1)),
		(exports.AsyncContract = (e, t) => ({
		enforce: r => (...n) => {
		if (n.length < e.length)
		return Promise.reject(
		new ValidationError({
		message: `Expected ${e.length} arguments but only received ${n.length}`,
		}),
		);
		const s = createVisitedState();
		for (let t = 0; t < e.length; t++) {
		const r = innerValidate(e[t], n[t], s);
		if (!r.success) return Promise.reject(new ValidationError(r));
		n[t] = r.value;
		}
		const a = r(...n);
		return a instanceof Promise
		? a.then(e => {
		const r = innerGuard(t, e, createGuardVisitedState());
		if (r) throw new ValidationError(r);
		return e;
		})
		: Promise.reject(
		new ValidationError({
		message: "Expected function to return a promise, but instead got " + a,
		}),
		);
		},
		})),
		(exports.Boolean = o),
		(exports.Brand = Brand),
		(exports.Constraint = Constraint),
		(exports.Contract = (e, t) => ({
		enforce: r => (...n) => {
		if (n.length < e.length)
		throw new ValidationError({
		message: `Expected ${e.length} arguments but only received ${n.length}`,
		});
		const s = createVisitedState();
		for (let t = 0; t < e.length; t++) {
		const r = innerValidate(e[t], n[t], s);
		if (!r.success) throw new ValidationError(r);
		n[t] = r.value;
		}
		const a = r(...n),
		o = innerGuard(t, a, createGuardVisitedState());
		if (o) throw new ValidationError(o);
		return a;
		},
		})),
		(exports.Enum = (e, t) => {
		const r = Object.values(t),
		n = new Set(r.some(e => "number" == typeof e) ? r.filter(e => "number" == typeof e) : r);
		return create("enum", t => (n.has(t) ? success(t) : expected(e, t)), {
		enumObject: t,
		show: () => e,
		});
		}),
		(exports.Function = i),
		(exports.Guard = (e, t) => r.withGuard(e, t)),
		(exports.InstanceOf = e =>
		create("instanceof", t => (t instanceof e ? success(t) : expected("" + e.name, t)), {
		ctor: e,
		show() {
		return `InstanceOf<${e.name}>`;
		},
		})),
		(exports.Intersect = Intersect),
		(exports.KeyOf = e => {
		const t = new Set(Object.keys(e)),
		r = [...t]
		.sort()
		.map(e => showValue(e))
		.join(" \| ");
		return create(
		"keyOf",
		e => (t.has("number" == typeof e ? e.toString() : e) ? success(e) : expected(r, e)),
		{ keys: t, show: e => parenthesize(r, e) },
		);
		}),
		(exports.Lazy = e => {
		const t = lazyValue(e);
		return create("lazy", (e, r, n) => n(t(), e), {
		underlying: t,
		show(e) {
		return show(t(), e);
		},
		});
		}),
		(exports.Literal = Literal),
		(exports.Named = (e, t) => (
		assertRuntype(t),
		create("named", (e, r) => r(t, e), {
		underlying: t,
		name: e,
		show() {
		return e;
		},
		})
		)),
		(exports.Never = a),
		(exports.Null = s),
		(exports.Number = l),
		(exports.Object = e => InternalObject(e, !1, !1)),
		(exports.ParsedValue = ParsedValue),
		(exports.Partial = e => InternalObject(e, !0, !1)),
		(exports.Readonly = function Readonly(e) {
		const t = { ...e };
		t.isReadonly = !0;
		for (const r of ["asPartial", "pick", "omit"])
		"function" == typeof e[r] && (t[r] = (...t) => Readonly(e[r](...t)));
		return t;
		}),
		(exports.ReadonlyArray = e => InternalArr(e, !0)),
		(exports.Record = (e, t) => {
		assertRuntype(e, t);
		const r = lazyValue(() => getExpectedBaseType(e)),
		n = create(
		"record",
		(s, a) =>
		null == s \|\| "object" != typeof s
		? expected(n, s)
		: Object.getPrototypeOf(s) !== Object.prototype && null !== Object.getPrototypeOf(s)
		? Array.isArray(s)
		? failure("Expected Record, but was Array")
		: failure(`Expected ${show(n)}, but was ${Object.getPrototypeOf(s)}`)
		: createValidationPlaceholder(Object.create(null), n => {
		for (const o in s) {
		let i = null;
		if ("number" === r()) {
		if (isNaN(+o)) return expected("record key to be a number", o);
		i = a(e, +o);
		} else
		"string" === r()
		? (i = a(e, o))
		: ((i = a(e, o)), i.success \|\| isNaN(+o) \|\| (i = a(e, +o)));
		if (!i.success) return expected("record key to be " + show(e), o);
		const l = a(t, s[o]);
		if (!l.success) return failure(l.message, { key: l.key ? `${o}.${l.key}` : o });
		n[i.value] = l.value;
		}
		}),
		{
		key: e,
		value: t,
		isReadonly: !1,
		show() {
		return `{ [_: ${show(e, !1)}]: ${show(t, !1)} }`;
		},
		},
		);
		return n;
		}),
		(exports.String = u),
		(exports.Symbol = c),
		(exports.Tuple = (...e) => {
		assertRuntype(...e);
		const t = create(
		"tuple",
		(r, n) =>
		Array.isArray(r)
		? r.length !== e.length
		? expected("an array of length " + e.length, r.length)
		: createValidationPlaceholder([...r], s => {
		let a,
		o = void 0;
		for (let i = 0; i < e.length; i++) {
		let l = n(e[i], r[i]);
		l.success
		? (s[i] = l.value)
		: (o \|\| (o = unableToAssign(r, t)),
		o.push(typesAreNotCompatible(`[${i}]`, l)),
		(a =
		a \|\|
		failure(l.message, {
		key: l.key ? `[${i}].${l.key}` : `[${i}]`,
		fullError: o,
		})));
		}
		return a;
		})
		: expected("tuple to be an array", r),
		{
		components: e,
		isReadonly: !1,
		show() {
		return `[${e.map(e => show(e, !1)).join(", ")}]`;
		},
		},
		);
		return t;
		}),
		(exports.Undefined = n),
		(exports.Union = Union),
		(exports.Unknown = r),
		(exports.ValidationError = ValidationError),
		(exports.assertType = (e, t) => {
		e.assert(t);
		}),
		(exports.showError = showError),
		(exports.showType = show),
		(exports.showValue = showValue);
		var e = require("./chunk-dd209c8b.js");
		(exports.Array = e.Arr),
		(exports.AsyncContract = e.AsyncContract),
		(exports.Boolean = e.Boolean),
		(exports.Brand = e.Brand),
		(exports.Constraint = e.Constraint),
		(exports.Contract = e.Contract),
		(exports.Enum = e.Enum),
		(exports.Function = e.Function),
		(exports.Guard = e.Guard),
		(exports.InstanceOf = e.InstanceOf),
		(exports.Intersect = e.Intersect),
		(exports.KeyOf = e.KeyOf),
		(exports.Lazy = e.Lazy),
		(exports.Literal = e.Literal),
		(exports.Mutable = e.Mutable),
		(exports.MutableArray = e.Arr),
		(exports.MutableObject = e.Obj),
		(exports.MutablePartial = e.Partial),
		(exports.MutableRecord = e.Record),
		(exports.MutableTuple = e.Tuple),
		(exports.Named = e.Named),
		(exports.Never = e.Never),
		(exports.Null = e.Null),
		(exports.Number = e.Number),
		(exports.Object = e.Obj),
		(exports.ParsedValue = e.ParsedValue),
		(exports.Partial = e.Partial),
		(exports.Readonly = e.Readonly),
		(exports.ReadonlyArray = e.ReadonlyArray),
		(exports.ReadonlyObject = e.ReadonlyObject),
		(exports.ReadonlyPartial = e.ReadonlyPartial),
		(exports.ReadonlyRecord = e.ReadonlyRecord),
		(exports.ReadonlyTuple = e.ReadonlyTuple),
		(exports.Record = e.Record),
		(exports.Sealed = e.Sealed),
		(exports.String = e.String),
		(exports.Symbol = e.Sym),
		(exports.Tuple = e.Tuple),
		(exports.Undefined = e.Undefined),
		(exports.Union = e.Union),
		(exports.Unknown = e.Unknown),
		(exports.ValidationError = e.ValidationError),
		(exports.assertType = e.assertType),
		(exports.showError = e.showError),
		(exports.showType = e.show),
		(exports.showValue = e.showValue);

71

lib/runtype.d.ts

		@@ -1,3 +0,12 @@
		import { Result, Union, Intersect, Constraint, ConstraintCheck, Brand, Failure } from './index';
		import { ParsedValue, ParsedValueConfig } from './types/ParsedValue';
		import type * as t from '.';
		import type { Result, Failure } from './result';
		import { ParsedValueConfig } from './types/ParsedValue';
		interface Helpers {
		readonly Union: typeof t.Union;
		readonly Intersect: typeof t.Intersect;
		readonly Constraint: typeof t.Constraint;
		readonly Brand: typeof t.Brand;
		readonly ParsedValue: typeof t.ParsedValue;
		}
		export declare function provideHelpers(h: Helpers): void;
		export declare type InnerValidateHelper = <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>;
		@@ -11,6 +20,29 @@ declare const internalSymbol: unique symbol;
		}) \| Cycle<T>;
		export declare type SealedState = {
		readonly keysFromIntersect?: ReadonlySet<string>;
		readonly deep: boolean;
		} \| false;
		export interface InternalValidation<TParsed> {
		p(x: any, innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>, innerValidateToPlaceholder: <T>(runtype: RuntypeBase<T>, value: unknown) => ResultWithCycle<T>): ResultWithCycle<TParsed>;
		t?: (x: any, innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Failure \| undefined) => Failure \| undefined;
		s?: (x: any, innerSerialize: (runtype: RuntypeBase, value: unknown) => Result<any>, innerSerializeToPlaceholder: (runtype: RuntypeBase, value: unknown) => ResultWithCycle<any>) => ResultWithCycle<any>;
		/**
		* parse
		*/
		p(x: any, innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown, sealed?: SealedState) => Result<T>, innerValidateToPlaceholder: <T>(runtype: RuntypeBase<T>, value: unknown, sealed?: SealedState) => ResultWithCycle<T>, mode: 'p' \| 's' \| 't', sealed: SealedState): ResultWithCycle<TParsed>;
		/**
		* test
		*/
		t?: (x: any, innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown, sealed?: SealedState) => Failure \| undefined, sealed: SealedState) => Failure \| undefined;
		/**
		* serialize
		*/
		s?: (x: any, innerSerialize: (runtype: RuntypeBase, value: unknown, sealed?: SealedState) => Result<any>, innerSerializeToPlaceholder: (runtype: RuntypeBase, value: unknown, sealed?: SealedState) => ResultWithCycle<any>, mode: 's', sealed: SealedState) => ResultWithCycle<any>;
		/**
		* get underlying type
		*/
		u?: (mode: 'p' \| 's' \| 't') => RuntypeBase \| undefined;
		/**
		* get fields, not called if "u" is implemented, can return
		* undefined to indicate that arbitrarily many fields are
		* possible.
		*/
		f?: (mode: 'p' \| 't' \| 's') => ReadonlySet<string> \| undefined;
		}
		@@ -61,7 +93,7 @@ /**
		*/
		Or<B extends RuntypeBase>(B: B): Union<[this, B]>;
		Or<B extends RuntypeBase>(B: B): t.Union<[this, B]>;
		/**
		* Intersect this Runtype with another.
		*/
		And<B extends RuntypeBase>(B: B): Intersect<[this, B]>;
		And<B extends RuntypeBase>(B: B): t.Intersect<[this, B]>;
		/**
		@@ -80,6 +112,6 @@ * Use an arbitrary constraint function to validate a runtype, and optionally
		*/
		withConstraint<T extends Static<this>, K = unknown>(constraint: ConstraintCheck<this>, options?: {
		withConstraint<T extends Static<this>, K = unknown>(constraint: t.ConstraintCheck<this>, options?: {
		name?: string;
		args?: K;
		}): Constraint<this, T, K>;
		}): t.Constraint<this, T, K>;
		/**
		@@ -103,11 +135,11 @@ * Helper function to convert an underlying Runtype into another static type
		args?: K;
		}): Constraint<this, T, K>;
		}): t.Constraint<this, T, K>;
		/**
		* Adds a brand to the type.
		*/
		withBrand<B extends string>(brand: B): Brand<B, this>;
		withBrand<B extends string>(brand: B): t.Brand<B, this>;
		/**
		* Apply conversion functions when parsing/serializing this value
		*/
		withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): ParsedValue<this, TParsed>;
		withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): t.ParsedValue<this, TParsed>;
		}
		@@ -146,2 +178,6 @@ export interface Codec<TParsed> extends Runtype<TParsed> {
		};
		/**
		* Get the underlying type of a runtype, if it is a wrapper around another type
		*/
		export declare function unwrapRuntype(t: RuntypeBase, mode: 'p' \| 's' \| 't'): RuntypeBase;
		export declare function createValidationPlaceholder<T>(placeholder: T, fn: (placeholder: T) => Failure \| undefined): Cycle<T>;
		@@ -155,5 +191,10 @@ export declare function mapValidationPlaceholder<T, S>(source: ResultWithCycle<T>, fn: (placeholder: T) => Result<S>, extraGuard?: RuntypeBase<S>): ResultWithCycle<S>;
		export declare function createGuardVisitedState(): OpaqueGuardVisitedState;
		export declare function innerValidate<T>(targetType: RuntypeBase<T>, value: any, $visited: OpaqueVisitedState): Result<T>;
		export declare function innerSerialize<T>(targetType: RuntypeBase<T>, value: any, $visited: OpaqueVisitedState): Result<T>;
		export declare function innerGuard(targetType: RuntypeBase, value: any, $visited: OpaqueGuardVisitedState): Failure \| undefined;
		export declare function innerValidate<T>(targetType: RuntypeBase<T>, value: any, $visited: OpaqueVisitedState, sealed: SealedState): Result<T>;
		export declare function innerSerialize<T>(targetType: RuntypeBase<T>, value: any, $visited: OpaqueVisitedState, sealed: SealedState): Result<T>;
		export declare function innerGuard(targetType: RuntypeBase, value: any, $visited: OpaqueGuardVisitedState, sealed: SealedState): Failure \| undefined;
		/**
		* Get the possible fields for a runtype
		* Returns "undefined" if there can be arbitrary fields (e.g. Record<string, number>)
		*/
		export declare function getFields(t: RuntypeBase, mode: 'p' \| 's' \| 't'): ReadonlySet<string> \| undefined;
		export {};

1

lib/types/brand.d.ts

		@@ -10,3 +10,2 @@ import { RuntypeBase, Static, Codec } from '../runtype';
		}
		export declare function isBrandRuntype(runtype: RuntypeBase): runtype is Brand<string, RuntypeBase>;
		export declare function Brand<B extends string, A extends RuntypeBase<unknown>>(brand: B, entity: A): Brand<B, A>;

1

lib/types/constraint.d.ts

		import { RuntypeBase, Static, Codec } from '../runtype';
		import { Unknown } from './unknown';
		export declare type ConstraintCheck<A extends RuntypeBase<unknown>> = (x: Static<A>) => boolean \| string;
		export declare function isConstraintRuntype(runtype: RuntypeBase): runtype is Constraint<RuntypeBase, unknown, unknown>;
		export interface Constraint<TUnderlying extends RuntypeBase<unknown>, TConstrained extends Static<TUnderlying> = Static<TUnderlying>, TArgs = unknown> extends Codec<TConstrained> {
		@@ -6,0 +5,0 @@ readonly tag: 'constraint';

1

lib/types/lazy.d.ts

		@@ -7,3 +7,2 @@ import { RuntypeBase, Codec, Static } from '../runtype';
		export declare function lazyValue<T>(fn: () => T): () => T;
		export declare function isLazyRuntype(runtype: RuntypeBase): runtype is Lazy<RuntypeBase>;
		/**
		@@ -10,0 +9,0 @@ * Construct a possibly-recursive Runtype.

1

lib/types/Named.d.ts

		import { RuntypeBase, Static, Codec } from '../runtype';
		export declare type ConstraintCheck<A extends RuntypeBase<unknown>> = (x: Static<A>) => boolean \| string;
		export declare function isNamedRuntype(runtype: RuntypeBase): runtype is Named<RuntypeBase>;
		export interface Named<TUnderlying extends RuntypeBase<unknown>> extends Codec<Static<TUnderlying>> {
		@@ -5,0 +4,0 @@ readonly tag: 'named';

2

lib/types/Object.d.ts

		@@ -33,2 +33,4 @@ import { Static, RuntypeBase, Codec } from '../runtype';
		declare function Obj<O extends RecordFields>(fields: O): Obj<O, false>;
		export declare function ReadonlyObject<O extends RecordFields>(fields: O): Obj<O, true>;
		export declare function Partial<O extends RecordFields>(fields: O): Partial<O, false>;
		export declare function ReadonlyPartial<O extends RecordFields>(fields: O): Partial<O, true>;

1

lib/types/ParsedValue.d.ts

		@@ -8,3 +8,2 @@ import { Result } from '../result';
		}
		export declare function isParsedValueRuntype(runtype: RuntypeBase): runtype is ParsedValue<RuntypeBase, unknown>;
		export interface ParsedValueConfig<TUnderlying extends RuntypeBase<unknown>, TParsed> {
		@@ -11,0 +10,0 @@ name?: string;

1

lib/types/Record.d.ts

		@@ -28,1 +28,2 @@ import { Static, RuntypeBase, Codec } from '../runtype';
		export declare function Record<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(key: K, value: V): Record<K, V>;
		export declare function ReadonlyRecord<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(key: K, value: V): ReadonlyRecord<K, V>;

1

lib/types/tuple.d.ts

		@@ -23,1 +23,2 @@ import { RuntypeBase, Codec } from '../runtype';
		export declare function Tuple<T extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]] \| readonly []>(...components: T): Tuple<T>;
		export declare function ReadonlyTuple<T extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]] \| readonly []>(...components: T): ReadonlyTuple<T>;

33

package.json

		{
		"name": "funtypes",
		"version": "4.2.0",
		"version": "5.0.0",
		"description": "Runtime validation for static types",
		@@ -9,2 +9,21 @@ "main": "./lib/index.js",
		"sideEffects": false,
		"exports": {
		"./readonly": {
		"types": "./lib/readonly.d.ts",
		"import": "./lib/readonly.mjs",
		"default": "./lib/readonly.js"
		},
		".": {
		"types": "./lib/index.d.ts",
		"import": "./lib/index.mjs",
		"default": "./lib/index.js"
		}
		},
		"typesVersions": {
		"*": {
		"readonly": [
		"lib/readonly.d.ts"
		]
		}
		},
		"scripts": {
		@@ -15,3 +34,2 @@ "postbuild": "tsc --noEmit && rimraf lib/*/.spec.*",
		"test": "jest $([ \"$CI\" = true ] && echo --coverage \|\| echo --watch)",
		"coveralls": "cat ./coverage/lcov.info \| ./node_modules/.bin/coveralls",
		"typecheck": "tsc --noEmit --watch"
		@@ -22,6 +40,5 @@ },
		"devDependencies": {
		"@types/jest": "24.0.18",
		"coveralls": "^3.0.6",
		"jest": "24.9.0",
		"prettier": "^2.1.1",
		"@types/jest": "^27.4.1",
		"jest": "^27.5.1",
		"prettier": "^2.6.0",
		"rollup": "^2.26.11",
		@@ -32,5 +49,5 @@ "rollup-plugin-prettier": "^2.1.0",
		"rollup-plugin-typescript2": "^0.27.2",
		"ts-jest": "^24.1.0",
		"ts-jest": "^27.1.3",
		"type-assertions": "^1.1.0",
		"typescript": "4.0.2"
		"typescript": "^4.6.2"
		},
		@@ -37,0 +54,0 @@ "keywords:": [

5

rollup.config.js

		@@ -10,3 +10,3 @@ import { sizeSnapshot } from 'rollup-plugin-size-snapshot';
		index: 'src/index.ts',
		// contracts: 'src/contracts.ts',
		readonly: 'src/readonly.ts',
		},
		@@ -17,2 +17,3 @@ output: [
		entryFileNames: '[name].js',
		chunkFileNames: 'chunk-[hash].js',
		format: 'cjs',
		@@ -23,3 +24,3 @@ },
		entryFileNames: '[name].mjs',
		chunkFileNames: '[name]-[hash].mjs',
		chunkFileNames: 'chunk-[hash].mjs',
		format: 'es',
		@@ -26,0 +27,0 @@ },

64

src/asynccontract.ts

		@@ -23,36 +23,38 @@ import { ValidationError } from './errors';
		return {
		enforce: (f: (...args: any[]) => any) => (...args: any[]) => {
		if (args.length < argTypes.length) {
		return Promise.reject(
		new ValidationError({
		message: `Expected ${argTypes.length} arguments but only received ${args.length}`,
		}),
		);
		}
		const visited: OpaqueVisitedState = createVisitedState();
		for (let i = 0; i < argTypes.length; i++) {
		const result = innerValidate(argTypes[i], args[i], visited);
		if (result.success) {
		args[i] = result.value;
		} else {
		return Promise.reject(new ValidationError(result));
		enforce:
		(f: (...args: any[]) => any) =>
		(...args: any[]) => {
		if (args.length < argTypes.length) {
		return Promise.reject(
		new ValidationError({
		message: `Expected ${argTypes.length} arguments but only received ${args.length}`,
		}),
		);
		}
		}
		const returnedPromise = f(...args);
		if (!(returnedPromise instanceof Promise)) {
		return Promise.reject(
		new ValidationError({
		message: `Expected function to return a promise, but instead got ${returnedPromise}`,
		}),
		);
		}
		return returnedPromise.then(value => {
		const result = innerGuard(returnType, value, createGuardVisitedState());
		if (result) {
		throw new ValidationError(result);
		const visited: OpaqueVisitedState = createVisitedState();
		for (let i = 0; i < argTypes.length; i++) {
		const result = innerValidate(argTypes[i], args[i], visited, false);
		if (result.success) {
		args[i] = result.value;
		} else {
		return Promise.reject(new ValidationError(result));
		}
		}
		return value;
		});
		},
		const returnedPromise = f(...args);
		if (!(returnedPromise instanceof Promise)) {
		return Promise.reject(
		new ValidationError({
		message: `Expected function to return a promise, but instead got ${returnedPromise}`,
		}),
		);
		}
		return returnedPromise.then(value => {
		const result = innerGuard(returnType, value, createGuardVisitedState(), false);
		if (result) {
		throw new ValidationError(result);
		}
		return value;
		});
		},
		};
		}

40

src/contract.ts

		@@ -23,24 +23,26 @@ import {
		return {
		enforce: (f: (...args: A) => Z) => (...args: A): Z => {
		if (args.length < argTypes.length)
		throw new ValidationError({
		message: `Expected ${argTypes.length} arguments but only received ${args.length}`,
		});
		const visited: OpaqueVisitedState = createVisitedState();
		for (let i = 0; i < argTypes.length; i++) {
		const result = innerValidate(argTypes[i], args[i], visited);
		if (result.success) {
		args[i] = result.value;
		} else {
		enforce:
		(f: (...args: A) => Z) =>
		(...args: A): Z => {
		if (args.length < argTypes.length)
		throw new ValidationError({
		message: `Expected ${argTypes.length} arguments but only received ${args.length}`,
		});
		const visited: OpaqueVisitedState = createVisitedState();
		for (let i = 0; i < argTypes.length; i++) {
		const result = innerValidate(argTypes[i], args[i], visited, false);
		if (result.success) {
		args[i] = result.value;
		} else {
		throw new ValidationError(result);
		}
		}
		const rawResult = f(...args);
		const result = innerGuard(returnType, rawResult, createGuardVisitedState(), false);
		if (result) {
		throw new ValidationError(result);
		}
		}
		const rawResult = f(...args);
		const result = innerGuard(returnType, rawResult, createGuardVisitedState());
		if (result) {
		throw new ValidationError(result);
		}
		return rawResult;
		},
		return rawResult;
		},
		};
		}

6

src/index.spec.ts

		@@ -63,3 +63,3 @@ import {
		);
		const leftHand: Hand = { left: (null as any) as Hand };
		const leftHand: Hand = { left: null as any as Hand };
		const rightHand: Hand = { right: leftHand };
		@@ -72,3 +72,3 @@ leftHand.left = rightHand;
		);
		const ambi: Ambi = { left: (null as any) as Ambi, right: (null as any) as Ambi };
		const ambi: Ambi = { left: null as any as Ambi, right: null as any as Ambi };
		ambi.left = ambi;
		@@ -844,3 +844,3 @@ ambi.right = ambi;
		fail('value passed validation even though it was not expected to');
		} catch (exception) {
		} catch (exception: any) {
		const { shortMessage: errorMessage, key: errorKey } = exception;
		@@ -847,0 +847,0 @@

36

src/index.ts

		@@ -0,1 +1,8 @@
		import { provideHelpers } from './runtype';
		import { Brand } from './types/brand';
		import { Constraint } from './types/constraint';
		import { Intersect } from './types/intersect';
		import { ParsedValue } from './types/ParsedValue';
		import { Union } from './types/union';

		export { AsyncContract } from './asynccontract';
		@@ -11,4 +18,18 @@ export { Contract } from './contract';

		export { Readonly } from './types/Readonly';
		export { Mutable } from './types/Mutable';

		export { Array, Array as MutableArray, ReadonlyArray } from './types/array';
		export {
		Object,
		Object as MutableObject,
		ReadonlyObject,
		Partial,
		Partial as MutablePartial,
		ReadonlyPartial,
		} from './types/Object';
		export { Record, Record as MutableRecord, ReadonlyRecord } from './types/Record';
		export { Tuple, Tuple as MutableTuple, ReadonlyTuple } from './types/tuple';

		// TODO: should we export StaticIntersect, StaticTuple, StaticUnion etc.
		export { Array, ReadonlyArray } from './types/array';
		export type { ConstraintCheck } from './types/constraint';
		@@ -25,7 +46,4 @@ export { Constraint, Guard } from './types/constraint';
		export { Never } from './types/never';
		export { Object, Partial } from './types/Object';
		export { Boolean, Function, Number, String, Symbol } from './types/primative';
		export { Readonly } from './types/Readonly';
		export { Record } from './types/Record';
		export { Tuple } from './types/tuple';
		export { Sealed } from './types/Sealed';
		export { Union } from './types/union';
		@@ -35,1 +53,9 @@ export { Unknown } from './types/unknown';
		export { ParsedValue } from './types/ParsedValue';

		provideHelpers({
		Union,
		Intersect,
		Constraint,
		Brand,
		ParsedValue,
		});

185

src/runtype.ts

		@@ -1,11 +0,32 @@
		import { Result, Union, Intersect, Constraint, ConstraintCheck, Brand, Failure } from './index';
		import type * as t from '.';
		// import { Union, Intersect, Constraint, ConstraintCheck, Brand, ParsedValue, ParsedValueConfig } from './index';
		import type { Result, Failure } from './result';
		import show from './show';
		import { ValidationError } from './errors';
		import { ParsedValue, ParsedValueConfig } from './types/ParsedValue';
		import { ParsedValueConfig } from './types/ParsedValue';
		import showValue from './showValue';
		import { failure, success } from './result';

		// let Union: typeof t.Union;
		// let Intersect: typeof t.Intersect;
		// let Constraint: typeof t.Constraint;
		// let Brand: typeof t.Brand;
		// let ParsedValue: typeof t.ParsedValue;
		// Importing these directly creates a cycle
		interface Helpers {
		readonly Union: typeof t.Union;
		readonly Intersect: typeof t.Intersect;
		readonly Constraint: typeof t.Constraint;
		readonly Brand: typeof t.Brand;
		readonly ParsedValue: typeof t.ParsedValue;
		}
		let helpers: Helpers;
		export function provideHelpers(h: Helpers) {
		helpers = h;
		}

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

		@@ -24,12 +45,36 @@ export function assertRuntype(...values: RuntypeBase[]) {
		export type ResultWithCycle<T> = (Result<T> & { cycle?: false }) \| Cycle<T>;

		export type SealedState =
		\| { readonly keysFromIntersect?: ReadonlySet<string>; readonly deep: boolean }
		\| false;
		export interface InternalValidation<TParsed> {
		/**
		* parse
		*/
		p(
		x: any,
		innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Result<T>,
		innerValidateToPlaceholder: <T>(runtype: RuntypeBase<T>, value: unknown) => ResultWithCycle<T>,
		innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown, sealed?: SealedState) => Result<T>,
		innerValidateToPlaceholder: <T>(
		runtype: RuntypeBase<T>,
		value: unknown,
		sealed?: SealedState,
		) => ResultWithCycle<T>,
		mode: 'p' \| 's' \| 't',
		sealed: SealedState,
		): ResultWithCycle<TParsed>;
		/**
		* test
		*/
		t?: (
		x: any,
		innerValidate: <T>(runtype: RuntypeBase<T>, value: unknown) => Failure \| undefined,
		innerValidate: <T>(
		runtype: RuntypeBase<T>,
		value: unknown,
		sealed?: SealedState,
		) => Failure \| undefined,
		sealed: SealedState,
		) => Failure \| undefined;
		/**
		* serialize
		*/
		s?: (
		@@ -39,6 +84,24 @@ // any is used here to ensure TypeScript still treats RuntypeBase as
		x: any,
		innerSerialize: (runtype: RuntypeBase, value: unknown) => Result<any>,
		innerSerializeToPlaceholder: (runtype: RuntypeBase, value: unknown) => ResultWithCycle<any>,
		innerSerialize: (runtype: RuntypeBase, value: unknown, sealed?: SealedState) => Result<any>,
		innerSerializeToPlaceholder: (
		runtype: RuntypeBase,
		value: unknown,
		sealed?: SealedState,
		) => ResultWithCycle<any>,
		mode: 's',
		sealed: SealedState,
		) => ResultWithCycle<any>;
		/**
		* get underlying type
		*/
		u?: (mode: 'p' \| 's' \| 't') => RuntypeBase \| undefined;

		/**
		* get fields, not called if "u" is implemented, can return
		* undefined to indicate that arbitrarily many fields are
		* possible.
		*/
		f?: (mode: 'p' \| 't' \| 's') => ReadonlySet<string> \| undefined;
		}

		/**
		@@ -95,3 +158,3 @@ * A runtype determines at runtime whether a value conforms to a type specification.
		*/
		Or<B extends RuntypeBase>(B: B): Union<[this, B]>;
		Or<B extends RuntypeBase>(B: B): t.Union<[this, B]>;

		@@ -101,3 +164,3 @@ /**
		*/
		And<B extends RuntypeBase>(B: B): Intersect<[this, B]>;
		And<B extends RuntypeBase>(B: B): t.Intersect<[this, B]>;

		@@ -118,5 +181,5 @@ /**
		withConstraint<T extends Static<this>, K = unknown>(
		constraint: ConstraintCheck<this>,
		constraint: t.ConstraintCheck<this>,
		options?: { name?: string; args?: K },
		): Constraint<this, T, K>;
		): t.Constraint<this, T, K>;

		@@ -141,3 +204,3 @@ /**
		options?: { name?: string; args?: K },
		): Constraint<this, T, K>;
		): t.Constraint<this, T, K>;

		@@ -147,3 +210,3 @@ /**
		*/
		withBrand<B extends string>(brand: B): Brand<B, this>;
		withBrand<B extends string>(brand: B): t.Brand<B, this>;

		@@ -153,3 +216,3 @@ /**
		*/
		withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): ParsedValue<this, TParsed>;
		withParser<TParsed>(value: ParsedValueConfig<this, TParsed>): t.ParsedValue<this, TParsed>;
		}
		@@ -210,3 +273,3 @@
		assert(x: any): asserts x is Static<TConfig> {
		const validated = innerGuard(A, x, createGuardVisitedState());
		const validated = innerGuard(A, x, createGuardVisitedState(), false);
		if (validated) {
		@@ -227,35 +290,34 @@ throw new ValidationError(validated);
		safeSerialize,
		Or: <B extends RuntypeBase>(B: B): Union<[Codec<Static<TConfig>>, B]> => Union(A, B),
		And: <B extends RuntypeBase>(B: B): Intersect<[Codec<Static<TConfig>>, B]> => Intersect(A, B),
		Or: <B extends RuntypeBase>(B: B): t.Union<[Codec<Static<TConfig>>, B]> => helpers.Union(A, B),
		And: <B extends RuntypeBase>(B: B): t.Intersect<[Codec<Static<TConfig>>, B]> =>
		helpers.Intersect(A, B),
		withConstraint: <T extends Static<TConfig>, K = unknown>(
		constraint: ConstraintCheck<Codec<Static<TConfig>>>,
		constraint: t.ConstraintCheck<Codec<Static<TConfig>>>,
		options?: { name?: string; args?: K },
		): Constraint<Codec<Static<TConfig>>, T, K> =>
		Constraint<Codec<Static<TConfig>>, T, K>(A, constraint, options),
		): t.Constraint<Codec<Static<TConfig>>, T, K> =>
		helpers.Constraint<Codec<Static<TConfig>>, T, K>(A, constraint, options),
		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> =>
		Constraint<Codec<Static<TConfig>>, T, K>(A, test, options),
		withBrand: <B extends string>(B: B): Brand<B, Codec<Static<TConfig>>> =>
		Brand<B, Codec<Static<TConfig>>>(B, A),
		): t.Constraint<Codec<Static<TConfig>>, T, K> =>
		helpers.Constraint<Codec<Static<TConfig>>, T, K>(A, test, options),
		withBrand: <B extends string>(B: B): t.Brand<B, Codec<Static<TConfig>>> =>
		helpers.Brand<B, Codec<Static<TConfig>>>(B, A),
		withParser: <TParsed>(
		config: ParsedValueConfig<Codec<Static<TConfig>>, TParsed>,
		): ParsedValue<Codec<Static<TConfig>>, TParsed> => ParsedValue(A as any, config),
		): t.ParsedValue<Codec<Static<TConfig>>, TParsed> => helpers.ParsedValue(A as any, config),
		toString: () => `Runtype<${show(A)}>`,
		[internal]:
		typeof internalImplementation === 'function'
		? {
		p: internalImplementation,
		}
		? { p: internalImplementation }
		: internalImplementation,
		};

		return (A as unknown) as TConfig;
		return A as unknown as TConfig;

		function safeParse(x: any) {
		return innerValidate(A, x, createVisitedState());
		return innerValidate(A, x, createVisitedState(), false);
		}
		function safeSerialize(x: any) {
		return innerSerialize(A, x, createVisitedState());
		return innerSerialize(A, x, createVisitedState(), false);
		}
		@@ -271,3 +333,3 @@ function parse(x: any) {
		function test(x: any): x is Static<TConfig> {
		const validated = innerGuard(A, x, createGuardVisitedState());
		const validated = innerGuard(A, x, createGuardVisitedState(), false);
		return validated === undefined;
		@@ -312,2 +374,14 @@ }

		/**
		* Get the underlying type of a runtype, if it is a wrapper around another type
		*/
		export function unwrapRuntype(t: RuntypeBase, mode: 'p' \| 's' \| 't'): RuntypeBase {
		const i = t[internal];
		const unwrapped = i.u ? i.u(mode) : undefined;
		if (unwrapped && unwrapped !== t) {
		return unwrapRuntype(unwrapped, mode);
		}
		return t;
		}

		export function createValidationPlaceholder<T>(
		@@ -331,3 +405,3 @@ placeholder: T,
		extraGuard &&
		innerGuard(extraGuard, result.value, createGuardVisitedState())) \|\|
		innerGuard(extraGuard, result.value, createGuardVisitedState(), false)) \|\|
		result
		@@ -372,7 +446,7 @@ );
		extraGuard &&
		innerGuard(extraGuard, unwrapResult.value, createGuardVisitedState());
		innerGuard(extraGuard, unwrapResult.value, createGuardVisitedState(), false);
		cache = guardFailure \|\| unwrapResult;
		} else {
		const guardFailure =
		extraGuard && innerGuard(extraGuard, result.value, createGuardVisitedState());
		extraGuard && innerGuard(extraGuard, result.value, createGuardVisitedState(), false);
		cache = guardFailure \|\| result;
		@@ -425,4 +499,5 @@ }
		$visited: OpaqueVisitedState,
		sealed: SealedState,
		): Result<T> {
		const result = innerValidateToPlaceholder(targetType, value, $visited);
		const result = innerValidateToPlaceholder(targetType, value, $visited, sealed);
		if (result.cycle) {
		@@ -438,2 +513,3 @@ return result.unwrap();
		$visited: OpaqueVisitedState,
		sealed: SealedState,
		): ResultWithCycle<T> {
		@@ -448,4 +524,6 @@ const visited = unwrapVisitedState($visited);
		value,
		(t, v) => innerValidate(t, v, $visited),
		(t, v) => innerValidateToPlaceholder(t, v, $visited),
		(t, v, s) => innerValidate(t, v, $visited, s ?? sealed),
		(t, v, s) => innerValidateToPlaceholder(t, v, $visited, s ?? sealed),
		'p',
		sealed,
		);
		@@ -463,4 +541,5 @@ if (result.cycle) {
		$visited: OpaqueVisitedState,
		sealed: SealedState,
		): Result<T> {
		const result = innerSerializeToPlaceholder(targetType, value, $visited);
		const result = innerSerializeToPlaceholder(targetType, value, $visited, sealed);
		if (result.cycle) {
		@@ -475,2 +554,3 @@ return result.unwrap();
		$visited: OpaqueVisitedState,
		sealed: SealedState,
		): ResultWithCycle<any> {
		@@ -485,4 +565,6 @@ const visited = unwrapVisitedState($visited);
		value,
		(t, v) => innerSerialize(t, v, $visited),
		(t, v) => innerSerializeToPlaceholder(t, v, $visited),
		(t, v, s) => innerSerialize(t, v, $visited, s ?? sealed),
		(t, v, s) => innerSerializeToPlaceholder(t, v, $visited, s ?? sealed),
		's',
		sealed,
		);
		@@ -500,2 +582,3 @@ if (result.cycle) {
		$visited: OpaqueGuardVisitedState,
		sealed: SealedState,
		): Failure \| undefined {
		@@ -510,8 +593,10 @@ const visited = unwrapGuardVisitedState($visited);
		if (validator.t) {
		return validator.t(value, (t, v) => innerGuard(t, v, $visited));
		return validator.t(value, (t, v, s) => innerGuard(t, v, $visited, s ?? sealed), sealed);
		}
		let result = validator.p(
		value,
		(t, v) => innerGuard(t, v, $visited) \|\| success(v as any),
		(t, v) => innerGuard(t, v, $visited) \|\| success(v as any),
		(t, v, s) => innerGuard(t, v, $visited, s ?? sealed) \|\| success(v as any),
		(t, v, s) => innerGuard(t, v, $visited, s ?? sealed) \|\| success(v as any),
		't',
		sealed,
		);
		@@ -522,1 +607,11 @@ if (result.cycle) result = result.unwrap();
		}

		/**
		* Get the possible fields for a runtype
		* Returns "undefined" if there can be arbitrary fields (e.g. Record<string, number>)
		*/
		export function getFields(t: RuntypeBase, mode: 'p' \| 's' \| 't'): ReadonlySet<string> \| undefined {
		const b = unwrapRuntype(t, mode);
		const i = b[internal];
		return i.f ? i.f(mode) : undefined;
		}

8

src/types/array.ts

		@@ -44,3 +44,3 @@ import {
		'array',
		(xs, innerValidate) => {
		(xs, innerValidate, _innerValidateToPlaceholder, _getFields, sealed) => {
		if (!Array.isArray(xs)) {
		@@ -54,3 +54,7 @@ return expected('an Array', xs);
		for (let i = 0; i < xs.length; i++) {
		const validated = innerValidate(element, xs[i]);
		const validated = innerValidate(
		element,
		xs[i],
		sealed && sealed.deep ? { deep: true } : false,
		);
		if (!validated.success) {
		@@ -57,0 +61,0 @@ if (!fullError) {

11

src/types/brand.ts

		@@ -17,6 +17,2 @@ import { RuntypeBase, Static, create, Codec, assertRuntype } from '../runtype';

		export function isBrandRuntype(runtype: RuntypeBase): runtype is Brand<string, RuntypeBase> {
		return 'tag' in runtype && (runtype as Brand<string, RuntypeBase>).tag === 'brand';
		}

		export function Brand<B extends string, A extends RuntypeBase<unknown>>(brand: B, entity: A) {
		@@ -26,5 +22,8 @@ assertRuntype(entity);
		'brand',
		(value, _innerValidate, innerValidateToPlaceholder) =>
		innerValidateToPlaceholder(entity, value) as any,
		{
		p: (value, _innerValidate, innerValidateToPlaceholder) =>
		innerValidateToPlaceholder(entity, value) as any,
		u: () => entity,
		},
		{
		brand,
		@@ -31,0 +30,0 @@ entity,

49

src/types/constraint.ts

		@@ -9,14 +9,6 @@ import { failure, success, unableToAssign } from '../result';

		export function isConstraintRuntype(
		runtype: RuntypeBase,
		): runtype is Constraint<RuntypeBase, unknown, unknown> {
		return (
		'tag' in runtype && (runtype as Constraint<RuntypeBase, unknown, unknown>).tag === 'constraint'
		);
		}

		export interface Constraint<
		TUnderlying extends RuntypeBase<unknown>,
		TConstrained extends Static<TUnderlying> = Static<TUnderlying>,
		TArgs = unknown
		TArgs = unknown,
		> extends Codec<TConstrained> {
		@@ -35,3 +27,3 @@ readonly tag: 'constraint';
		TConstrained extends Static<TUnderlying> = Static<TUnderlying>,
		TArgs = unknown
		TArgs = unknown,
		>(
		@@ -47,21 +39,24 @@ underlying: TUnderlying,
		'constraint',
		(value, innerValidate) => {
		const name = options && options.name;
		const validated = innerValidate(underlying, value);
		{
		p(value, innerValidate) {
		const name = options && options.name;
		const validated = innerValidate(underlying, value);

		if (!validated.success) {
		return validated;
		}
		if (!validated.success) {
		return validated;
		}

		const result = constraint(validated.value as any);
		if (!result \|\| typeof result === 'string') {
		const message =
		typeof result === 'string'
		? result
		: `${showValue(value)} failed ${name \|\| 'constraint'} check`;
		return failure(message, {
		fullError: unableToAssign(value, runtype, message),
		});
		}
		return success(validated.value as TConstrained);
		const result = constraint(validated.value as any);
		if (!result \|\| typeof result === 'string') {
		const message =
		typeof result === 'string'
		? result
		: `${showValue(value)} failed ${name \|\| 'constraint'} check`;
		return failure(message, {
		fullError: unableToAssign(value, runtype, message),
		});
		}
		return success(validated.value as TConstrained);
		},
		u: () => underlying,
		},
		@@ -68,0 +63,0 @@ {

134

src/types/intersect.ts

		@@ -9,4 +9,7 @@ import { failure, success } from '../result';
		assertRuntype,
		SealedState,
		getFields,
		} from '../runtype';
		import show, { parenthesize } from '../show';
		import { lazyValue } from './lazy';

		@@ -24,3 +27,3 @@ // We use the fact that a union of functions is effectively an intersection of parameters
		export interface Intersect<
		TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
		TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]],
		> extends Codec<StaticIntersect<TIntersectees>> {
		@@ -43,52 +46,99 @@ readonly tag: 'intersect';
		export function Intersect<
		TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
		TIntersectees extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]],
		>(...intersectees: TIntersectees): Intersect<TIntersectees> {
		assertRuntype(...intersectees);
		const allFieldInfoForMode = (mode: 'p' \| 't' \| 's') => {
		const intresecteesWithOwnFields = intersectees.map(intersectee => ({
		i: intersectee,
		f: getFields(intersectee, mode),
		}));
		const intersecteesWithOtherFields = new Map(
		intersectees.map(intersectee => {
		const allFields = new Set<string>();
		for (const { i, f: fields } of intresecteesWithOwnFields) {
		if (i !== intersectee) {
		if (fields === undefined) return [intersectee, undefined] as const;
		for (const field of fields) {
		allFields.add(field);
		}
		}
		}
		return [intersectee, allFields] as const;
		}),
		);

		const allFields = new Set<string>();
		for (const { f: fields } of intresecteesWithOwnFields) {
		if (fields === undefined) return { intersecteesWithOtherFields, allFields: undefined };
		for (const field of fields) {
		allFields.add(field);
		}
		}
		return { intersecteesWithOtherFields, allFields };
		};
		// use lazy value here so that:
		// 1. If this is never used in a `Sealed` context, we can skip evaluating it
		// 2. Circular references using `Lazy` don't break.
		const allFieldInfo = {
		p: lazyValue(() => allFieldInfoForMode(`p`)),
		t: lazyValue(() => allFieldInfoForMode(`t`)),
		s: lazyValue(() => allFieldInfoForMode(`s`)),
		};
		return create<Intersect<TIntersectees>>(
		'intersect',
		(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;
		{
		p: (value, innerValidate, _innerValidateToPlaceholder, mode, sealed) => {
		const getSealed = sealed
		? (targetType: RuntypeBase): SealedState => {
		const i = allFieldInfo[mode]().intersecteesWithOtherFields.get(targetType);
		if (i === undefined) return false;
		else return { keysFromIntersect: i, deep: sealed.deep };
		}
		if (!Array.isArray(validated.value)) {
		return failure(
		`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`,
		);
		: (_i: RuntypeBase): SealedState => false;
		if (Array.isArray(value)) {
		return createValidationPlaceholder<any>([...value], placeholder => {
		for (const targetType of intersectees) {
		let validated = innerValidate(targetType, placeholder, getSealed(targetType));
		if (!validated.success) {
		return validated;
		}
		if (!Array.isArray(validated.value)) {
		return failure(
		`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);
		}
		placeholder.splice(0, placeholder.length, ...validated.value);
		}
		});
		} else if (value && typeof value === 'object') {
		return createValidationPlaceholder<any>(Object.create(null), placeholder => {
		for (const targetType of intersectees) {
		let validated = innerValidate(targetType, value);
		if (!validated.success) {
		return validated;
		});
		} else if (value && typeof value === 'object') {
		return createValidationPlaceholder<any>(Object.create(null), placeholder => {
		for (const targetType of intersectees) {
		let validated = innerValidate(targetType, value, getSealed(targetType));
		if (!validated.success) {
		return validated;
		}
		if (!(validated.value && typeof validated.value === 'object')) {
		return failure(
		`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);
		}
		if (!(validated.value && typeof validated.value === 'object')) {
		return failure(
		`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, getSealed(targetType));
		if (!validated.success) {
		return validated;
		}
		});
		}
		let result = value;
		for (const targetType of intersectees) {
		let validated = innerValidate(targetType, result);
		if (!validated.success) {
		return validated;
		result = validated.value;
		}
		result = validated.value;
		}
		return success(result);
		return success(result);
		},
		f: mode => allFieldInfo[mode]().allFields,
		},
		@@ -95,0 +145,0 @@ {

11

src/types/lazy.ts

		@@ -16,6 +16,2 @@ import { create, RuntypeBase, Codec, Static } from '../runtype';

		export function isLazyRuntype(runtype: RuntypeBase): runtype is Lazy<RuntypeBase> {
		return 'tag' in runtype && (runtype as Lazy<RuntypeBase<unknown>>).tag === 'lazy';
		}

		/**
		@@ -31,5 +27,8 @@ * Construct a possibly-recursive Runtype.
		'lazy',
		(value, _innerValidate, innerValidateToPlaceholder) =>
		innerValidateToPlaceholder(underlying(), value) as any,
		{
		p: (value, _innerValidate, innerValidateToPlaceholder) =>
		innerValidateToPlaceholder(underlying(), value) as any,
		u: underlying,
		},
		{
		underlying,
		@@ -36,0 +35,0 @@ show(needsParens) {

11

src/types/Named.ts

		@@ -5,6 +5,2 @@ import { RuntypeBase, Static, create, Codec, assertRuntype } from '../runtype';

		export function isNamedRuntype(runtype: RuntypeBase): runtype is Named<RuntypeBase> {
		return 'tag' in runtype && (runtype as Named<RuntypeBase>).tag === 'named';
		}

		export interface Named<TUnderlying extends RuntypeBase<unknown>>
		@@ -24,4 +20,7 @@ extends Codec<Static<TUnderlying>> {
		'named',
		(value, innerValidate) => {
		return innerValidate(underlying as any, value);
		{
		p: (value, _innerValidate, innerValidateToPlaceholder) => {
		return innerValidateToPlaceholder(underlying as any, value);
		},
		u: () => underlying,
		},
		@@ -28,0 +27,0 @@ {

6

src/types/never.ts

		@@ -11,2 +11,6 @@ import { expected } from '../result';
		*/
		export const Never: Never = create('never', value => expected('nothing', value), {}) as any;
		export const Never: Never = create(
		'never',
		{ p: value => expected('nothing', value), f: () => new Set() },
		{},
		) as any;

24

src/types/Object.spec.ts

		@@ -1,2 +0,3 @@
		import { Object as ObjectType, String } from '..';
		import { Object as ObjectType, showType, String } from '..';
		import { ReadonlyPartial } from './Object';

		@@ -64,1 +65,22 @@ test('pick', () => {
		});

		test('ReadonlyPartial', () => {
		const CrewMember = ReadonlyPartial({
		name: String,
		rank: String,
		home: String,
		});

		expect(showType(CrewMember)).toMatchInlineSnapshot(
		`"{ readonly name?: string; readonly rank?: string; readonly home?: string; }"`,
		);
		expect(CrewMember.safeParse({ name: 'my name', home: 'my home' })).toMatchInlineSnapshot(`
		Object {
		"success": true,
		"value": Object {
		"home": "my home",
		"name": "my name",
		},
		}
		`);
		});

94

src/types/Object.ts

		@@ -18,3 +18,3 @@ import {
		IsPartial extends boolean,
		IsReadonly extends boolean
		IsReadonly extends boolean,
		> = IsPartial extends false
		@@ -31,3 +31,3 @@ ? IsReadonly extends false
		IsPartial extends boolean,
		IsReadonly extends boolean
		IsReadonly extends boolean,
		> extends Codec<RecordStaticType<O, IsPartial, IsReadonly>> {
		@@ -74,37 +74,62 @@ readonly tag: 'object';
		assertRuntype(...Object.values(fields));
		const fieldNames: ReadonlySet<string> = new Set(Object.keys(fields));
		const runtype: InternalRecord<O, Part, RO> = create<InternalRecord<O, Part, RO>>(
		'object',
		(x, innerValidate) => {
		if (x === null \|\| x === undefined \|\| typeof x !== 'object') {
		return expected(runtype, x);
		}
		if (Array.isArray(x)) {
		return failure(`Expected ${show(runtype)}, but was an Array`);
		}
		{
		p: (x, innerValidate, _innerValidateToPlaceholder, _getFields, sealed) => {
		if (x === null \|\| x === undefined \|\| typeof x !== 'object') {
		return expected(runtype, x);
		}
		if (Array.isArray(x)) {
		return failure(`Expected ${show(runtype)}, but was an Array`);
		}

		return createValidationPlaceholder(Object.create(null), (placeholder: any) => {
		let fullError: FullError \| undefined = undefined;
		let firstError: Failure \| undefined;
		for (const key in fields) {
		if (!isPartial \|\| (hasKey(key, x) && x[key] !== undefined)) {
		const value = isPartial \|\| hasKey(key, x) ? x[key] : undefined;
		let validated = innerValidate(fields[key], value);
		if (!validated.success) {
		if (!fullError) {
		fullError = unableToAssign(x, runtype);
		return createValidationPlaceholder(Object.create(null), (placeholder: any) => {
		let fullError: FullError \| undefined = undefined;
		let firstError: Failure \| undefined;
		for (const key in fields) {
		if (!isPartial \|\| (hasKey(key, x) && x[key] !== undefined)) {
		const value = isPartial \|\| hasKey(key, x) ? x[key] : undefined;
		let validated = innerValidate(
		fields[key],
		value,
		sealed && sealed.deep ? { deep: true } : false,
		);
		if (!validated.success) {
		if (!fullError) {
		fullError = unableToAssign(x, runtype);
		}
		fullError.push(typesAreNotCompatible(`"${key}"`, validated));
		firstError =
		firstError \|\|
		failure(validated.message, {
		key: validated.key ? `${key}.${validated.key}` : key,
		fullError: fullError,
		});
		} else {
		placeholder[key] = validated.value;
		}
		fullError.push(typesAreNotCompatible(`"${key}"`, validated));
		firstError =
		firstError \|\|
		failure(validated.message, {
		key: validated.key ? `${key}.${validated.key}` : key,
		fullError: fullError,
		});
		} else {
		placeholder[key] = validated.value;
		}
		}
		}
		return firstError;
		});
		if (!firstError && sealed) {
		for (const key of Object.keys(x)) {
		if (!fieldNames.has(key) && !sealed.keysFromIntersect?.has(key)) {
		const message = `Unexpected property: ${key}`;
		if (!fullError) {
		fullError = unableToAssign(x, runtype);
		}
		fullError.push([message]);
		firstError =
		firstError \|\|
		failure(message, {
		key: key,
		fullError: fullError,
		});
		}
		}
		}
		return firstError;
		});
		},
		f: () => fieldNames,
		},
		@@ -170,2 +195,5 @@ {
		}
		export function ReadonlyObject<O extends RecordFields>(fields: O): Obj<O, true> {
		return InternalObject(fields, false, true);
		}

		@@ -175,1 +203,5 @@ export function Partial<O extends RecordFields>(fields: O): Partial<O, false> {
		}

		export function ReadonlyPartial<O extends RecordFields>(fields: O): Partial<O, true> {
		return InternalObject(fields, true, true);
		}

23

src/types/ParsedValue.ts

		@@ -13,2 +13,3 @@ import { failure, Result } from '../result';
		import show from '../show';
		import { Never } from './never';

		@@ -22,8 +23,2 @@ export interface ParsedValue<TUnderlying extends RuntypeBase<unknown>, TParsed>

		export function isParsedValueRuntype(
		runtype: RuntypeBase,
		): runtype is ParsedValue<RuntypeBase, unknown> {
		return 'tag' in runtype && (runtype as ParsedValue<RuntypeBase, unknown>).tag === 'parsed';
		}

		export interface ParsedValueConfig<TUnderlying extends RuntypeBase<unknown>, TParsed> {
		@@ -57,3 +52,3 @@ name?: string;
		},
		s(value, _internalSerialize, _internalSerializeToPlaceholder) {
		s(value, _internalSerialize, internalSerializeToPlaceholder, _getFields, sealed) {
		if (!config.serialize) {
		@@ -67,3 +62,3 @@ return failure(
		const testResult = config.test
		? innerGuard(config.test, value, createGuardVisitedState())
		? innerGuard(config.test, value, createGuardVisitedState(), sealed)
		: undefined;
		@@ -81,4 +76,14 @@

		return _internalSerializeToPlaceholder(underlying, serialized.value);
		return internalSerializeToPlaceholder(underlying, serialized.value, false);
		},
		u(mode) {
		switch (mode) {
		case 'p':
		return underlying;
		case 't':
		return config.test ?? Never;
		case 's':
		return config.serialize ? config.test : Never;
		}
		},
		},
		@@ -85,0 +90,0 @@ {

2

src/types/primative.ts

		@@ -27,3 +27,3 @@ import { failure, success } from '../result';
		TType extends 'boolean' \| 'function' \| 'number' \| 'string' \| 'symbol',
		TValue
		TValue,
		>(type: TType): Codec<TValue> & { readonly tag: TType } {
		@@ -30,0 +30,0 @@ return create<Codec<TValue> & { readonly tag: TType }>(

4

src/types/Readonly.spec.ts

		@@ -24,4 +24,6 @@ import * as ta from 'type-assertions';
		const obj = ft.Object({ whatever: ft.Number });
		expect(obj.isReadonly).toBe(false);
		ta.assert<ta.Equal<ReturnType<typeof obj['parse']>, { whatever: number }>>();
		const rObj = ft.Readonly(obj);
		expect(rObj.isReadonly).toBe(true);
		ta.assert<ta.Equal<ReturnType<typeof rObj['parse']>, { readonly whatever: number }>>();
		@@ -36,2 +38,4 @@ expect(rObj.safeParse({ whatever: 2 })).toMatchInlineSnapshot(`
		`);
		expect(obj.asPartial().isReadonly).toBe(false);
		expect(rObj.asPartial().isReadonly).toBe(true);
		});
		@@ -38,0 +42,0 @@

2

src/types/Readonly.ts

		@@ -28,3 +28,3 @@ import { RuntypeBase } from '../runtype';
		export function Readonly<
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[]
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[],
		>(input: Tuple<TElements>): ReadonlyTuple<TElements>;
		@@ -31,0 +31,0 @@ export function Readonly<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(

24

src/types/Record.spec.ts

		@@ -27,2 +27,14 @@ import * as ta from 'type-assertions';
		Object {
		"fullError": Array [
		"The types of bar are not compatible",
		Array [
		"Unable to assign {value: 24} to { value: 42; }",
		Array [
		"The types of \\"value\\" are not compatible",
		Array [
		"Expected literal 42, but was 24",
		],
		],
		],
		],
		"key": "bar.value",
		@@ -89,2 +101,14 @@ "message": "Expected literal 42, but was 24",
		Object {
		"fullError": Array [
		"The types of bar are not compatible",
		Array [
		"Unable to assign {value: 24} to { value: 42; }",
		Array [
		"The types of \\"value\\" are not compatible",
		Array [
		"Expected literal 42, but was 24",
		],
		],
		],
		],
		"key": "bar.value",
		@@ -91,0 +115,0 @@ "message": "Expected literal 42, but was 24",

28

src/types/Record.ts

		@@ -15,3 +15,3 @@ import {
		import { Union } from './union';
		import { expected, failure, Result } from '../result';
		import { expected, failure, Result, typesAreNotCompatible } from '../result';

		@@ -71,3 +71,3 @@ export type KeyRuntypeBaseWithoutUnion =
		'record',
		(x, innerValidate) => {
		(x, innerValidate, _innerValidateToPlaceholder, _getFields, sealed) => {
		if (x === null \|\| x === undefined \|\| typeof x !== 'object') {
		@@ -91,9 +91,9 @@ return expected(runtype, x);
		if (isNaN(+k)) return expected(`record key to be a number`, k);
		keyValidation = innerValidate(key, +k);
		keyValidation = innerValidate(key, +k, false);
		} else if (expectedBaseType() === 'string') {
		keyValidation = innerValidate(key, k);
		keyValidation = innerValidate(key, k, false);
		} else {
		keyValidation = innerValidate(key, k);
		keyValidation = innerValidate(key, k, false);
		if (!keyValidation.success && !isNaN(+k)) {
		keyValidation = innerValidate(key, +k);
		keyValidation = innerValidate(key, +k, false);
		}
		@@ -105,6 +105,11 @@ }

		const validated = innerValidate(value, (x as any)[k]);
		const validated = innerValidate(
		value,
		(x as any)[k],
		sealed && sealed.deep ? { deep: true } : false,
		);
		if (!validated.success) {
		return failure(validated.message, {
		key: validated.key ? `${k}.${validated.key}` : k,
		fullError: typesAreNotCompatible(k, validated.fullError ?? [validated.message]),
		});
		@@ -128,1 +133,10 @@ }
		}

		export function ReadonlyRecord<K extends KeyRuntypeBase, V extends RuntypeBase<unknown>>(
		key: K,
		value: V,
		): ReadonlyRecord<K, V> {
		const record: any = Record(key, value);
		record.isReadonly = true;
		return record;
		}

26

src/types/tuple.ts

		@@ -20,3 +20,3 @@ import {
		export interface Tuple<
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[]
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[],
		> extends Codec<StaticTuple<TElements>> {
		@@ -29,3 +29,3 @@ readonly tag: 'tuple';
		export interface ReadonlyTuple<
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[]
		TElements extends readonly RuntypeBase<unknown>[] = readonly RuntypeBase<unknown>[],
		> extends Codec<ReadonlyStaticTuple<TElements>> {
		@@ -45,3 +45,3 @@ readonly tag: 'tuple';
		export function Tuple<
		T extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]] \| readonly []
		T extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]] \| readonly [],
		>(...components: T): Tuple<T> {
		@@ -51,3 +51,3 @@ assertRuntype(...components);
		'tuple',
		(x, innerValidate) => {
		(x, innerValidate, _innerValidateToPlaceholder, _getFields, sealed) => {
		if (!Array.isArray(x)) {
		@@ -65,3 +65,7 @@ return expected(`tuple to be an array`, x);
		for (let i = 0; i < components.length; i++) {
		let validatedComponent = innerValidate(components[i], x[i]);
		let validatedComponent = innerValidate(
		components[i],
		x[i],
		sealed && sealed.deep ? { deep: true } : false,
		);

		@@ -90,3 +94,5 @@ if (!validatedComponent.success) {
		show() {
		return `[${(components as readonly RuntypeBase<unknown>[])
		return `${this.isReadonly ? `readonly ` : ``}[${(
		components as readonly RuntypeBase<unknown>[]
		)
		.map(e => show(e, false))
		@@ -99,1 +105,9 @@ .join(', ')}]`;
		}

		export function ReadonlyTuple<
		T extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]] \| readonly [],
		>(...components: T): ReadonlyTuple<T> {
		const tuple: any = Tuple(...components);
		tuple.isReadonly = true;
		return tuple;
		}

67

src/types/union.ts

		@@ -11,6 +11,8 @@ import {
		assertRuntype,
		unwrapRuntype,
		getFields,
		} from '../runtype';
		import show, { parenthesize } from '../show';
		import { LiteralValue, isLiteralRuntype } from './literal';
		import { lazyValue, isLazyRuntype } from './lazy';
		import { lazyValue } from './lazy';
		import { isObjectRuntype } from './Object';
		@@ -28,9 +30,4 @@ import {
		import { isTupleRuntype } from './tuple';
		import { isBrandRuntype } from './brand';
		import { isConstraintRuntype } from './constraint';
		import { isParsedValueRuntype } from './ParsedValue';
		import { Never } from '..';
		import showValue from '../showValue';
		import { isIntersectRuntype } from './intersect';
		import { isNamedRuntype } from './Named';

		@@ -54,24 +51,2 @@ export type StaticUnion<TAlternatives extends readonly RuntypeBase<unknown>[]> = {

		function resolveUnderlyingType(runtype: RuntypeBase, mode: 'p' \| 's' \| 't'): RuntypeBase {
		if (isLazyRuntype(runtype)) return resolveUnderlyingType(runtype.underlying(), mode);
		if (isBrandRuntype(runtype)) return resolveUnderlyingType(runtype.entity, mode);
		if (isConstraintRuntype(runtype)) return resolveUnderlyingType(runtype.underlying, mode);
		if (isNamedRuntype(runtype)) return resolveUnderlyingType(runtype.underlying, mode);

		if (mode === 'p' && isParsedValueRuntype(runtype))
		return resolveUnderlyingType(runtype.underlying, mode);
		if (mode === 't' && isParsedValueRuntype(runtype)) {
		return runtype.config.test ? resolveUnderlyingType(runtype.config.test, mode) : Never;
		}
		if (mode === 's' && isParsedValueRuntype(runtype)) {
		if (!runtype.config.serialize) {
		// this node can never match
		return Never;
		}
		return runtype.config.test ? resolveUnderlyingType(runtype.config.test, mode) : runtype;
		}

		return runtype;
		}

		function mapGet<TKey, TValue>(map: Map<TKey, TValue>) {
		@@ -91,6 +66,6 @@ return (key: TKey, fn: () => TValue) => {
		): [string, RuntypeBase][] {
		const underlying = resolveUnderlyingType(alternative, mode);
		const underlying = unwrapRuntype(alternative, mode);
		const fields: [string, RuntypeBase][] = [];
		const pushField = (fieldName: string, type: RuntypeBase) => {
		const f = resolveUnderlyingType(type, mode);
		const f = unwrapRuntype(type, mode);
		if (isUnionType(f)) {
		@@ -169,3 +144,3 @@ for (const type of f.alternatives) {
		export function Union<
		TAlternatives extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]]
		TAlternatives extends readonly [RuntypeBase<unknown>, ...RuntypeBase<unknown>[]],
		>(...alternatives: TAlternatives): Union<TAlternatives> {
		@@ -254,3 +229,3 @@ assertRuntype(...alternatives);
		const withFields = flatAlternatives
		.filter(a => resolveUnderlyingType(a, mode).tag !== 'never')
		.filter(a => unwrapRuntype(a, mode).tag !== 'never')
		.map(a => [a, findFields(a, mode)] as const);
		@@ -271,7 +246,5 @@ const withAtLeastOneField = withFields.filter(a => a[1].length !== 0);
		if (!resultWithoutKey.success) {
		if (resultWithKey.fullError) {
		resultWithoutKey.fullError!.push(andError(resultWithKey.fullError!));
		} else {
		resultWithoutKey.fullError!.push(andError(unableToAssign(value, `Object`)));
		}
		resultWithoutKey.fullError!.push(
		andError(resultWithKey.fullError ?? unableToAssign(value, `Object`)),
		);
		}
		@@ -292,2 +265,19 @@ return resultWithoutKey;

		const getFieldsForMode = (mode: 'p' \| 't' \| 's') => {
		const fields = new Set<string>();
		for (const a of alternatives) {
		const aFields = getFields(a, mode);
		if (aFields === undefined) return undefined;
		for (const f of aFields) {
		fields.add(f);
		}
		}
		return fields;
		};
		const fields = {
		p: lazyValue(() => getFieldsForMode(`p`)),
		t: lazyValue(() => getFieldsForMode(`t`)),
		s: lazyValue(() => getFieldsForMode(`s`)),
		};

		const runtype: Union<TAlternatives> = create<Union<TAlternatives>>(
		@@ -306,2 +296,3 @@ 'union',
		},
		f: mode => fields[mode](),
		},
		@@ -323,3 +314,3 @@ {
		for (let i = 0; i < alternatives.length; i++) {
		const input = innerValidate(alternatives[i], x, visited);
		const input = innerValidate(alternatives[i], x, visited, false);
		if (input.success) {
		@@ -326,0 +317,0 @@ return cases[i](input.value);

2

tsconfig.json

		@@ -12,3 +12,3 @@ {
		"declaration": true,
		"sourceMap": false,
		"sourceMap": true,
		"outDir": "lib",
		@@ -15,0 +15,0 @@ "forceConsistentCasingInFileNames": true,

.vscode/settings.json

.vscode/tasks.json

.github/workflows/rollingversions.yml

Sorry, the diff of this file is not supported yet

.github/workflows/test.yml

Sorry, the diff of this file is not supported yet

lib/index.mjs

Sorry, the diff of this file is not supported yet

funtypes - npm Package Compare versions

New alerts

Improved metrics

Worsened metrics