orbit-oss/is
5
5
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use string literals instead of enums (#113)

Browse source
This commit is contained in:
Bjorn Stromberg 2020-06-20 16:28:47 +09:00 • committed by GitHub
parent 9d404cad2e
commit 1ffe2fb6a7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 250 additions and 254 deletions
Download patch file Download diff file Expand all files Collapse all files

386
source/index.ts
View file

@ -4,101 +4,145 @@
export type Class<T = unknown> = new (...args: any[]) => T; export type Class<T = unknown> = new (...args: any[]) => T;
export const enum TypeName { const typedArrayTypeNames = [
null = 'null', 'Int8Array',
boolean = 'boolean', 'Uint8Array',
undefined = 'undefined', 'Uint8ClampedArray',
string = 'string', 'Int16Array',
number = 'number', 'Uint16Array',
bigint = 'bigint', 'Int32Array',
symbol = 'symbol', 'Uint32Array',
Function = 'Function', 'Float32Array',
Generator = 'Generator', 'Float64Array',
AsyncGenerator = 'AsyncGenerator', 'BigInt64Array',
GeneratorFunction = 'GeneratorFunction', 'BigUint64Array'
AsyncGeneratorFunction = 'AsyncGeneratorFunction', ] as const;
AsyncFunction = 'AsyncFunction',
Observable = 'Observable', export type TypedArray =
Array = 'Array', | Int8Array
Buffer = 'Buffer', | Uint8Array
Object = 'Object', | Uint8ClampedArray
RegExp = 'RegExp', | Int16Array
Date = 'Date', | Uint16Array
Error = 'Error', | Int32Array
Map = 'Map', | Uint32Array
Set = 'Set', | Float32Array
WeakMap = 'WeakMap', | Float64Array
WeakSet = 'WeakSet', | BigInt64Array
Int8Array = 'Int8Array', | BigUint64Array;
Uint8Array = 'Uint8Array',
Uint8ClampedArray = 'Uint8ClampedArray', type TypedArrayTypeName = typeof typedArrayTypeNames[number];
Int16Array = 'Int16Array',
Uint16Array = 'Uint16Array', function isTypedArrayName(name: unknown): name is TypedArrayTypeName {
Int32Array = 'Int32Array', return typedArrayTypeNames.includes(name as TypedArrayTypeName);
Uint32Array = 'Uint32Array', }
Float32Array = 'Float32Array',
Float64Array = 'Float64Array', const objectTypeNames = [
BigInt64Array = 'BigInt64Array', 'Function',
BigUint64Array = 'BigUint64Array', 'Generator',
ArrayBuffer = 'ArrayBuffer', 'AsyncGenerator',
SharedArrayBuffer = 'SharedArrayBuffer', 'GeneratorFunction',
DataView = 'DataView', 'AsyncGeneratorFunction',
Promise = 'Promise', 'AsyncFunction',
URL = 'URL' 'Observable',
'Array',
'Buffer',
'Object',
'RegExp',
'Date',
'Error',
'Map',
'Set',
'WeakMap',
'WeakSet',
'ArrayBuffer',
'SharedArrayBuffer',
'DataView',
'Promise',
'URL',
'HTMLElement',
...typedArrayTypeNames
] as const;
type ObjectTypeName = typeof objectTypeNames[number];
const primitiveTypeNames = [
'null',
'undefined',
'string',
'number',
'bigint',
'boolean',
'symbol'
] as const;
export type Primitive =
| null
| undefined
| string
| number
| bigint
| boolean
| symbol;
type PrimitiveTypeName = typeof primitiveTypeNames[number];
function isPrimitiveTypeName(name: unknown): name is PrimitiveTypeName {
return primitiveTypeNames.includes(name as PrimitiveTypeName);
}
export type TypeName = ObjectTypeName | PrimitiveTypeName;
// eslint-disable-next-line @typescript-eslint/ban-types
function isOfType<T extends Primitive | Function>(type: PrimitiveTypeName | 'function') {
return (value: unknown): value is T => typeof value === type;
} }
const {toString} = Object.prototype; const {toString} = Object.prototype;
const isOfType = <T>(type: string) => (value: unknown): value is T => typeof value === type; const getObjectType = (value: unknown): ObjectTypeName | undefined => {
const getObjectType = (value: unknown): TypeName | undefined => {
const objectName = toString.call(value).slice(8, -1); const objectName = toString.call(value).slice(8, -1);
if (objectName) { if (objectName) {
return objectName as TypeName; return objectName as ObjectTypeName;
} }
return undefined; return undefined;
}; };
const isObjectOfType = <T>(type: TypeName) => (value: unknown): value is T => getObjectType(value) === type; const isObjectOfType = <T>(type: ObjectTypeName) => (value: unknown): value is T => getObjectType(value) === type;
function is(value: unknown): TypeName { function is(value: unknown): TypeName {
switch (value) { if (value === null) {
case null: return 'null';
return TypeName.null;
case true:
case false:
return TypeName.boolean;
default:
} }
switch (typeof value) { switch (typeof value) {
case 'undefined': case 'undefined':
return TypeName.undefined; return 'undefined';
case 'string': case 'string':
return TypeName.string; return 'string';
case 'number': case 'number':
return TypeName.number; return 'number';
case 'boolean':
return 'boolean';
case 'function':
return 'Function';
case 'bigint': case 'bigint':
return TypeName.bigint; return 'bigint';
case 'symbol': case 'symbol':
return TypeName.symbol; return 'symbol';
default: default:
} }
if (is.function_(value)) {
return TypeName.Function;
}
if (is.observable(value)) { if (is.observable(value)) {
return TypeName.Observable; return 'Observable';
} }
if (is.array(value)) { if (is.array(value)) {
return TypeName.Array; return 'Array';
} }
if (is.buffer(value)) { if (is.buffer(value)) {
return TypeName.Buffer; return 'Buffer';
} }
const tagType = getObjectType(value); const tagType = getObjectType(value);
@ -110,7 +154,7 @@ function is(value: unknown): TypeName {
throw new TypeError('Please don\'t use object wrappers for primitive types'); throw new TypeError('Please don\'t use object wrappers for primitive types');
} }
return TypeName.Object; return 'Object';
} }
is.undefined = isOfType<undefined>('undefined'); is.undefined = isOfType<undefined>('undefined');
@ -146,7 +190,7 @@ is.generator = (value: unknown): value is Generator => is.iterable(value) && is.
is.asyncGenerator = (value: unknown): value is AsyncGenerator => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw); is.asyncGenerator = (value: unknown): value is AsyncGenerator => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
is.nativePromise = <T = unknown>(value: unknown): value is Promise<T> => is.nativePromise = <T = unknown>(value: unknown): value is Promise<T> =>
isObjectOfType<Promise<T>>(TypeName.Promise)(value); isObjectOfType<Promise<T>>('Promise')(value);
const hasPromiseAPI = <T = unknown>(value: unknown): value is Promise<T> => const hasPromiseAPI = <T = unknown>(value: unknown): value is Promise<T> =>
is.function_((value as Promise<T>)?.then) && is.function_((value as Promise<T>)?.then) &&
@ -154,41 +198,41 @@ const hasPromiseAPI = <T = unknown>(value: unknown): value is Promise<T> =>
is.promise = <T = unknown>(value: unknown): value is Promise<T> => is.nativePromise(value) || hasPromiseAPI(value); is.promise = <T = unknown>(value: unknown): value is Promise<T> => is.nativePromise(value) || hasPromiseAPI(value);
is.generatorFunction = isObjectOfType<GeneratorFunction>(TypeName.GeneratorFunction); is.generatorFunction = isObjectOfType<GeneratorFunction>('GeneratorFunction');
is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise<unknown>) => getObjectType(value) === TypeName.AsyncGeneratorFunction; is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise<unknown>) => getObjectType(value) === 'AsyncGeneratorFunction';
is.asyncFunction = <T = unknown>(value: unknown): value is ((...args: any[]) => Promise<T>) => getObjectType(value) === TypeName.AsyncFunction; is.asyncFunction = <T = unknown>(value: unknown): value is ((...args: any[]) => Promise<T>) => getObjectType(value) === 'AsyncFunction';
// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types // eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
is.boundFunction = (value: unknown): value is Function => is.function_(value) && !value.hasOwnProperty('prototype'); is.boundFunction = (value: unknown): value is Function => is.function_(value) && !value.hasOwnProperty('prototype');
is.regExp = isObjectOfType<RegExp>(TypeName.RegExp); is.regExp = isObjectOfType<RegExp>('RegExp');
is.date = isObjectOfType<Date>(TypeName.Date); is.date = isObjectOfType<Date>('Date');
is.error = isObjectOfType<Error>(TypeName.Error); is.error = isObjectOfType<Error>('Error');
is.map = <Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value> => isObjectOfType<Map<Key, Value>>(TypeName.Map)(value); is.map = <Key = unknown, Value = unknown>(value: unknown): value is Map<Key, Value> => isObjectOfType<Map<Key, Value>>('Map')(value);
is.set = <T = unknown>(value: unknown): value is Set<T> => isObjectOfType<Set<T>>(TypeName.Set)(value); is.set = <T = unknown>(value: unknown): value is Set<T> => isObjectOfType<Set<T>>('Set')(value);
is.weakMap = <Key extends object = object, Value = unknown>(value: unknown): value is WeakMap<Key, Value> => isObjectOfType<WeakMap<Key, Value>>(TypeName.WeakMap)(value); is.weakMap = <Key extends object = object, Value = unknown>(value: unknown): value is WeakMap<Key, Value> => isObjectOfType<WeakMap<Key, Value>>('WeakMap')(value);
is.weakSet = (value: unknown): value is WeakSet<object> => isObjectOfType<WeakSet<object>>(TypeName.WeakSet)(value); is.weakSet = (value: unknown): value is WeakSet<object> => isObjectOfType<WeakSet<object>>('WeakSet')(value);
is.int8Array = isObjectOfType<Int8Array>(TypeName.Int8Array); is.int8Array = isObjectOfType<Int8Array>('Int8Array');
is.uint8Array = isObjectOfType<Uint8Array>(TypeName.Uint8Array); is.uint8Array = isObjectOfType<Uint8Array>('Uint8Array');
is.uint8ClampedArray = isObjectOfType<Uint8ClampedArray>(TypeName.Uint8ClampedArray); is.uint8ClampedArray = isObjectOfType<Uint8ClampedArray>('Uint8ClampedArray');
is.int16Array = isObjectOfType<Int16Array>(TypeName.Int16Array); is.int16Array = isObjectOfType<Int16Array>('Int16Array');
is.uint16Array = isObjectOfType<Uint16Array>(TypeName.Uint16Array); is.uint16Array = isObjectOfType<Uint16Array>('Uint16Array');
is.int32Array = isObjectOfType<Int32Array>(TypeName.Int32Array); is.int32Array = isObjectOfType<Int32Array>('Int32Array');
is.uint32Array = isObjectOfType<Uint32Array>(TypeName.Uint32Array); is.uint32Array = isObjectOfType<Uint32Array>('Uint32Array');
is.float32Array = isObjectOfType<Float32Array>(TypeName.Float32Array); is.float32Array = isObjectOfType<Float32Array>('Float32Array');
is.float64Array = isObjectOfType<Float64Array>(TypeName.Float64Array); is.float64Array = isObjectOfType<Float64Array>('Float64Array');
is.bigInt64Array = isObjectOfType<BigInt64Array>(TypeName.BigInt64Array); is.bigInt64Array = isObjectOfType<BigInt64Array>('BigInt64Array');
is.bigUint64Array = isObjectOfType<BigUint64Array>(TypeName.BigUint64Array); is.bigUint64Array = isObjectOfType<BigUint64Array>('BigUint64Array');
is.arrayBuffer = isObjectOfType<ArrayBuffer>(TypeName.ArrayBuffer); is.arrayBuffer = isObjectOfType<ArrayBuffer>('ArrayBuffer');
is.sharedArrayBuffer = isObjectOfType<SharedArrayBuffer>(TypeName.SharedArrayBuffer); is.sharedArrayBuffer = isObjectOfType<SharedArrayBuffer>('SharedArrayBuffer');
is.dataView = isObjectOfType<DataView>(TypeName.DataView); is.dataView = isObjectOfType<DataView>('DataView');
is.directInstanceOf = <T>(instance: unknown, class_: Class<T>): instance is T => Object.getPrototypeOf(instance) === class_.prototype; is.directInstanceOf = <T>(instance: unknown, class_: Class<T>): instance is T => Object.getPrototypeOf(instance) === class_.prototype;
is.urlInstance = (value: unknown): value is URL => isObjectOfType<URL>(TypeName.URL)(value); is.urlInstance = (value: unknown): value is URL => isObjectOfType<URL>('URL')(value);
is.urlString = (value: unknown): value is string => { is.urlString = (value: unknown): value is string => {
if (!is.string(value)) { if (!is.string(value)) {
@ -211,33 +255,14 @@ is.falsy = (value: unknown) => !value;
is.nan = (value: unknown) => Number.isNaN(value as number); is.nan = (value: unknown) => Number.isNaN(value as number);
const primitiveTypeOfTypes = new Set([ is.primitive = (value: unknown): value is Primitive => is.null_(value) || isPrimitiveTypeName(typeof value);
'undefined',
'string',
'number',
'bigint',
'boolean',
'symbol'
]);
// TODO: This should be able to be `not object` when the `not` operator is out
export type Primitive =
| null
| undefined
| string
| number
| bigint
| boolean
| symbol;
is.primitive = (value: unknown): value is Primitive => is.null_(value) || primitiveTypeOfTypes.has(typeof value);
is.integer = (value: unknown): value is number => Number.isInteger(value as number); is.integer = (value: unknown): value is number => Number.isInteger(value as number);
is.safeInteger = (value: unknown): value is number => Number.isSafeInteger(value as number); is.safeInteger = (value: unknown): value is number => Number.isSafeInteger(value as number);
is.plainObject = <Value = unknown>(value: unknown): value is Record<string, Value> => { is.plainObject = <Value = unknown>(value: unknown): value is Record<string, Value> => {
// From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
if (getObjectType(value) !== TypeName.Object) { if (toString.call(value) !== '[object Object]') {
return false; return false;
} }
@ -246,41 +271,7 @@ is.plainObject = <Value = unknown>(value: unknown): value is Record<string, Valu
return prototype === null || prototype === Object.getPrototypeOf({}); return prototype === null || prototype === Object.getPrototypeOf({});
}; };
const typedArrayTypes = new Set([ is.typedArray = (value: unknown): value is TypedArray => isTypedArrayName(getObjectType(value));
TypeName.Int8Array,
TypeName.Uint8Array,
TypeName.Uint8ClampedArray,
TypeName.Int16Array,
TypeName.Uint16Array,
TypeName.Int32Array,
TypeName.Uint32Array,
TypeName.Float32Array,
TypeName.Float64Array,
TypeName.BigInt64Array,
TypeName.BigUint64Array
]);
export type TypedArray =
| Int8Array
| Uint8Array
| Uint8ClampedArray
| Int16Array
| Uint16Array
| Int32Array
| Uint32Array
| Float32Array
| Float64Array
| BigInt64Array
| BigUint64Array;
is.typedArray = (value: unknown): value is TypedArray => {
const objectType = getObjectType(value);
if (objectType === undefined) {
return false;
}
return typedArrayTypes.has(objectType);
};
export interface ArrayLike<T> { export interface ArrayLike<T> {
readonly [index: number]: T; readonly [index: number]: T;
@ -303,7 +294,7 @@ is.inRange = (value: number, range: number | number[]): value is number => {
}; };
const NODE_TYPE_ELEMENT = 1; const NODE_TYPE_ELEMENT = 1;
const DOM_PROPERTIES_TO_CHECK = [ const DOM_PROPERTIES_TO_CHECK: Array<(keyof HTMLElement)> = [
'innerHTML', 'innerHTML',
'ownerDocument', 'ownerDocument',
'style', 'style',
@ -311,8 +302,13 @@ const DOM_PROPERTIES_TO_CHECK = [
'nodeValue' 'nodeValue'
]; ];
is.domElement = (value: unknown): value is Element => is.object(value) && (value as Element).nodeType === NODE_TYPE_ELEMENT && is.string((value as Element).nodeName) && is.domElement = (value: unknown): value is HTMLElement => {
!is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in (value as Element)); return is.object(value) &&
(value as HTMLElement).nodeType === NODE_TYPE_ELEMENT &&
is.string((value as HTMLElement).nodeName) &&
!is.plainObject(value) &&
DOM_PROPERTIES_TO_CHECK.every(property => property in value);
};
export interface ObservableLike { export interface ObservableLike {
subscribe(observer: (value: unknown) => void): void; subscribe(observer: (value: unknown) => void): void;
@ -419,7 +415,7 @@ export const enum AssertionTypeDescription {
plainObject = 'plain object', plainObject = 'plain object',
arrayLike = 'array-like', arrayLike = 'array-like',
typedArray = 'TypedArray', typedArray = 'TypedArray',
domElement = 'Element', domElement = 'HTMLElement',
nodeStream = 'Node.js Stream', nodeStream = 'Node.js Stream',
infinite = 'infinite number', infinite = 'infinite number',
emptyArray = 'empty array', emptyArray = 'empty array',
@ -506,7 +502,7 @@ interface Assert {
plainObject: <Value = unknown>(value: unknown) => asserts value is Record<string, Value>; plainObject: <Value = unknown>(value: unknown) => asserts value is Record<string, Value>;
typedArray: (value: unknown) => asserts value is TypedArray; typedArray: (value: unknown) => asserts value is TypedArray;
arrayLike: <T = unknown>(value: unknown) => asserts value is ArrayLike<T>; arrayLike: <T = unknown>(value: unknown) => asserts value is ArrayLike<T>;
domElement: (value: unknown) => asserts value is Element; domElement: (value: unknown) => asserts value is HTMLElement;
observable: (value: unknown) => asserts value is ObservableLike; observable: (value: unknown) => asserts value is ObservableLike;
nodeStream: (value: unknown) => asserts value is NodeStream; nodeStream: (value: unknown) => asserts value is NodeStream;
infinite: (value: unknown) => asserts value is number; infinite: (value: unknown) => asserts value is number;
@ -537,55 +533,55 @@ interface Assert {
export const assert: Assert = { export const assert: Assert = {
// Unknowns. // Unknowns.
undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), TypeName.undefined, value), undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), 'undefined', value),
string: (value: unknown): asserts value is string => assertType(is.string(value), TypeName.string, value), string: (value: unknown): asserts value is string => assertType(is.string(value), 'string', value),
number: (value: unknown): asserts value is number => assertType(is.number(value), TypeName.number, value), number: (value: unknown): asserts value is number => assertType(is.number(value), 'number', value),
bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), TypeName.bigint, value), bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), 'bigint', value),
// eslint-disable-next-line @typescript-eslint/ban-types // eslint-disable-next-line @typescript-eslint/ban-types
function_: (value: unknown): asserts value is Function => assertType(is.function_(value), TypeName.Function, value), function_: (value: unknown): asserts value is Function => assertType(is.function_(value), 'Function', value),
null_: (value: unknown): asserts value is null => assertType(is.null_(value), TypeName.null, value), null_: (value: unknown): asserts value is null => assertType(is.null_(value), 'null', value),
class_: (value: unknown): asserts value is Class => assertType(is.class_(value), AssertionTypeDescription.class_, value), class_: (value: unknown): asserts value is Class => assertType(is.class_(value), AssertionTypeDescription.class_, value),
boolean: (value: unknown): asserts value is boolean => assertType(is.boolean(value), TypeName.boolean, value), boolean: (value: unknown): asserts value is boolean => assertType(is.boolean(value), 'boolean', value),
symbol: (value: unknown): asserts value is symbol => assertType(is.symbol(value), TypeName.symbol, value), symbol: (value: unknown): asserts value is symbol => assertType(is.symbol(value), 'symbol', value),
numericString: (value: unknown): asserts value is string => assertType(is.numericString(value), AssertionTypeDescription.numericString, value), numericString: (value: unknown): asserts value is string => assertType(is.numericString(value), AssertionTypeDescription.numericString, value),
array: <T = unknown>(value: unknown): asserts value is T[] => assertType(is.array(value), TypeName.Array, value), array: <T = unknown>(value: unknown): asserts value is T[] => assertType(is.array(value), 'Array', value),
buffer: (value: unknown): asserts value is Buffer => assertType(is.buffer(value), TypeName.Buffer, value), buffer: (value: unknown): asserts value is Buffer => assertType(is.buffer(value), 'Buffer', value),
nullOrUndefined: (value: unknown): asserts value is null | undefined => assertType(is.nullOrUndefined(value), AssertionTypeDescription.nullOrUndefined, value), nullOrUndefined: (value: unknown): asserts value is null | undefined => assertType(is.nullOrUndefined(value), AssertionTypeDescription.nullOrUndefined, value),
object: (value: unknown): asserts value is object => assertType(is.object(value), TypeName.Object, value), object: (value: unknown): asserts value is object => assertType(is.object(value), 'Object', value),
iterable: <T = unknown>(value: unknown): asserts value is Iterable<T> => assertType(is.iterable(value), AssertionTypeDescription.iterable, value), iterable: <T = unknown>(value: unknown): asserts value is Iterable<T> => assertType(is.iterable(value), AssertionTypeDescription.iterable, value),
asyncIterable: <T = unknown>(value: unknown): asserts value is AsyncIterable<T> => assertType(is.asyncIterable(value), AssertionTypeDescription.asyncIterable, value), asyncIterable: <T = unknown>(value: unknown): asserts value is AsyncIterable<T> => assertType(is.asyncIterable(value), AssertionTypeDescription.asyncIterable, value),
generator: (value: unknown): asserts value is Generator => assertType(is.generator(value), TypeName.Generator, value), generator: (value: unknown): asserts value is Generator => assertType(is.generator(value), 'Generator', value),
asyncGenerator: (value: unknown): asserts value is AsyncGenerator => assertType(is.asyncGenerator(value), TypeName.AsyncGenerator, value), asyncGenerator: (value: unknown): asserts value is AsyncGenerator => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
nativePromise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.nativePromise(value), AssertionTypeDescription.nativePromise, value), nativePromise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.nativePromise(value), AssertionTypeDescription.nativePromise, value),
promise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.promise(value), TypeName.Promise, value), promise: <T = unknown>(value: unknown): asserts value is Promise<T> => assertType(is.promise(value), 'Promise', value),
generatorFunction: (value: unknown): asserts value is GeneratorFunction => assertType(is.generatorFunction(value), TypeName.GeneratorFunction, value), generatorFunction: (value: unknown): asserts value is GeneratorFunction => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
asyncGeneratorFunction: (value: unknown): asserts value is AsyncGeneratorFunction => assertType(is.asyncGeneratorFunction(value), TypeName.AsyncGeneratorFunction, value), asyncGeneratorFunction: (value: unknown): asserts value is AsyncGeneratorFunction => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types // eslint-disable-next-line @typescript-eslint/ban-types
asyncFunction: (value: unknown): asserts value is Function => assertType(is.asyncFunction(value), TypeName.AsyncFunction, value), asyncFunction: (value: unknown): asserts value is Function => assertType(is.asyncFunction(value), 'AsyncFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types // eslint-disable-next-line @typescript-eslint/ban-types
boundFunction: (value: unknown): asserts value is Function => assertType(is.boundFunction(value), TypeName.Function, value), boundFunction: (value: unknown): asserts value is Function => assertType(is.boundFunction(value), 'Function', value),
regExp: (value: unknown): asserts value is RegExp => assertType(is.regExp(value), TypeName.RegExp, value), regExp: (value: unknown): asserts value is RegExp => assertType(is.regExp(value), 'RegExp', value),
date: (value: unknown): asserts value is Date => assertType(is.date(value), TypeName.Date, value), date: (value: unknown): asserts value is Date => assertType(is.date(value), 'Date', value),
error: (value: unknown): asserts value is Error => assertType(is.error(value), TypeName.Error, value), error: (value: unknown): asserts value is Error => assertType(is.error(value), 'Error', value),
map: <Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value> => assertType(is.map(value), TypeName.Map, value), map: <Key = unknown, Value = unknown>(value: unknown): asserts value is Map<Key, Value> => assertType(is.map(value), 'Map', value),
set: <T = unknown>(value: unknown): asserts value is Set<T> => assertType(is.set(value), TypeName.Set, value), set: <T = unknown>(value: unknown): asserts value is Set<T> => assertType(is.set(value), 'Set', value),
weakMap: <Key extends object = object, Value = unknown>(value: unknown): asserts value is WeakMap<Key, Value> => assertType(is.weakMap(value), TypeName.WeakMap, value), weakMap: <Key extends object = object, Value = unknown>(value: unknown): asserts value is WeakMap<Key, Value> => assertType(is.weakMap(value), 'WeakMap', value),
weakSet: <T extends object = object>(value: unknown): asserts value is WeakSet<T> => assertType(is.weakSet(value), TypeName.WeakSet, value), weakSet: <T extends object = object>(value: unknown): asserts value is WeakSet<T> => assertType(is.weakSet(value), 'WeakSet', value),
int8Array: (value: unknown): asserts value is Int8Array => assertType(is.int8Array(value), TypeName.Int8Array, value), int8Array: (value: unknown): asserts value is Int8Array => assertType(is.int8Array(value), 'Int8Array', value),
uint8Array: (value: unknown): asserts value is Uint8Array => assertType(is.uint8Array(value), TypeName.Uint8Array, value), uint8Array: (value: unknown): asserts value is Uint8Array => assertType(is.uint8Array(value), 'Uint8Array', value),
uint8ClampedArray: (value: unknown): asserts value is Uint8ClampedArray => assertType(is.uint8ClampedArray(value), TypeName.Uint8ClampedArray, value), uint8ClampedArray: (value: unknown): asserts value is Uint8ClampedArray => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
int16Array: (value: unknown): asserts value is Int16Array => assertType(is.int16Array(value), TypeName.Int16Array, value), int16Array: (value: unknown): asserts value is Int16Array => assertType(is.int16Array(value), 'Int16Array', value),
uint16Array: (value: unknown): asserts value is Uint16Array => assertType(is.uint16Array(value), TypeName.Uint16Array, value), uint16Array: (value: unknown): asserts value is Uint16Array => assertType(is.uint16Array(value), 'Uint16Array', value),
int32Array: (value: unknown): asserts value is Int32Array => assertType(is.int32Array(value), TypeName.Int32Array, value), int32Array: (value: unknown): asserts value is Int32Array => assertType(is.int32Array(value), 'Int32Array', value),
uint32Array: (value: unknown): asserts value is Uint32Array => assertType(is.uint32Array(value), TypeName.Uint32Array, value), uint32Array: (value: unknown): asserts value is Uint32Array => assertType(is.uint32Array(value), 'Uint32Array', value),
float32Array: (value: unknown): asserts value is Float32Array => assertType(is.float32Array(value), TypeName.Float32Array, value), float32Array: (value: unknown): asserts value is Float32Array => assertType(is.float32Array(value), 'Float32Array', value),
float64Array: (value: unknown): asserts value is Float64Array => assertType(is.float64Array(value), TypeName.Float64Array, value), float64Array: (value: unknown): asserts value is Float64Array => assertType(is.float64Array(value), 'Float64Array', value),
bigInt64Array: (value: unknown): asserts value is BigInt64Array => assertType(is.bigInt64Array(value), TypeName.BigInt64Array, value), bigInt64Array: (value: unknown): asserts value is BigInt64Array => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
bigUint64Array: (value: unknown): asserts value is BigUint64Array => assertType(is.bigUint64Array(value), TypeName.BigUint64Array, value), bigUint64Array: (value: unknown): asserts value is BigUint64Array => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
arrayBuffer: (value: unknown): asserts value is ArrayBuffer => assertType(is.arrayBuffer(value), TypeName.ArrayBuffer, value), arrayBuffer: (value: unknown): asserts value is ArrayBuffer => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
sharedArrayBuffer: (value: unknown): asserts value is SharedArrayBuffer => assertType(is.sharedArrayBuffer(value), TypeName.SharedArrayBuffer, value), sharedArrayBuffer: (value: unknown): asserts value is SharedArrayBuffer => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
dataView: (value: unknown): asserts value is DataView => assertType(is.dataView(value), TypeName.DataView, value), dataView: (value: unknown): asserts value is DataView => assertType(is.dataView(value), 'DataView', value),
urlInstance: (value: unknown): asserts value is URL => assertType(is.urlInstance(value), TypeName.URL, value), urlInstance: (value: unknown): asserts value is URL => assertType(is.urlInstance(value), 'URL', value),
urlString: (value: unknown): asserts value is string => assertType(is.urlString(value), AssertionTypeDescription.urlString, value), urlString: (value: unknown): asserts value is string => assertType(is.urlString(value), AssertionTypeDescription.urlString, value),
truthy: (value: unknown): asserts value is unknown => assertType(is.truthy(value), AssertionTypeDescription.truthy, value), truthy: (value: unknown): asserts value is unknown => assertType(is.truthy(value), AssertionTypeDescription.truthy, value),
falsy: (value: unknown): asserts value is unknown => assertType(is.falsy(value), AssertionTypeDescription.falsy, value), falsy: (value: unknown): asserts value is unknown => assertType(is.falsy(value), AssertionTypeDescription.falsy, value),
@ -596,8 +592,8 @@ export const assert: Assert = {
plainObject: <Value = unknown>(value: unknown): asserts value is Record<string, Value> => assertType(is.plainObject(value), AssertionTypeDescription.plainObject, value), plainObject: <Value = unknown>(value: unknown): asserts value is Record<string, Value> => assertType(is.plainObject(value), AssertionTypeDescription.plainObject, value),
typedArray: (value: unknown): asserts value is TypedArray => assertType(is.typedArray(value), AssertionTypeDescription.typedArray, value), typedArray: (value: unknown): asserts value is TypedArray => assertType(is.typedArray(value), AssertionTypeDescription.typedArray, value),
arrayLike: <T = unknown>(value: unknown): asserts value is ArrayLike<T> => assertType(is.arrayLike(value), AssertionTypeDescription.arrayLike, value), arrayLike: <T = unknown>(value: unknown): asserts value is ArrayLike<T> => assertType(is.arrayLike(value), AssertionTypeDescription.arrayLike, value),
domElement: (value: unknown): asserts value is Element => assertType(is.domElement(value), AssertionTypeDescription.domElement, value), domElement: (value: unknown): asserts value is HTMLElement => assertType(is.domElement(value), AssertionTypeDescription.domElement, value),
observable: (value: unknown): asserts value is ObservableLike => assertType(is.observable(value), TypeName.Observable, value), observable: (value: unknown): asserts value is ObservableLike => assertType(is.observable(value), 'Observable', value),
nodeStream: (value: unknown): asserts value is NodeStream => assertType(is.nodeStream(value), AssertionTypeDescription.nodeStream, value), nodeStream: (value: unknown): asserts value is NodeStream => assertType(is.nodeStream(value), AssertionTypeDescription.nodeStream, value),
infinite: (value: unknown): asserts value is number => assertType(is.infinite(value), AssertionTypeDescription.infinite, value), infinite: (value: unknown): asserts value is number => assertType(is.infinite(value), AssertionTypeDescription.infinite, value),
emptyArray: (value: unknown): asserts value is never[] => assertType(is.emptyArray(value), AssertionTypeDescription.emptyArray, value), emptyArray: (value: unknown): asserts value is never[] => assertType(is.emptyArray(value), AssertionTypeDescription.emptyArray, value),

118
test/test.ts
View file

@ -7,7 +7,7 @@ import {JSDOM} from 'jsdom';
import {Subject, Observable} from 'rxjs'; import {Subject, Observable} from 'rxjs';
import tempy = require('tempy'); import tempy = require('tempy');
import ZenObservable = require('zen-observable'); import ZenObservable = require('zen-observable');
import is, {assert, AssertionTypeDescription, TypeName} from '../source'; import is, {assert, AssertionTypeDescription, Primitive, TypedArray, TypeName} from '../source';
class PromiseSubclassFixture<T> extends Promise<T> {} class PromiseSubclassFixture<T> extends Promise<T> {}
class ErrorSubclassFixture extends Error {} class ErrorSubclassFixture extends Error {}
@ -47,7 +47,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
undefined undefined
], ],
typename: TypeName.undefined typename: 'undefined'
}], }],
['null', { ['null', {
is: is.null_, is: is.null_,
@ -55,7 +55,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
null null
], ],
typename: TypeName.null typename: 'null'
}], }],
['string', { ['string', {
is: is.string, is: is.string,
@ -65,7 +65,7 @@ const types = new Map<string, Test>([
'hello world', 'hello world',
'' ''
], ],
typename: TypeName.string typename: 'string'
}], }],
['emptyString', { ['emptyString', {
is: is.emptyString, is: is.emptyString,
@ -74,7 +74,7 @@ const types = new Map<string, Test>([
'', '',
String() String()
], ],
typename: TypeName.string, typename: 'string',
typeDescription: AssertionTypeDescription.emptyString typeDescription: AssertionTypeDescription.emptyString
}], }],
['number', { ['number', {
@ -88,7 +88,7 @@ const types = new Map<string, Test>([
Infinity, Infinity,
-Infinity -Infinity
], ],
typename: TypeName.number typename: 'number'
}], }],
['bigint', { ['bigint', {
is: is.bigint, is: is.bigint,
@ -100,7 +100,7 @@ const types = new Map<string, Test>([
// -0n, // -0n,
BigInt('1234') BigInt('1234')
], ],
typename: TypeName.bigint typename: 'bigint'
}], }],
['boolean', { ['boolean', {
is: is.boolean, is: is.boolean,
@ -108,7 +108,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
true, false true, false
], ],
typename: TypeName.boolean typename: 'boolean'
}], }],
['symbol', { ['symbol', {
is: is.symbol, is: is.symbol,
@ -116,7 +116,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
Symbol('🦄') Symbol('🦄')
], ],
typename: TypeName.symbol typename: 'symbol'
}], }],
['numericString', { ['numericString', {
is: is.numericString, is: is.numericString,
@ -127,7 +127,7 @@ const types = new Map<string, Test>([
'Infinity', 'Infinity',
'0x56' '0x56'
], ],
typename: TypeName.string, typename: 'string',
typeDescription: AssertionTypeDescription.numericString typeDescription: AssertionTypeDescription.numericString
}], }],
['array', { ['array', {
@ -137,7 +137,7 @@ const types = new Map<string, Test>([
[1, 2], [1, 2],
new Array(2) new Array(2)
], ],
typename: TypeName.Array typename: 'Array'
}], }],
['emptyArray', { ['emptyArray', {
is: is.emptyArray, is: is.emptyArray,
@ -146,7 +146,7 @@ const types = new Map<string, Test>([
[], [],
new Array() // eslint-disable-line @typescript-eslint/no-array-constructor new Array() // eslint-disable-line @typescript-eslint/no-array-constructor
], ],
typename: TypeName.Array, typename: 'Array',
typeDescription: AssertionTypeDescription.emptyArray typeDescription: AssertionTypeDescription.emptyArray
}], }],
['function', { ['function', {
@ -160,7 +160,7 @@ const types = new Map<string, Test>([
function * (): unknown {}, function * (): unknown {},
async function * (): unknown {} async function * (): unknown {}
], ],
typename: TypeName.Function typename: 'Function'
}], }],
['buffer', { ['buffer', {
is: is.buffer, is: is.buffer,
@ -168,7 +168,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
Buffer.from('🦄') Buffer.from('🦄')
], ],
typename: TypeName.Buffer typename: 'Buffer'
}], }],
['object', { ['object', {
is: is.object, is: is.object,
@ -177,7 +177,7 @@ const types = new Map<string, Test>([
{x: 1}, {x: 1},
Object.create({x: 1}) Object.create({x: 1})
], ],
typename: TypeName.Object typename: 'Object'
}], }],
['regExp', { ['regExp', {
is: is.regExp, is: is.regExp,
@ -186,7 +186,7 @@ const types = new Map<string, Test>([
/\w/, /\w/,
new RegExp('\\w') // eslint-disable-line prefer-regex-literals new RegExp('\\w') // eslint-disable-line prefer-regex-literals
], ],
typename: TypeName.RegExp typename: 'RegExp'
}], }],
['date', { ['date', {
is: is.date, is: is.date,
@ -194,7 +194,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Date() new Date()
], ],
typename: TypeName.Date typename: 'Date'
}], }],
['error', { ['error', {
is: is.error, is: is.error,
@ -203,7 +203,7 @@ const types = new Map<string, Test>([
new Error('🦄'), new Error('🦄'),
new ErrorSubclassFixture() new ErrorSubclassFixture()
], ],
typename: TypeName.Error typename: 'Error'
}], }],
['nativePromise', { ['nativePromise', {
is: is.nativePromise, is: is.nativePromise,
@ -212,7 +212,7 @@ const types = new Map<string, Test>([
Promise.resolve(), Promise.resolve(),
PromiseSubclassFixture.resolve() PromiseSubclassFixture.resolve()
], ],
typename: TypeName.Promise, typename: 'Promise',
typeDescription: AssertionTypeDescription.nativePromise typeDescription: AssertionTypeDescription.nativePromise
}], }],
['promise', { ['promise', {
@ -221,8 +221,8 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
{then() {}, catch() {}} {then() {}, catch() {}}
], ],
typename: TypeName.Object, typename: 'Object',
typeDescription: TypeName.Promise typeDescription: 'Promise'
}], }],
['generator', { ['generator', {
is: is.generator, is: is.generator,
@ -232,7 +232,7 @@ const types = new Map<string, Test>([
yield 4; yield 4;
})() })()
], ],
typename: TypeName.Generator typename: 'Generator'
}], }],
['asyncGenerator', { ['asyncGenerator', {
is: is.asyncGenerator, is: is.asyncGenerator,
@ -242,7 +242,7 @@ const types = new Map<string, Test>([
yield 4; yield 4;
})() })()
], ],
typename: TypeName.AsyncGenerator typename: 'AsyncGenerator'
}], }],
['generatorFunction', { ['generatorFunction', {
is: is.generatorFunction, is: is.generatorFunction,
@ -252,8 +252,8 @@ const types = new Map<string, Test>([
yield 4; yield 4;
} }
], ],
typename: TypeName.Function, typename: 'Function',
typeDescription: TypeName.GeneratorFunction typeDescription: 'GeneratorFunction'
}], }],
['asyncGeneratorFunction', { ['asyncGeneratorFunction', {
is: is.asyncGeneratorFunction, is: is.asyncGeneratorFunction,
@ -263,8 +263,8 @@ const types = new Map<string, Test>([
yield 4; yield 4;
} }
], ],
typename: TypeName.Function, typename: 'Function',
typeDescription: TypeName.AsyncGeneratorFunction typeDescription: 'AsyncGeneratorFunction'
}], }],
['asyncFunction', { ['asyncFunction', {
is: is.asyncFunction, is: is.asyncFunction,
@ -273,8 +273,8 @@ const types = new Map<string, Test>([
async function () {}, async function () {},
async () => {} async () => {}
], ],
typename: TypeName.Function, typename: 'Function',
typeDescription: TypeName.AsyncFunction typeDescription: 'AsyncFunction'
}], }],
['boundFunction', { ['boundFunction', {
is: is.boundFunction, is: is.boundFunction,
@ -283,7 +283,7 @@ const types = new Map<string, Test>([
() => {}, () => {},
function () {}.bind(null) // eslint-disable-line no-extra-bind function () {}.bind(null) // eslint-disable-line no-extra-bind
], ],
typename: TypeName.Function typename: 'Function'
}], }],
['map', { ['map', {
is: is.map, is: is.map,
@ -291,7 +291,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Map([['one', '1']]) new Map([['one', '1']])
], ],
typename: TypeName.Map typename: 'Map'
}], }],
['emptyMap', { ['emptyMap', {
is: is.emptyMap, is: is.emptyMap,
@ -299,7 +299,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Map() new Map()
], ],
typename: TypeName.Map, typename: 'Map',
typeDescription: AssertionTypeDescription.emptyMap typeDescription: AssertionTypeDescription.emptyMap
}], }],
['set', { ['set', {
@ -308,7 +308,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Set(['one']) new Set(['one'])
], ],
typename: TypeName.Set typename: 'Set'
}], }],
['emptySet', { ['emptySet', {
is: is.emptySet, is: is.emptySet,
@ -316,7 +316,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Set() new Set()
], ],
typename: TypeName.Set, typename: 'Set',
typeDescription: AssertionTypeDescription.emptySet typeDescription: AssertionTypeDescription.emptySet
}], }],
['weakSet', { ['weakSet', {
@ -325,7 +325,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new WeakSet() new WeakSet()
], ],
typename: TypeName.WeakSet typename: 'WeakSet'
}], }],
['weakMap', { ['weakMap', {
is: is.weakMap, is: is.weakMap,
@ -333,7 +333,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new WeakMap() new WeakMap()
], ],
typename: TypeName.WeakMap typename: 'WeakMap'
}], }],
['int8Array', { ['int8Array', {
is: is.int8Array, is: is.int8Array,
@ -341,7 +341,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Int8Array() new Int8Array()
], ],
typename: TypeName.Int8Array typename: 'Int8Array'
}], }],
['uint8Array', { ['uint8Array', {
is: is.uint8Array, is: is.uint8Array,
@ -349,7 +349,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Uint8Array() new Uint8Array()
], ],
typename: TypeName.Uint8Array typename: 'Uint8Array'
}], }],
['uint8ClampedArray', { ['uint8ClampedArray', {
is: is.uint8ClampedArray, is: is.uint8ClampedArray,
@ -357,7 +357,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Uint8ClampedArray() new Uint8ClampedArray()
], ],
typename: TypeName.Uint8ClampedArray typename: 'Uint8ClampedArray'
}], }],
['int16Array', { ['int16Array', {
is: is.int16Array, is: is.int16Array,
@ -365,7 +365,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Int16Array() new Int16Array()
], ],
typename: TypeName.Int16Array typename: 'Int16Array'
}], }],
['uint16Array', { ['uint16Array', {
is: is.uint16Array, is: is.uint16Array,
@ -373,7 +373,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Uint16Array() new Uint16Array()
], ],
typename: TypeName.Uint16Array typename: 'Uint16Array'
}], }],
['int32Array', { ['int32Array', {
is: is.int32Array, is: is.int32Array,
@ -381,7 +381,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Int32Array() new Int32Array()
], ],
typename: TypeName.Int32Array typename: 'Int32Array'
}], }],
['uint32Array', { ['uint32Array', {
is: is.uint32Array, is: is.uint32Array,
@ -389,7 +389,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Uint32Array() new Uint32Array()
], ],
typename: TypeName.Uint32Array typename: 'Uint32Array'
}], }],
['float32Array', { ['float32Array', {
is: is.float32Array, is: is.float32Array,
@ -397,7 +397,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Float32Array() new Float32Array()
], ],
typename: TypeName.Float32Array typename: 'Float32Array'
}], }],
['float64Array', { ['float64Array', {
is: is.float64Array, is: is.float64Array,
@ -405,7 +405,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new Float64Array() new Float64Array()
], ],
typename: TypeName.Float64Array typename: 'Float64Array'
}], }],
['bigInt64Array', { ['bigInt64Array', {
is: is.bigInt64Array, is: is.bigInt64Array,
@ -413,7 +413,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new BigInt64Array() new BigInt64Array()
], ],
typename: TypeName.BigInt64Array typename: 'BigInt64Array'
}], }],
['bigUint64Array', { ['bigUint64Array', {
is: is.bigUint64Array, is: is.bigUint64Array,
@ -421,7 +421,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new BigUint64Array() new BigUint64Array()
], ],
typename: TypeName.BigUint64Array typename: 'BigUint64Array'
}], }],
['arrayBuffer', { ['arrayBuffer', {
is: is.arrayBuffer, is: is.arrayBuffer,
@ -429,7 +429,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new ArrayBuffer(10) new ArrayBuffer(10)
], ],
typename: TypeName.ArrayBuffer typename: 'ArrayBuffer'
}], }],
['dataView', { ['dataView', {
is: is.dataView, is: is.dataView,
@ -437,7 +437,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
new DataView(new ArrayBuffer(10)) new DataView(new ArrayBuffer(10))
], ],
typename: TypeName.DataView typename: 'DataView'
}], }],
['nan', { ['nan', {
is: is.nan, is: is.nan,
@ -446,7 +446,7 @@ const types = new Map<string, Test>([
NaN, NaN,
Number.NaN Number.NaN
], ],
typename: TypeName.number, typename: 'number',
typeDescription: AssertionTypeDescription.nan typeDescription: AssertionTypeDescription.nan
}], }],
['nullOrUndefined', { ['nullOrUndefined', {
@ -466,7 +466,7 @@ const types = new Map<string, Test>([
Object.create(null), Object.create(null),
new Object() // eslint-disable-line no-new-object new Object() // eslint-disable-line no-new-object
], ],
typename: TypeName.Object, typename: 'Object',
typeDescription: AssertionTypeDescription.plainObject typeDescription: AssertionTypeDescription.plainObject
}], }],
['integer', { ['integer', {
@ -475,7 +475,7 @@ const types = new Map<string, Test>([
fixtures: [ fixtures: [
6 6
], ],
typename: TypeName.number, typename: 'number',
typeDescription: AssertionTypeDescription.integer typeDescription: AssertionTypeDescription.integer
}], }],
['safeInteger', { ['safeInteger', {
@ -485,7 +485,7 @@ const types = new Map<string, Test>([
(2 ** 53) - 1, (2 ** 53) - 1,
-(2 ** 53) + 1 -(2 ** 53) + 1
], ],
typename: TypeName.number, typename: 'number',
typeDescription: AssertionTypeDescription.safeInteger typeDescription: AssertionTypeDescription.safeInteger
}], }],
['domElement', { ['domElement', {
@ -521,7 +521,7 @@ const types = new Map<string, Test>([
new Subject(), new Subject(),
new ZenObservable(() => {}) new ZenObservable(() => {})
], ],
typename: TypeName.Observable typename: 'Observable'
}], }],
['nodeStream', { ['nodeStream', {
is: is.nodeStream, is: is.nodeStream,
@ -537,7 +537,7 @@ const types = new Map<string, Test>([
new Stream.Stream(), new Stream.Stream(),
new Stream.Writable() new Stream.Writable()
], ],
typename: TypeName.Object, typename: 'Object',
typeDescription: AssertionTypeDescription.nodeStream typeDescription: AssertionTypeDescription.nodeStream
}], }],
['infinite', { ['infinite', {
@ -547,7 +547,7 @@ const types = new Map<string, Test>([
Infinity, Infinity,
-Infinity -Infinity
], ],
typename: TypeName.number, typename: 'number',
typeDescription: AssertionTypeDescription.infinite typeDescription: AssertionTypeDescription.infinite
}] }]
]); ]);
@ -591,7 +591,7 @@ const testType = (t: ExecutionContext, type: string, exclude?: string[]) => {
} }
if (isTypeUnderTest && typename) { if (isTypeUnderTest && typename) {
t.is(is(fixture), typename); t.is<TypeName>(is(fixture), typename);
} }
} }
} }
@ -959,7 +959,7 @@ test('is.nullOrUndefined', t => {
}); });
test('is.primitive', t => { test('is.primitive', t => {
const primitives = [ const primitives: Primitive[] = [
undefined, undefined,
null, null,
'🦄', '🦄',
@ -1101,7 +1101,7 @@ test('is.class', t => {
}); });
test('is.typedArray', t => { test('is.typedArray', t => {
const typedArrays = [ const typedArrays: TypedArray[] = [
new Int8Array(), new Int8Array(),
new Uint8Array(), new Uint8Array(),
new Uint8ClampedArray(), new Uint8ClampedArray(),