From 6824f1446d9fdba6bd46e3052bda1c2be8d5403c Mon Sep 17 00:00:00 2001 From: Bjorn Stromberg Date: Thu, 4 Jun 2020 20:24:47 +0900 Subject: [PATCH] Use string literals instead of enums --- source/index.ts | 323 ++++++++++++++++++++++-------------------------- test/test.ts | 116 ++++++++--------- 2 files changed, 205 insertions(+), 234 deletions(-) diff --git a/source/index.ts b/source/index.ts index 9c6d8cf..48c4a0d 100644 --- a/source/index.ts +++ b/source/index.ts @@ -4,49 +4,73 @@ export type Class = new (...args: any[]) => T; -export const enum TypeName { - null = 'null', - boolean = 'boolean', - undefined = 'undefined', - string = 'string', - number = 'number', - bigint = 'bigint', - symbol = 'symbol', - Function = 'Function', - Generator = 'Generator', - AsyncGenerator = 'AsyncGenerator', - GeneratorFunction = 'GeneratorFunction', - AsyncGeneratorFunction = 'AsyncGeneratorFunction', - AsyncFunction = 'AsyncFunction', - Observable = 'Observable', - Array = 'Array', - Buffer = 'Buffer', - Object = 'Object', - RegExp = 'RegExp', - Date = 'Date', - Error = 'Error', - Map = 'Map', - Set = 'Set', - WeakMap = 'WeakMap', - WeakSet = 'WeakSet', - Int8Array = 'Int8Array', - Uint8Array = 'Uint8Array', - Uint8ClampedArray = 'Uint8ClampedArray', - Int16Array = 'Int16Array', - Uint16Array = 'Uint16Array', - Int32Array = 'Int32Array', - Uint32Array = 'Uint32Array', - Float32Array = 'Float32Array', - Float64Array = 'Float64Array', - BigInt64Array = 'BigInt64Array', - BigUint64Array = 'BigUint64Array', - ArrayBuffer = 'ArrayBuffer', - SharedArrayBuffer = 'SharedArrayBuffer', - DataView = 'DataView', - Promise = 'Promise', - URL = 'URL' +const objectTypeNames = [ + 'Function', + 'Generator', + 'AsyncGenerator', + 'GeneratorFunction', + 'AsyncGeneratorFunction', + 'AsyncFunction', + 'Observable', + 'Array', + 'Buffer', + 'Object', + 'RegExp', + 'Date', + 'Error', + 'Map', + 'Set', + 'WeakMap', + 'WeakSet', + 'ArrayBuffer', + 'SharedArrayBuffer', + 'DataView', + 'Promise', + 'URL' +] as const; + +type ObjectTypeName = typeof objectTypeNames[number]; + +const primitives = { + null: null, + undefined, + string: String(), + number: Number(), + bigint: BigInt(0), + boolean: Boolean(), + symbol: Symbol('') +} as const; + +type PrimitiveTypeName = keyof typeof primitives; +export type Primitive = typeof primitives[PrimitiveTypeName]; + +function isPrimitiveTypeName(name: string): name is PrimitiveTypeName { + return Object.prototype.hasOwnProperty.call(primitives, name); } +const typedArrays = { + Int8Array: new Int8Array(), + Uint8Array: new Uint8Array(), + Uint8ClampedArray: new Uint8ClampedArray(), + Int16Array: new Int16Array(), + Uint16Array: new Uint16Array(), + Int32Array: new Int32Array(), + Uint32Array: new Uint32Array(), + Float32Array: new Float32Array(), + Float64Array: new Float64Array(), + BigInt64Array: new BigInt64Array(), + BigUint64Array: new BigUint64Array() +} as const; + +type TypedArrayTypeName = keyof typeof typedArrays; +export type TypedArray = typeof typedArrays[TypedArrayTypeName]; + +function isTypedArrayName(value: any): value is TypedArrayTypeName { + return Object.prototype.hasOwnProperty.call(typedArrays, value); +} + +export type TypeName = ObjectTypeName | PrimitiveTypeName | TypedArrayTypeName; + const {toString} = Object.prototype; const isOfType = (type: string) => (value: unknown): value is T => typeof value === type; @@ -64,41 +88,41 @@ const isObjectOfType = (type: TypeName) => (value: unknown): value is T => ge function is(value: unknown): TypeName { switch (value) { case null: - return TypeName.null; + return 'null'; case true: case false: - return TypeName.boolean; + return 'boolean'; default: } switch (typeof value) { case 'undefined': - return TypeName.undefined; + return 'undefined'; case 'string': - return TypeName.string; + return 'string'; case 'number': - return TypeName.number; + return 'number'; case 'bigint': - return TypeName.bigint; + return 'bigint'; case 'symbol': - return TypeName.symbol; + return 'symbol'; default: } if (is.function_(value)) { - return TypeName.Function; + return 'Function'; } if (is.observable(value)) { - return TypeName.Observable; + return 'Observable'; } if (is.array(value)) { - return TypeName.Array; + return 'Array'; } if (is.buffer(value)) { - return TypeName.Buffer; + return 'Buffer'; } const tagType = getObjectType(value); @@ -110,7 +134,7 @@ function is(value: unknown): TypeName { throw new TypeError('Please don\'t use object wrappers for primitive types'); } - return TypeName.Object; + return 'Object'; } is.undefined = isOfType('undefined'); @@ -146,7 +170,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.nativePromise = (value: unknown): value is Promise => - isObjectOfType>(TypeName.Promise)(value); + isObjectOfType>('Promise')(value); const hasPromiseAPI = (value: unknown): value is Promise => is.function_((value as Promise)?.then) && @@ -154,41 +178,41 @@ const hasPromiseAPI = (value: unknown): value is Promise => is.promise = (value: unknown): value is Promise => is.nativePromise(value) || hasPromiseAPI(value); -is.generatorFunction = isObjectOfType(TypeName.GeneratorFunction); +is.generatorFunction = isObjectOfType('GeneratorFunction'); -is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise) => getObjectType(value) === TypeName.AsyncGeneratorFunction; +is.asyncGeneratorFunction = (value: unknown): value is ((...args: any[]) => Promise) => getObjectType(value) === 'AsyncGeneratorFunction'; -is.asyncFunction = (value: unknown): value is ((...args: any[]) => Promise) => getObjectType(value) === TypeName.AsyncFunction; +is.asyncFunction = (value: unknown): value is ((...args: any[]) => Promise) => getObjectType(value) === 'AsyncFunction'; // 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.regExp = isObjectOfType(TypeName.RegExp); -is.date = isObjectOfType(TypeName.Date); -is.error = isObjectOfType(TypeName.Error); -is.map = (value: unknown): value is Map => isObjectOfType>(TypeName.Map)(value); -is.set = (value: unknown): value is Set => isObjectOfType>(TypeName.Set)(value); -is.weakMap = (value: unknown): value is WeakMap => isObjectOfType>(TypeName.WeakMap)(value); -is.weakSet = (value: unknown): value is WeakSet => isObjectOfType>(TypeName.WeakSet)(value); +is.regExp = isObjectOfType('RegExp'); +is.date = isObjectOfType('Date'); +is.error = isObjectOfType('Error'); +is.map = (value: unknown): value is Map => isObjectOfType>('Map')(value); +is.set = (value: unknown): value is Set => isObjectOfType>('Set')(value); +is.weakMap = (value: unknown): value is WeakMap => isObjectOfType>('WeakMap')(value); +is.weakSet = (value: unknown): value is WeakSet => isObjectOfType>('WeakSet')(value); -is.int8Array = isObjectOfType(TypeName.Int8Array); -is.uint8Array = isObjectOfType(TypeName.Uint8Array); -is.uint8ClampedArray = isObjectOfType(TypeName.Uint8ClampedArray); -is.int16Array = isObjectOfType(TypeName.Int16Array); -is.uint16Array = isObjectOfType(TypeName.Uint16Array); -is.int32Array = isObjectOfType(TypeName.Int32Array); -is.uint32Array = isObjectOfType(TypeName.Uint32Array); -is.float32Array = isObjectOfType(TypeName.Float32Array); -is.float64Array = isObjectOfType(TypeName.Float64Array); -is.bigInt64Array = isObjectOfType(TypeName.BigInt64Array); -is.bigUint64Array = isObjectOfType(TypeName.BigUint64Array); +is.int8Array = isObjectOfType('Int8Array'); +is.uint8Array = isObjectOfType('Uint8Array'); +is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray'); +is.int16Array = isObjectOfType('Int16Array'); +is.uint16Array = isObjectOfType('Uint16Array'); +is.int32Array = isObjectOfType('Int32Array'); +is.uint32Array = isObjectOfType('Uint32Array'); +is.float32Array = isObjectOfType('Float32Array'); +is.float64Array = isObjectOfType('Float64Array'); +is.bigInt64Array = isObjectOfType('BigInt64Array'); +is.bigUint64Array = isObjectOfType('BigUint64Array'); -is.arrayBuffer = isObjectOfType(TypeName.ArrayBuffer); -is.sharedArrayBuffer = isObjectOfType(TypeName.SharedArrayBuffer); -is.dataView = isObjectOfType(TypeName.DataView); +is.arrayBuffer = isObjectOfType('ArrayBuffer'); +is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer'); +is.dataView = isObjectOfType('DataView'); is.directInstanceOf = (instance: unknown, class_: Class): instance is T => Object.getPrototypeOf(instance) === class_.prototype; -is.urlInstance = (value: unknown): value is URL => isObjectOfType(TypeName.URL)(value); +is.urlInstance = (value: unknown): value is URL => isObjectOfType('URL')(value); is.urlString = (value: unknown): value is string => { if (!is.string(value)) { @@ -211,33 +235,14 @@ is.falsy = (value: unknown) => !value; is.nan = (value: unknown) => Number.isNaN(value as number); -const primitiveTypeOfTypes = new Set([ - '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.primitive = (value: unknown): value is Primitive => is.null_(value) || isPrimitiveTypeName(typeof value); 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.plainObject = (value: unknown): value is Record => { // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js - if (getObjectType(value) !== TypeName.Object) { + if (getObjectType(value) !== 'Object') { return false; } @@ -246,41 +251,7 @@ is.plainObject = (value: unknown): value is Record { - const objectType = getObjectType(value); - if (objectType === undefined) { - return false; - } - - return typedArrayTypes.has(objectType); -}; +is.typedArray = (value: unknown): value is TypedArray => isTypedArrayName(getObjectType(value)); export interface ArrayLike { readonly [index: number]: T; @@ -537,55 +508,55 @@ interface Assert { export const assert: Assert = { // Unknowns. - undefined: (value: unknown): asserts value is undefined => assertType(is.undefined(value), TypeName.undefined, value), - string: (value: unknown): asserts value is string => assertType(is.string(value), TypeName.string, value), - number: (value: unknown): asserts value is number => assertType(is.number(value), TypeName.number, value), - bigint: (value: unknown): asserts value is bigint => assertType(is.bigint(value), TypeName.bigint, 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), 'string', 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), 'bigint', value), // eslint-disable-next-line @typescript-eslint/ban-types - function_: (value: unknown): asserts value is Function => assertType(is.function_(value), TypeName.Function, value), - null_: (value: unknown): asserts value is null => assertType(is.null_(value), TypeName.null, 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), 'null', 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), - symbol: (value: unknown): asserts value is symbol => assertType(is.symbol(value), TypeName.symbol, 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), 'symbol', value), numericString: (value: unknown): asserts value is string => assertType(is.numericString(value), AssertionTypeDescription.numericString, value), - array: (value: unknown): asserts value is T[] => assertType(is.array(value), TypeName.Array, value), - buffer: (value: unknown): asserts value is Buffer => assertType(is.buffer(value), TypeName.Buffer, value), + array: (value: unknown): asserts value is T[] => assertType(is.array(value), 'Array', 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), - 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: (value: unknown): asserts value is Iterable => assertType(is.iterable(value), AssertionTypeDescription.iterable, value), asyncIterable: (value: unknown): asserts value is AsyncIterable => assertType(is.asyncIterable(value), AssertionTypeDescription.asyncIterable, value), - generator: (value: unknown): asserts value is Generator => assertType(is.generator(value), TypeName.Generator, value), - asyncGenerator: (value: unknown): asserts value is AsyncGenerator => assertType(is.asyncGenerator(value), TypeName.AsyncGenerator, 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), 'AsyncGenerator', value), nativePromise: (value: unknown): asserts value is Promise => assertType(is.nativePromise(value), AssertionTypeDescription.nativePromise, value), - promise: (value: unknown): asserts value is Promise => assertType(is.promise(value), TypeName.Promise, value), - generatorFunction: (value: unknown): asserts value is GeneratorFunction => assertType(is.generatorFunction(value), TypeName.GeneratorFunction, value), - asyncGeneratorFunction: (value: unknown): asserts value is AsyncGeneratorFunction => assertType(is.asyncGeneratorFunction(value), TypeName.AsyncGeneratorFunction, value), + promise: (value: unknown): asserts value is Promise => assertType(is.promise(value), 'Promise', 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), 'AsyncGeneratorFunction', value), // 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 - boundFunction: (value: unknown): asserts value is Function => assertType(is.boundFunction(value), TypeName.Function, value), - regExp: (value: unknown): asserts value is RegExp => assertType(is.regExp(value), TypeName.RegExp, value), - date: (value: unknown): asserts value is Date => assertType(is.date(value), TypeName.Date, value), - error: (value: unknown): asserts value is Error => assertType(is.error(value), TypeName.Error, value), - map: (value: unknown): asserts value is Map => assertType(is.map(value), TypeName.Map, value), - set: (value: unknown): asserts value is Set => assertType(is.set(value), TypeName.Set, value), - weakMap: (value: unknown): asserts value is WeakMap => assertType(is.weakMap(value), TypeName.WeakMap, value), - weakSet: (value: unknown): asserts value is WeakSet => assertType(is.weakSet(value), TypeName.WeakSet, value), - int8Array: (value: unknown): asserts value is Int8Array => assertType(is.int8Array(value), TypeName.Int8Array, value), - uint8Array: (value: unknown): asserts value is Uint8Array => assertType(is.uint8Array(value), TypeName.Uint8Array, value), - uint8ClampedArray: (value: unknown): asserts value is Uint8ClampedArray => assertType(is.uint8ClampedArray(value), TypeName.Uint8ClampedArray, value), - int16Array: (value: unknown): asserts value is Int16Array => assertType(is.int16Array(value), TypeName.Int16Array, value), - uint16Array: (value: unknown): asserts value is Uint16Array => assertType(is.uint16Array(value), TypeName.Uint16Array, value), - int32Array: (value: unknown): asserts value is Int32Array => assertType(is.int32Array(value), TypeName.Int32Array, value), - uint32Array: (value: unknown): asserts value is Uint32Array => assertType(is.uint32Array(value), TypeName.Uint32Array, value), - float32Array: (value: unknown): asserts value is Float32Array => assertType(is.float32Array(value), TypeName.Float32Array, value), - float64Array: (value: unknown): asserts value is Float64Array => assertType(is.float64Array(value), TypeName.Float64Array, value), - bigInt64Array: (value: unknown): asserts value is BigInt64Array => assertType(is.bigInt64Array(value), TypeName.BigInt64Array, value), - bigUint64Array: (value: unknown): asserts value is BigUint64Array => assertType(is.bigUint64Array(value), TypeName.BigUint64Array, value), - arrayBuffer: (value: unknown): asserts value is ArrayBuffer => assertType(is.arrayBuffer(value), TypeName.ArrayBuffer, value), - sharedArrayBuffer: (value: unknown): asserts value is SharedArrayBuffer => assertType(is.sharedArrayBuffer(value), TypeName.SharedArrayBuffer, value), - dataView: (value: unknown): asserts value is DataView => assertType(is.dataView(value), TypeName.DataView, value), - urlInstance: (value: unknown): asserts value is URL => assertType(is.urlInstance(value), TypeName.URL, 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), 'RegExp', 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), 'Error', value), + map: (value: unknown): asserts value is Map => assertType(is.map(value), 'Map', value), + set: (value: unknown): asserts value is Set => assertType(is.set(value), 'Set', value), + weakMap: (value: unknown): asserts value is WeakMap => assertType(is.weakMap(value), 'WeakMap', value), + weakSet: (value: unknown): asserts value is WeakSet => assertType(is.weakSet(value), 'WeakSet', 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), 'Uint8Array', 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), 'Int16Array', 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), 'Int32Array', 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), 'Float32Array', 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), 'BigInt64Array', 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), 'ArrayBuffer', 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), 'DataView', 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), 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), @@ -597,7 +568,7 @@ export const assert: Assert = { typedArray: (value: unknown): asserts value is TypedArray => assertType(is.typedArray(value), AssertionTypeDescription.typedArray, value), arrayLike: (value: unknown): asserts value is ArrayLike => assertType(is.arrayLike(value), AssertionTypeDescription.arrayLike, value), domElement: (value: unknown): asserts value is Element => 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), 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), diff --git a/test/test.ts b/test/test.ts index f540828..9b0d055 100644 --- a/test/test.ts +++ b/test/test.ts @@ -7,7 +7,7 @@ import {JSDOM} from 'jsdom'; import {Subject, Observable} from 'rxjs'; import tempy = require('tempy'); import ZenObservable = require('zen-observable'); -import is, {assert, AssertionTypeDescription, TypeName} from '../source'; +import is, {assert, AssertionTypeDescription, Primitive, TypedArray, TypeName} from '../source'; class PromiseSubclassFixture extends Promise {} class ErrorSubclassFixture extends Error {} @@ -47,7 +47,7 @@ const types = new Map([ fixtures: [ undefined ], - typename: TypeName.undefined + typename: 'undefined' }], ['null', { is: is.null_, @@ -55,7 +55,7 @@ const types = new Map([ fixtures: [ null ], - typename: TypeName.null + typename: 'null' }], ['string', { is: is.string, @@ -65,7 +65,7 @@ const types = new Map([ 'hello world', '' ], - typename: TypeName.string + typename: 'string' }], ['emptyString', { is: is.emptyString, @@ -74,7 +74,7 @@ const types = new Map([ '', String() ], - typename: TypeName.string, + typename: 'string', typeDescription: AssertionTypeDescription.emptyString }], ['number', { @@ -88,7 +88,7 @@ const types = new Map([ Infinity, -Infinity ], - typename: TypeName.number + typename: 'number' }], ['bigint', { is: is.bigint, @@ -100,7 +100,7 @@ const types = new Map([ // -0n, BigInt('1234') ], - typename: TypeName.bigint + typename: 'bigint' }], ['boolean', { is: is.boolean, @@ -108,7 +108,7 @@ const types = new Map([ fixtures: [ true, false ], - typename: TypeName.boolean + typename: 'boolean' }], ['symbol', { is: is.symbol, @@ -116,7 +116,7 @@ const types = new Map([ fixtures: [ Symbol('🦄') ], - typename: TypeName.symbol + typename: 'symbol' }], ['numericString', { is: is.numericString, @@ -127,7 +127,7 @@ const types = new Map([ 'Infinity', '0x56' ], - typename: TypeName.string, + typename: 'string', typeDescription: AssertionTypeDescription.numericString }], ['array', { @@ -137,7 +137,7 @@ const types = new Map([ [1, 2], new Array(2) ], - typename: TypeName.Array + typename: 'Array' }], ['emptyArray', { is: is.emptyArray, @@ -146,7 +146,7 @@ const types = new Map([ [], new Array() // eslint-disable-line @typescript-eslint/no-array-constructor ], - typename: TypeName.Array, + typename: 'Array', typeDescription: AssertionTypeDescription.emptyArray }], ['function', { @@ -160,7 +160,7 @@ const types = new Map([ function * (): unknown {}, async function * (): unknown {} ], - typename: TypeName.Function + typename: 'Function' }], ['buffer', { is: is.buffer, @@ -168,7 +168,7 @@ const types = new Map([ fixtures: [ Buffer.from('🦄') ], - typename: TypeName.Buffer + typename: 'Buffer' }], ['object', { is: is.object, @@ -177,7 +177,7 @@ const types = new Map([ {x: 1}, Object.create({x: 1}) ], - typename: TypeName.Object + typename: 'Object' }], ['regExp', { is: is.regExp, @@ -186,7 +186,7 @@ const types = new Map([ /\w/, new RegExp('\\w') // eslint-disable-line prefer-regex-literals ], - typename: TypeName.RegExp + typename: 'RegExp' }], ['date', { is: is.date, @@ -194,7 +194,7 @@ const types = new Map([ fixtures: [ new Date() ], - typename: TypeName.Date + typename: 'Date' }], ['error', { is: is.error, @@ -203,7 +203,7 @@ const types = new Map([ new Error('🦄'), new ErrorSubclassFixture() ], - typename: TypeName.Error + typename: 'Error' }], ['nativePromise', { is: is.nativePromise, @@ -212,7 +212,7 @@ const types = new Map([ Promise.resolve(), PromiseSubclassFixture.resolve() ], - typename: TypeName.Promise, + typename: 'Promise', typeDescription: AssertionTypeDescription.nativePromise }], ['promise', { @@ -221,8 +221,8 @@ const types = new Map([ fixtures: [ {then() {}, catch() {}} ], - typename: TypeName.Object, - typeDescription: TypeName.Promise + typename: 'Object', + typeDescription: 'Promise' }], ['generator', { is: is.generator, @@ -232,7 +232,7 @@ const types = new Map([ yield 4; })() ], - typename: TypeName.Generator + typename: 'Generator' }], ['asyncGenerator', { is: is.asyncGenerator, @@ -242,7 +242,7 @@ const types = new Map([ yield 4; })() ], - typename: TypeName.AsyncGenerator + typename: 'AsyncGenerator' }], ['generatorFunction', { is: is.generatorFunction, @@ -252,8 +252,8 @@ const types = new Map([ yield 4; } ], - typename: TypeName.Function, - typeDescription: TypeName.GeneratorFunction + typename: 'Function', + typeDescription: 'GeneratorFunction' }], ['asyncGeneratorFunction', { is: is.asyncGeneratorFunction, @@ -263,8 +263,8 @@ const types = new Map([ yield 4; } ], - typename: TypeName.Function, - typeDescription: TypeName.AsyncGeneratorFunction + typename: 'Function', + typeDescription: 'AsyncGeneratorFunction' }], ['asyncFunction', { is: is.asyncFunction, @@ -273,8 +273,8 @@ const types = new Map([ async function () {}, async () => {} ], - typename: TypeName.Function, - typeDescription: TypeName.AsyncFunction + typename: 'Function', + typeDescription: 'AsyncFunction' }], ['boundFunction', { is: is.boundFunction, @@ -283,7 +283,7 @@ const types = new Map([ () => {}, function () {}.bind(null) // eslint-disable-line no-extra-bind ], - typename: TypeName.Function + typename: 'Function' }], ['map', { is: is.map, @@ -291,7 +291,7 @@ const types = new Map([ fixtures: [ new Map([['one', '1']]) ], - typename: TypeName.Map + typename: 'Map' }], ['emptyMap', { is: is.emptyMap, @@ -299,7 +299,7 @@ const types = new Map([ fixtures: [ new Map() ], - typename: TypeName.Map, + typename: 'Map', typeDescription: AssertionTypeDescription.emptyMap }], ['set', { @@ -308,7 +308,7 @@ const types = new Map([ fixtures: [ new Set(['one']) ], - typename: TypeName.Set + typename: 'Set' }], ['emptySet', { is: is.emptySet, @@ -316,7 +316,7 @@ const types = new Map([ fixtures: [ new Set() ], - typename: TypeName.Set, + typename: 'Set', typeDescription: AssertionTypeDescription.emptySet }], ['weakSet', { @@ -325,7 +325,7 @@ const types = new Map([ fixtures: [ new WeakSet() ], - typename: TypeName.WeakSet + typename: 'WeakSet' }], ['weakMap', { is: is.weakMap, @@ -333,7 +333,7 @@ const types = new Map([ fixtures: [ new WeakMap() ], - typename: TypeName.WeakMap + typename: 'WeakMap' }], ['int8Array', { is: is.int8Array, @@ -341,7 +341,7 @@ const types = new Map([ fixtures: [ new Int8Array() ], - typename: TypeName.Int8Array + typename: 'Int8Array' }], ['uint8Array', { is: is.uint8Array, @@ -349,7 +349,7 @@ const types = new Map([ fixtures: [ new Uint8Array() ], - typename: TypeName.Uint8Array + typename: 'Uint8Array' }], ['uint8ClampedArray', { is: is.uint8ClampedArray, @@ -357,7 +357,7 @@ const types = new Map([ fixtures: [ new Uint8ClampedArray() ], - typename: TypeName.Uint8ClampedArray + typename: 'Uint8ClampedArray' }], ['int16Array', { is: is.int16Array, @@ -365,7 +365,7 @@ const types = new Map([ fixtures: [ new Int16Array() ], - typename: TypeName.Int16Array + typename: 'Int16Array' }], ['uint16Array', { is: is.uint16Array, @@ -373,7 +373,7 @@ const types = new Map([ fixtures: [ new Uint16Array() ], - typename: TypeName.Uint16Array + typename: 'Uint16Array' }], ['int32Array', { is: is.int32Array, @@ -381,7 +381,7 @@ const types = new Map([ fixtures: [ new Int32Array() ], - typename: TypeName.Int32Array + typename: 'Int32Array' }], ['uint32Array', { is: is.uint32Array, @@ -389,7 +389,7 @@ const types = new Map([ fixtures: [ new Uint32Array() ], - typename: TypeName.Uint32Array + typename: 'Uint32Array' }], ['float32Array', { is: is.float32Array, @@ -397,7 +397,7 @@ const types = new Map([ fixtures: [ new Float32Array() ], - typename: TypeName.Float32Array + typename: 'Float32Array' }], ['float64Array', { is: is.float64Array, @@ -405,7 +405,7 @@ const types = new Map([ fixtures: [ new Float64Array() ], - typename: TypeName.Float64Array + typename: 'Float64Array' }], ['bigInt64Array', { is: is.bigInt64Array, @@ -413,7 +413,7 @@ const types = new Map([ fixtures: [ new BigInt64Array() ], - typename: TypeName.BigInt64Array + typename: 'BigInt64Array' }], ['bigUint64Array', { is: is.bigUint64Array, @@ -421,7 +421,7 @@ const types = new Map([ fixtures: [ new BigUint64Array() ], - typename: TypeName.BigUint64Array + typename: 'BigUint64Array' }], ['arrayBuffer', { is: is.arrayBuffer, @@ -429,7 +429,7 @@ const types = new Map([ fixtures: [ new ArrayBuffer(10) ], - typename: TypeName.ArrayBuffer + typename: 'ArrayBuffer' }], ['dataView', { is: is.dataView, @@ -437,7 +437,7 @@ const types = new Map([ fixtures: [ new DataView(new ArrayBuffer(10)) ], - typename: TypeName.DataView + typename: 'DataView' }], ['nan', { is: is.nan, @@ -446,7 +446,7 @@ const types = new Map([ NaN, Number.NaN ], - typename: TypeName.number, + typename: 'number', typeDescription: AssertionTypeDescription.nan }], ['nullOrUndefined', { @@ -466,7 +466,7 @@ const types = new Map([ Object.create(null), new Object() // eslint-disable-line no-new-object ], - typename: TypeName.Object, + typename: 'Object', typeDescription: AssertionTypeDescription.plainObject }], ['integer', { @@ -475,7 +475,7 @@ const types = new Map([ fixtures: [ 6 ], - typename: TypeName.number, + typename: 'number', typeDescription: AssertionTypeDescription.integer }], ['safeInteger', { @@ -485,7 +485,7 @@ const types = new Map([ (2 ** 53) - 1, -(2 ** 53) + 1 ], - typename: TypeName.number, + typename: 'number', typeDescription: AssertionTypeDescription.safeInteger }], ['domElement', { @@ -521,7 +521,7 @@ const types = new Map([ new Subject(), new ZenObservable(() => {}) ], - typename: TypeName.Observable + typename: 'Observable' }], ['nodeStream', { is: is.nodeStream, @@ -537,7 +537,7 @@ const types = new Map([ new Stream.Stream(), new Stream.Writable() ], - typename: TypeName.Object, + typename: 'Object', typeDescription: AssertionTypeDescription.nodeStream }], ['infinite', { @@ -547,7 +547,7 @@ const types = new Map([ Infinity, -Infinity ], - typename: TypeName.number, + typename: 'number', typeDescription: AssertionTypeDescription.infinite }] ]); @@ -959,7 +959,7 @@ test('is.nullOrUndefined', t => { }); test('is.primitive', t => { - const primitives = [ + const primitives: Primitive[] = [ undefined, null, '🦄', @@ -1101,7 +1101,7 @@ test('is.class', t => { }); test('is.typedArray', t => { - const typedArrays = [ + const typedArrays: TypedArray[] = [ new Int8Array(), new Uint8Array(), new Uint8ClampedArray(),