From 3c847be5a042334e994d1e18158e9b9118cf1fba Mon Sep 17 00:00:00 2001 From: Sindre Sorhus Date: Mon, 4 Feb 2019 02:13:23 +0700 Subject: [PATCH] Improve the TypeScript types (#80) --- source/index.ts | 113 ++++++++++++++++++++++++------------------- source/tests/test.ts | 4 +- tslint.json | 5 +- 3 files changed, 70 insertions(+), 52 deletions(-) diff --git a/source/index.ts b/source/index.ts index e6d1cff..60a29a2 100644 --- a/source/index.ts +++ b/source/index.ts @@ -7,18 +7,8 @@ // tslint:disable-next-line const URLGlobal = typeof URL === 'undefined' ? require('url').URL : URL; -type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array; -type Primitive = null | undefined | string | number | boolean | Symbol; - -export interface ArrayLike { - length: number; -} - export type Class = new(...args: any[]) => T; -type DomElement = object & { nodeType: 1; nodeName: string }; -type NodeStream = object & { pipe: Function }; - export const enum TypeName { null = 'null', boolean = 'boolean', @@ -58,11 +48,9 @@ export const enum TypeName { const toString = Object.prototype.toString; const isOfType = (type: string) => (value: unknown): value is T => typeof value === type; -const isBuffer = (input: unknown): input is Buffer => !is.nullOrUndefined(input) && !is.nullOrUndefined((input as Buffer).constructor) && is.function_((input as Buffer).constructor.isBuffer) && (input as Buffer).constructor.isBuffer(input); const getObjectType = (value: unknown): TypeName | null => { const objectName = toString.call(value).slice(8, -1); - if (objectName) { return objectName as TypeName; } @@ -72,7 +60,8 @@ const getObjectType = (value: unknown): TypeName | null => { const isObjectOfType = (type: TypeName) => (value: unknown): value is T => getObjectType(value) === type; -function is(value: unknown): TypeName { // tslint:disable-line:only-arrow-functions +// tslint:disable-next-line: no-use-before-declare +function is(value: unknown): TypeName { switch (value) { case null: return TypeName.null; @@ -102,11 +91,11 @@ function is(value: unknown): TypeName { // tslint:disable-line:only-arrow-functi return TypeName.Observable; } - if (Array.isArray(value)) { + if (is.array(value)) { return TypeName.Array; } - if (isBuffer(value)) { + if (is.buffer(value)) { return TypeName.Buffer; } @@ -122,25 +111,24 @@ function is(value: unknown): TypeName { // tslint:disable-line:only-arrow-functi return TypeName.Object; } -// tslint:disable-next-line:strict-type-predicates +// tslint:disable-next-line: strict-type-predicates const isObject = (value: unknown): value is object => typeof value === 'object'; is.undefined = isOfType('undefined'); is.string = isOfType('string'); is.number = isOfType('number'); is.function_ = isOfType('function'); -// tslint:disable-next-line:strict-type-predicates +// tslint:disable-next-line: strict-type-predicates is.null_ = (value: unknown): value is null => value === null; is.class_ = (value: unknown): value is Class => is.function_(value) && value.toString().startsWith('class '); is.boolean = (value: unknown): value is boolean => value === true || value === false; -is.symbol = isOfType('symbol'); -// tslint:enable:variable-name +is.symbol = isOfType('symbol'); -is.numericString = (value: unknown): boolean => +is.numericString = (value: unknown): value is string => is.string(value) && value.length > 0 && !Number.isNaN(Number(value)); is.array = Array.isArray; -is.buffer = isBuffer; +is.buffer = (value: unknown): value is Buffer => !is.nullOrUndefined(value) && !is.nullOrUndefined((value as Buffer).constructor) && is.function_((value as Buffer).constructor.isBuffer) && (value as Buffer).constructor.isBuffer(value); is.nullOrUndefined = (value: unknown): value is null | undefined => is.null_(value) || is.undefined(value); is.object = (value: unknown): value is object => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value)); @@ -188,7 +176,7 @@ is.dataView = isObjectOfType(TypeName.DataView); is.directInstanceOf = (instance: unknown, klass: Class): instance is T => Object.getPrototypeOf(instance) === klass.prototype; is.urlInstance = (value: unknown): value is URL => isObjectOfType(TypeName.URL)(value); -is.urlString = (value: unknown) => { +is.urlString = (value: unknown): value is string => { if (!is.string(value)) { return false; } @@ -201,12 +189,15 @@ is.urlString = (value: unknown) => { } }; +// TODO: Use the `not` operator with a type guard here when it's available. +// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);` is.truthy = (value: unknown) => Boolean(value); +// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);` is.falsy = (value: unknown) => !value; is.nan = (value: unknown) => Number.isNaN(value as number); -const primitiveTypes = new Set([ +const primitiveTypeOfTypes = new Set([ 'undefined', 'string', 'number', @@ -214,12 +205,15 @@ const primitiveTypes = new Set([ 'symbol' ]); -is.primitive = (value: unknown): value is Primitive => is.null_(value) || primitiveTypes.has(typeof value); +// TODO: This should be able to be `not object` when the `not` operator is out +export type Primitive = null | undefined | string | number | 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.safeInteger = (value: unknown): value is number => Number.isSafeInteger(value as number); -is.plainObject = (value: unknown) => { +is.plainObject = (value: unknown): value is {[key: string]: unknown} => { // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js let prototype; @@ -240,9 +234,10 @@ const typedArrayTypes = new Set([ TypeName.Float64Array ]); +export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array; + is.typedArray = (value: unknown): value is TypedArray => { const objectType = getObjectType(value); - if (objectType === null) { return false; } @@ -250,10 +245,15 @@ is.typedArray = (value: unknown): value is TypedArray => { return typedArrayTypes.has(objectType); }; -const isValidLength = (value: unknown) => is.safeInteger(value) && value > -1; -is.arrayLike = (value: unknown): value is ArrayLike => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength((value as ArrayLike).length); +export interface ArrayLike { + readonly length: number; + readonly [index: number]: T; +} -is.inRange = (value: number, range: number | number[]) => { +const isValidLength = (value: unknown) => is.safeInteger(value) && value >= 0; +is.arrayLike = (value: unknown): value is ArrayLike => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength((value as ArrayLike).length); + +is.inRange = (value: number, range: number | number[]): value is number => { if (is.number(range)) { return value >= Math.min(0, range) && value <= Math.max(range, 0); } @@ -274,10 +274,15 @@ const DOM_PROPERTIES_TO_CHECK = [ 'nodeValue' ]; -is.domElement = (value: unknown): value is DomElement => is.object(value) && (value as DomElement).nodeType === NODE_TYPE_ELEMENT && is.string((value as DomElement).nodeName) && - !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in (value as DomElement)); +is.domElement = (value: unknown): value is Element => is.object(value) && (value as Element).nodeType === NODE_TYPE_ELEMENT && is.string((value as Element).nodeName) && + !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in (value as Element)); -is.observable = (value: unknown) => { +export interface ObservableLike { + subscribe(observer: (value: unknown) => void): void; + [Symbol.observable](): ObservableLike; +} + +is.observable = (value: unknown): value is ObservableLike => { if (!value) { return false; } @@ -293,34 +298,44 @@ is.observable = (value: unknown) => { return false; }; +export type NodeStream = object & {readonly pipe: Function}; + is.nodeStream = (value: unknown): value is NodeStream => !is.nullOrUndefined(value) && isObject(value) as unknown && is.function_((value as NodeStream).pipe) && !is.observable(value); -is.infinite = (value: unknown) => value === Infinity || value === -Infinity; +is.infinite = (value: unknown): value is number => value === Infinity || value === -Infinity; -const isAbsoluteMod2 = (rem: number) => (value: number) => is.integer(value) && Math.abs(value % 2) === rem; +const isAbsoluteMod2 = (rem: number) => (value: number): value is number => is.integer(value) && Math.abs(value % 2) === rem; is.evenInteger = isAbsoluteMod2(0); is.oddInteger = isAbsoluteMod2(1); +is.emptyArray = (value: unknown): value is never[] => is.array(value) && value.length === 0; +is.nonEmptyArray = (value: unknown): value is unknown[] => is.array(value) && value.length > 0; + +is.emptyString = (value: unknown): value is '' => is.string(value) && value.length === 0; + +// TODO: Use `not ''` when the `not` operator is available. +is.nonEmptyString = (value: unknown): value is string => is.string(value) && value.length > 0; + const isWhiteSpaceString = (value: unknown) => is.string(value) && /\S/.test(value) === false; +is.emptyStringOrWhitespace = (value: unknown): value is string => is.emptyString(value) || isWhiteSpaceString(value); -is.emptyArray = (value: unknown) => is.array(value) && value.length === 0; -is.nonEmptyArray = (value: unknown) => is.array(value) && value.length > 0; +is.emptyObject = (value: unknown): value is {[key: string]: never} => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0; -is.emptyString = (value: unknown) => is.string(value) && value.length === 0; -is.nonEmptyString = (value: unknown) => is.string(value) && value.length > 0; -is.emptyStringOrWhitespace = (value: unknown) => is.emptyString(value) || isWhiteSpaceString(value); +// TODO: Use `not` operator here to remove `Map` and `Set` from type guard: +// - https://github.com/Microsoft/TypeScript/pull/29317 +is.nonEmptyObject = (value: unknown): value is {[key: string]: unknown} => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0; -is.emptyObject = (value: unknown) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0; -is.nonEmptyObject = (value: unknown) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0; +is.emptySet = (value: unknown): value is Set => is.set(value) && value.size === 0; +is.nonEmptySet = (value: unknown): value is Set => is.set(value) && value.size > 0; -is.emptySet = (value: unknown) => is.set(value) && value.size === 0; -is.nonEmptySet = (value: unknown) => is.set(value) && value.size > 0; +is.emptyMap = (value: unknown): value is Map => is.map(value) && value.size === 0; +is.nonEmptyMap = (value: unknown): value is Map => is.map(value) && value.size > 0; -is.emptyMap = (value: unknown) => is.map(value) && value.size === 0; -is.nonEmptyMap = (value: unknown) => is.map(value) && value.size > 0; +export type Predicate = (value: unknown) => boolean; type ArrayMethod = (fn: (value: unknown, index: number, array: unknown[]) => boolean, thisArg?: unknown) => boolean; -const predicateOnArray = (method: ArrayMethod, predicate: unknown, values: unknown[]) => { + +const predicateOnArray = (method: ArrayMethod, predicate: Predicate, values: unknown[]) => { if (is.function_(predicate) === false) { throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`); } @@ -329,12 +344,12 @@ const predicateOnArray = (method: ArrayMethod, predicate: unknown, values: unkno throw new TypeError('Invalid number of values'); } - return method.call(values, predicate as any); + return method.call(values, predicate); }; // tslint:disable variable-name -is.any = (predicate: unknown, ...values: unknown[]) => predicateOnArray(Array.prototype.some, predicate, values); -is.all = (predicate: unknown, ...values: unknown[]) => predicateOnArray(Array.prototype.every, predicate, values); +is.any = (predicate: Predicate, ...values: unknown[]): boolean => predicateOnArray(Array.prototype.some, predicate, values); +is.all = (predicate: Predicate, ...values: unknown[]): boolean => predicateOnArray(Array.prototype.every, predicate, values); // tslint:enable variable-name // Some few keywords are reserved, but we'll populate them for Node.js users diff --git a/source/tests/test.ts b/source/tests/test.ts index 1fcd976..8342b54 100644 --- a/source/tests/test.ts +++ b/source/tests/test.ts @@ -867,7 +867,7 @@ test('is.any', t => { t.false(is.any(is.integer, true, 'lol', {})); t.throws(() => { - is.any(null, true); + is.any(null as any, true); }); t.throws(() => { @@ -882,7 +882,7 @@ test('is.all', t => { t.false(is.all(is.set, new Map(), {})); t.throws(() => { - is.all(null, true); + is.all(null as any, true); }); t.throws(() => { diff --git a/tslint.json b/tslint.json index 55e9f36..6f6ad0e 100644 --- a/tslint.json +++ b/tslint.json @@ -1,3 +1,6 @@ { - "extends": "tslint-xo" + "extends": "tslint-xo", + "rules": { + "interface-over-type-literal": false + } }