forked from orbit-oss/is
Refactor module in TypeScript (#28)
This commit is contained in:
Lukas Tetzlaff
Sindre Sorhus
parent
83adc096ef
commit
8d8fd2b7e0
7 changed files with 602 additions and 375 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -1,2 +1,3 @@
|
|||
node_modules
|
||||
yarn.lock
|
||||
dist
|
||||
|
|
|
|||
227
index.js
227
index.js
|
|
@ -1,227 +0,0 @@
|
|||
'use strict';
|
||||
const util = require('util');
|
||||
|
||||
const toString = Object.prototype.toString;
|
||||
const getObjectType = x => toString.call(x).slice(8, -1);
|
||||
const isOfType = type => x => typeof x === type; // eslint-disable-line valid-typeof
|
||||
const isObjectOfType = type => x => getObjectType(x) === type;
|
||||
|
||||
const is = value => {
|
||||
if (value === null) {
|
||||
return 'null';
|
||||
}
|
||||
|
||||
if (value === true || value === false) {
|
||||
return 'boolean';
|
||||
}
|
||||
|
||||
const type = typeof value;
|
||||
|
||||
if (type === 'undefined') {
|
||||
return 'undefined';
|
||||
}
|
||||
|
||||
if (type === 'string') {
|
||||
return 'string';
|
||||
}
|
||||
|
||||
if (type === 'number') {
|
||||
return 'number';
|
||||
}
|
||||
|
||||
if (type === 'symbol') {
|
||||
return 'symbol';
|
||||
}
|
||||
|
||||
if (is.function(value)) {
|
||||
return 'Function';
|
||||
}
|
||||
|
||||
if (Array.isArray(value)) {
|
||||
return 'Array';
|
||||
}
|
||||
|
||||
if (Buffer.isBuffer(value)) {
|
||||
return 'Buffer';
|
||||
}
|
||||
|
||||
const tagType = getObjectType(value);
|
||||
if (tagType) {
|
||||
return tagType;
|
||||
}
|
||||
|
||||
if (value instanceof String || value instanceof Boolean || value instanceof Number) {
|
||||
throw new TypeError('Please don\'t use object wrappers for primitive types');
|
||||
}
|
||||
|
||||
return 'Object';
|
||||
};
|
||||
|
||||
is.undefined = isOfType('undefined');
|
||||
is.null = x => x === null;
|
||||
is.string = isOfType('string');
|
||||
is.number = isOfType('number');
|
||||
is.boolean = x => x === true || x === false;
|
||||
is.symbol = isOfType('symbol');
|
||||
|
||||
is.array = Array.isArray;
|
||||
is.function = isOfType('function');
|
||||
is.buffer = Buffer.isBuffer;
|
||||
|
||||
const isObject = x => typeof x === 'object';
|
||||
|
||||
is.object = x => !is.nullOrUndefined(x) && (is.function(x) || isObject(x));
|
||||
|
||||
is.nativePromise = isObjectOfType('Promise');
|
||||
|
||||
const hasPromiseAPI = x =>
|
||||
!is.null(x) &&
|
||||
isObject(x) &&
|
||||
is.function(x.then) &&
|
||||
is.function(x.catch);
|
||||
|
||||
is.promise = x => is.nativePromise(x) || hasPromiseAPI(x);
|
||||
|
||||
is.generator = x => is.iterable(x) && is.function(x.next) && is.function(x.throw);
|
||||
|
||||
// TODO: Change to use `isObjectOfType` once Node.js 6 or higher is targeted
|
||||
const isFunctionOfType = type => x => is.function(x) && is.function(x.constructor) && x.constructor.name === type;
|
||||
|
||||
is.generatorFunction = isFunctionOfType('GeneratorFunction');
|
||||
is.asyncFunction = isFunctionOfType('AsyncFunction');
|
||||
|
||||
is.regExp = isObjectOfType('RegExp');
|
||||
is.date = isObjectOfType('Date');
|
||||
is.error = isObjectOfType('Error');
|
||||
is.map = isObjectOfType('Map');
|
||||
is.set = isObjectOfType('Set');
|
||||
is.weakMap = isObjectOfType('WeakMap');
|
||||
is.weakSet = isObjectOfType('WeakSet');
|
||||
|
||||
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.arrayBuffer = isObjectOfType('ArrayBuffer');
|
||||
is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
|
||||
|
||||
is.truthy = x => !!x; // eslint-disable-line no-implicit-coercion
|
||||
is.falsy = x => !x;
|
||||
|
||||
is.nan = Number.isNaN;
|
||||
is.nullOrUndefined = x => is.null(x) || is.undefined(x);
|
||||
|
||||
const primitiveTypes = new Set([
|
||||
'undefined',
|
||||
'string',
|
||||
'number',
|
||||
'boolean',
|
||||
'symbol'
|
||||
]);
|
||||
is.primitive = x => is.null(x) || primitiveTypes.has(typeof x);
|
||||
|
||||
is.integer = Number.isInteger;
|
||||
is.safeInteger = Number.isSafeInteger;
|
||||
|
||||
is.plainObject = x => {
|
||||
// From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
|
||||
let prototype;
|
||||
// eslint-disable-next-line no-return-assign
|
||||
return getObjectType(x) === 'Object' &&
|
||||
(prototype = Object.getPrototypeOf(x), prototype === null ||
|
||||
prototype === Object.getPrototypeOf({}));
|
||||
};
|
||||
|
||||
is.iterable = x => !is.nullOrUndefined(x) && is.function(x[Symbol.iterator]);
|
||||
|
||||
is.class = x => is.function(x) && x.toString().startsWith('class ');
|
||||
|
||||
const typedArrayTypes = new Set([
|
||||
'Int8Array',
|
||||
'Uint8Array',
|
||||
'Uint8ClampedArray',
|
||||
'Int16Array',
|
||||
'Uint16Array',
|
||||
'Int32Array',
|
||||
'Uint32Array',
|
||||
'Float32Array',
|
||||
'Float64Array'
|
||||
]);
|
||||
is.typedArray = x => typedArrayTypes.has(getObjectType(x));
|
||||
|
||||
const isValidLength = x => is.safeInteger(x) && x > -1;
|
||||
is.arrayLike = x => !is.nullOrUndefined(x) && !is.function(x) && isValidLength(x.length);
|
||||
|
||||
is.inRange = (x, range) => {
|
||||
if (is.number(range)) {
|
||||
return x >= Math.min(0, range) && x <= Math.max(range, 0);
|
||||
}
|
||||
|
||||
if (is.array(range) && range.length === 2) {
|
||||
// TODO: Use spread operator here when targeting Node.js 6 or higher
|
||||
return x >= Math.min.apply(null, range) && x <= Math.max.apply(null, range);
|
||||
}
|
||||
|
||||
throw new TypeError(`Invalid range: ${util.inspect(range)}`);
|
||||
};
|
||||
|
||||
const NODE_TYPE_ELEMENT = 1;
|
||||
const DOM_PROPERTIES_TO_CHECK = [
|
||||
'innerHTML',
|
||||
'ownerDocument',
|
||||
'style',
|
||||
'attributes',
|
||||
'nodeValue'
|
||||
];
|
||||
|
||||
is.domElement = x => is.object(x) && x.nodeType === NODE_TYPE_ELEMENT && is.string(x.nodeName) &&
|
||||
!is.plainObject(x) && DOM_PROPERTIES_TO_CHECK.every(property => property in x);
|
||||
|
||||
is.infinite = x => x === Infinity || x === -Infinity;
|
||||
|
||||
const isAbsoluteMod2 = value => x => is.integer(x) && Math.abs(x % 2) === value;
|
||||
is.even = isAbsoluteMod2(0);
|
||||
is.odd = isAbsoluteMod2(1);
|
||||
|
||||
const isWhiteSpaceString = x => is.string(x) && /\S/.test(x) === false;
|
||||
const isEmptyStringOrArray = x => (is.string(x) || is.array(x)) && x.length === 0;
|
||||
const isEmptyObject = x => !is.map(x) && !is.set(x) && is.object(x) && Object.keys(x).length === 0;
|
||||
const isEmptyMapOrSet = x => (is.map(x) || is.set(x)) && x.size === 0;
|
||||
|
||||
is.empty = x => is.falsy(x) || isEmptyStringOrArray(x) || isEmptyObject(x) || isEmptyMapOrSet(x);
|
||||
is.emptyOrWhitespace = x => is.empty(x) || isWhiteSpaceString(x);
|
||||
|
||||
const predicateOnArray = (method, predicate, values) => {
|
||||
// `values` is the calling function's "arguments object".
|
||||
// We have to do it this way to keep node v4 support.
|
||||
// So here we convert it to an array and slice off the first item.
|
||||
values = Array.prototype.slice.call(values, 1);
|
||||
|
||||
if (is.function(predicate) === false) {
|
||||
throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
|
||||
}
|
||||
|
||||
if (values.length === 0) {
|
||||
throw new TypeError(`Invalid number of values`);
|
||||
}
|
||||
|
||||
return method.call(values, predicate);
|
||||
};
|
||||
|
||||
// We have to use anonymous functions for the any() and all() methods
|
||||
// to get the arguments since we can't use rest parameters in node v4.
|
||||
is.any = function (predicate) {
|
||||
return predicateOnArray(Array.prototype.some, predicate, arguments);
|
||||
};
|
||||
|
||||
is.all = function (predicate) {
|
||||
return predicateOnArray(Array.prototype.every, predicate, arguments);
|
||||
};
|
||||
|
||||
module.exports = is;
|
||||
16
package.json
16
package.json
|
|
@ -16,10 +16,15 @@
|
|||
"node": ">=4"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "xo && ava"
|
||||
"lint": "tslint --project .",
|
||||
"build": "tsc",
|
||||
"test": "npm run lint && npm run build && ava dist/tests",
|
||||
"prepublish": "npm run build && del dist/tests"
|
||||
},
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": [
|
||||
"index.js"
|
||||
"dist"
|
||||
],
|
||||
"keywords": [
|
||||
"type",
|
||||
|
|
@ -43,8 +48,13 @@
|
|||
"compare"
|
||||
],
|
||||
"devDependencies": {
|
||||
"@types/jsdom": "^2.0.31",
|
||||
"@types/node": "^8.0.47",
|
||||
"ava": "*",
|
||||
"del-cli": "^1.1.0",
|
||||
"jsdom": "^9.12.0",
|
||||
"xo": "*"
|
||||
"tslint": "^5.8.0",
|
||||
"tslint-xo": "^0.2.1",
|
||||
"typescript": "^2.6.1"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
243
source/index.ts
Normal file
243
source/index.ts
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
import * as util from 'util';
|
||||
|
||||
const toString = Object.prototype.toString;
|
||||
const getObjectType = (value: any) => toString.call(value).slice(8, -1) as string;
|
||||
const isOfType = (type: string) => (value: any) => typeof value === type; // tslint:disable-line
|
||||
const isObjectOfType = (type: string) => (value: any) => getObjectType(value) === type;
|
||||
|
||||
function is(value: any) { // tslint:disable-line:only-arrow-functions
|
||||
if (value === null) {
|
||||
return 'null';
|
||||
}
|
||||
|
||||
if (value === true || value === false) {
|
||||
return 'boolean';
|
||||
}
|
||||
|
||||
const type = typeof value;
|
||||
|
||||
if (type === 'undefined') {
|
||||
return 'undefined';
|
||||
}
|
||||
|
||||
if (type === 'string') {
|
||||
return 'string';
|
||||
}
|
||||
|
||||
if (type === 'number') {
|
||||
return 'number';
|
||||
}
|
||||
|
||||
if (type === 'symbol') {
|
||||
return 'symbol';
|
||||
}
|
||||
|
||||
if (is.function_(value)) {
|
||||
return 'Function';
|
||||
}
|
||||
|
||||
if (Array.isArray(value)) {
|
||||
return 'Array';
|
||||
}
|
||||
|
||||
if (Buffer.isBuffer(value)) {
|
||||
return 'Buffer';
|
||||
}
|
||||
|
||||
const tagType = getObjectType(value);
|
||||
if (tagType) {
|
||||
return tagType;
|
||||
}
|
||||
|
||||
if (value instanceof String || value instanceof Boolean || value instanceof Number) {
|
||||
throw new TypeError('Please don\'t use object wrappers for primitive types');
|
||||
}
|
||||
|
||||
return 'Object';
|
||||
}
|
||||
|
||||
namespace is { // tslint:disable-line:no-namespace
|
||||
const isObject = (value: any) => typeof value === 'object';
|
||||
|
||||
// tslint:disable:variable-name
|
||||
export const undefined = isOfType('undefined');
|
||||
export const string = isOfType('string');
|
||||
export const number = isOfType('number');
|
||||
export const function_ = isOfType('function');
|
||||
export const null_ = (value: any) => value === null;
|
||||
|
||||
export const class_ = (value: any) => function_(value) && value.toString().startsWith('class ');
|
||||
export const boolean = (value: any) => value === true || value === false;
|
||||
// tslint:enable:variable-name
|
||||
|
||||
export const symbol = isOfType('symbol');
|
||||
|
||||
export const array = Array.isArray;
|
||||
export const buffer = Buffer.isBuffer;
|
||||
|
||||
export const nullOrUndefined = (value: any) => null_(value) || undefined(value);
|
||||
export const object = (value: any) => !nullOrUndefined(value) && (function_(value) || isObject(value));
|
||||
export const iterable = (value: any) => !nullOrUndefined(value) && function_(value[Symbol.iterator]);
|
||||
export const generator = (value: any) => iterable(value) && function_(value.next) && function_(value.throw);
|
||||
|
||||
export const nativePromise = isObjectOfType('Promise');
|
||||
|
||||
const hasPromiseAPI = (value: any) =>
|
||||
!null_(value) &&
|
||||
isObject(value) &&
|
||||
function_(value.then) &&
|
||||
function_(value.catch);
|
||||
|
||||
export const promise = (value: any) => nativePromise(value) || hasPromiseAPI(value);
|
||||
|
||||
// TODO: Change to use `isObjectOfType` once Node.js 6 or higher is targeted
|
||||
const isFunctionOfType = (type: string) => (value: any) => function_(value) && function_(value.constructor) && value.constructor.name === type;
|
||||
|
||||
export const generatorFunction = isFunctionOfType('GeneratorFunction');
|
||||
export const asyncFunction = isFunctionOfType('AsyncFunction');
|
||||
|
||||
export const regExp = isObjectOfType('RegExp');
|
||||
export const date = isObjectOfType('Date');
|
||||
export const error = isObjectOfType('Error');
|
||||
export const map = isObjectOfType('Map');
|
||||
export const set = isObjectOfType('Set');
|
||||
export const weakMap = isObjectOfType('WeakMap');
|
||||
export const weakSet = isObjectOfType('WeakSet');
|
||||
|
||||
export const int8Array = isObjectOfType('Int8Array');
|
||||
export const uint8Array = isObjectOfType('Uint8Array');
|
||||
export const uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
|
||||
export const int16Array = isObjectOfType('Int16Array');
|
||||
export const uint16Array = isObjectOfType('Uint16Array');
|
||||
export const int32Array = isObjectOfType('Int32Array');
|
||||
export const uint32Array = isObjectOfType('Uint32Array');
|
||||
export const float32Array = isObjectOfType('Float32Array');
|
||||
export const float64Array = isObjectOfType('Float64Array');
|
||||
|
||||
export const arrayBuffer = isObjectOfType('ArrayBuffer');
|
||||
export const sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
|
||||
|
||||
export const truthy = (value: any) => Boolean(value);
|
||||
export const falsy = (value: any) => !value;
|
||||
|
||||
export const nan = (value: any) => Number.isNaN(value);
|
||||
|
||||
const primitiveTypes = new Set([
|
||||
'undefined',
|
||||
'string',
|
||||
'number',
|
||||
'boolean',
|
||||
'symbol'
|
||||
]);
|
||||
|
||||
export const primitive = (value: any) => null_(value) || primitiveTypes.has(typeof value);
|
||||
|
||||
export const integer = (value: any) => Number.isInteger(value);
|
||||
export const safeInteger = (value: any) => Number.isSafeInteger(value);
|
||||
|
||||
export const plainObject = (value: any) => {
|
||||
// From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
|
||||
let prototype;
|
||||
|
||||
return getObjectType(value) === 'Object' &&
|
||||
(prototype = Object.getPrototypeOf(value), prototype === null || // tslint:disable-line:ban-comma-operator
|
||||
prototype === Object.getPrototypeOf({}));
|
||||
};
|
||||
|
||||
const typedArrayTypes = new Set([
|
||||
'Int8Array',
|
||||
'Uint8Array',
|
||||
'Uint8ClampedArray',
|
||||
'Int16Array',
|
||||
'Uint16Array',
|
||||
'Int32Array',
|
||||
'Uint32Array',
|
||||
'Float32Array',
|
||||
'Float64Array'
|
||||
]);
|
||||
export const typedArray = (value: any) => typedArrayTypes.has(getObjectType(value));
|
||||
|
||||
const isValidLength = (value: any) => safeInteger(value) && value > -1;
|
||||
export const arrayLike = (value: any) => !nullOrUndefined(value) && !function_(value) && isValidLength(value.length);
|
||||
|
||||
export const inRange = (value: number, range: number | number[]) => {
|
||||
if (number(range)) {
|
||||
return value >= Math.min(0, range as number) && value <= Math.max(range as number, 0);
|
||||
}
|
||||
|
||||
if (array(range) && range.length === 2) {
|
||||
// TODO: Use spread operator here when targeting Node.js 6 or higher
|
||||
return value >= Math.min.apply(null, range) && value <= Math.max.apply(null, range);
|
||||
}
|
||||
|
||||
throw new TypeError(`Invalid range: ${util.inspect(range)}`);
|
||||
};
|
||||
|
||||
const NODE_TYPE_ELEMENT = 1;
|
||||
const DOM_PROPERTIES_TO_CHECK = [
|
||||
'innerHTML',
|
||||
'ownerDocument',
|
||||
'style',
|
||||
'attributes',
|
||||
'nodeValue'
|
||||
];
|
||||
|
||||
export const domElement = (value: any) => object(value) && value.nodeType === NODE_TYPE_ELEMENT && string(value.nodeName) &&
|
||||
!plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
|
||||
|
||||
export const infinite = (value: any) => value === Infinity || value === -Infinity;
|
||||
|
||||
const isAbsoluteMod2 = (value: number) => (rem: number) => integer(rem) && Math.abs(rem % 2) === value;
|
||||
export const even = isAbsoluteMod2(0);
|
||||
export const odd = isAbsoluteMod2(1);
|
||||
|
||||
const isWhiteSpaceString = (value: any) => string(value) && /\S/.test(value) === false;
|
||||
const isEmptyStringOrArray = (value: any) => (string(value) || array(value)) && value.length === 0;
|
||||
const isEmptyObject = (value: any) => !map(value) && !set(value) && object(value) && Object.keys(value).length === 0;
|
||||
const isEmptyMapOrSet = (value: any) => (map(value) || set(value)) && value.size === 0;
|
||||
|
||||
export const empty = (value: any) => falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value);
|
||||
export const emptyOrWhitespace = (value: any) => empty(value) || isWhiteSpaceString(value);
|
||||
|
||||
type ArrayMethod = (fn: (value: any, index: number, arr: any[]) => boolean, thisArg?: any) => boolean;
|
||||
const predicateOnArray = (method: ArrayMethod, predicate: any, args: IArguments) => {
|
||||
// `args` is the calling function's "arguments object".
|
||||
// We have to do it this way to keep node v4 support.
|
||||
// So here we convert it to an array and slice off the first item.
|
||||
const values = Array.prototype.slice.call(args, 1);
|
||||
|
||||
if (function_(predicate) === false) {
|
||||
throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
|
||||
}
|
||||
|
||||
if (values.length === 0) {
|
||||
throw new TypeError('Invalid number of values');
|
||||
}
|
||||
|
||||
return method.call(values, predicate);
|
||||
};
|
||||
|
||||
// We can't use rest parameters in node v4 due to the lack of the spread operator.
|
||||
// Therefore We have to use anonymous functions for the any() and all() methods
|
||||
// tslint:disable:only-arrow-functions no-function-expression
|
||||
export function any(...predicate: any[]): any; // tslint:disable-line:variable-name
|
||||
export function any(predicate: any) {
|
||||
return predicateOnArray(Array.prototype.some, predicate, arguments);
|
||||
}
|
||||
|
||||
export function all(...predicate: any[]): any;
|
||||
export function all(predicate: any) {
|
||||
return predicateOnArray(Array.prototype.every, predicate, arguments);
|
||||
}
|
||||
// tslint:enable:only-arrow-functions no-function-expression
|
||||
}
|
||||
|
||||
// Some few keywords are reserved, but we'll populate them for the node-folks
|
||||
// See https://github.com/Microsoft/TypeScript/issues/2536
|
||||
Object.defineProperties(is, {
|
||||
class: {value: is.class_},
|
||||
function: {value: is.function_},
|
||||
null: {value: is.null_}
|
||||
});
|
||||
|
||||
export default is; // tslint:disable-line:no-default-export
|
||||
|
|
@ -1,133 +1,311 @@
|
|||
import util from 'util';
|
||||
import test from 'ava';
|
||||
import * as util from 'util';
|
||||
import test, {TestContext, Context} from 'ava';
|
||||
import {jsdom} from 'jsdom';
|
||||
import m from '.';
|
||||
import m from '..';
|
||||
|
||||
const isNode8orHigher = Number(process.versions.node.split('.')[0]) >= 8;
|
||||
|
||||
const PromiseSubclassFixture = class extends Promise {};
|
||||
const ErrorSubclassFixture = class extends Error {};
|
||||
// Currently out of order, see https://github.com/Microsoft/TypeScript/issues/15202 class PromiseSubclassFixture<T> extends Promise<T> {}
|
||||
class ErrorSubclassFixture extends Error {}
|
||||
|
||||
const document = jsdom();
|
||||
const createDomElement = el => document.createElement(el);
|
||||
const createDomElement = (el: string) => document.createElement(el);
|
||||
|
||||
const types = new Map([
|
||||
['undefined', undefined],
|
||||
['null', null],
|
||||
['string', [
|
||||
'🦄',
|
||||
'hello world',
|
||||
''
|
||||
]],
|
||||
['number', [
|
||||
6,
|
||||
1.4,
|
||||
0,
|
||||
-0,
|
||||
Infinity,
|
||||
-Infinity
|
||||
]],
|
||||
['boolean', [
|
||||
true,
|
||||
false
|
||||
]],
|
||||
['symbol', Symbol('🦄')],
|
||||
['array', [
|
||||
[1, 2],
|
||||
new Array(2)
|
||||
]],
|
||||
['function', [
|
||||
function foo() {}, // eslint-disable-line func-names
|
||||
function () {},
|
||||
() => {},
|
||||
async function () {},
|
||||
function * () {}
|
||||
]],
|
||||
['buffer', Buffer.from('🦄')],
|
||||
['object', [
|
||||
{x: 1},
|
||||
Object.create({x: 1})
|
||||
]],
|
||||
['regExp', [
|
||||
/\w/,
|
||||
new RegExp('\\w')
|
||||
]],
|
||||
['date', new Date()],
|
||||
['error', [
|
||||
new Error('🦄'),
|
||||
new ErrorSubclassFixture()
|
||||
]],
|
||||
['nativePromise', [
|
||||
Promise.resolve(),
|
||||
PromiseSubclassFixture.resolve()
|
||||
]],
|
||||
['promise', {then() {}, catch() {}}],
|
||||
['generator', (function * () {
|
||||
yield 4;
|
||||
})()],
|
||||
['generatorFunction', function * () {
|
||||
yield 4;
|
||||
interface Test {
|
||||
is(value: any): boolean;
|
||||
fixtures: any[];
|
||||
}
|
||||
|
||||
const types = new Map<string, Test>([
|
||||
['undefined', {
|
||||
is: m.undefined,
|
||||
fixtures: [
|
||||
undefined
|
||||
]
|
||||
}],
|
||||
['asyncFunction', [
|
||||
async function () {},
|
||||
async () => {}
|
||||
]],
|
||||
['map', new Map()],
|
||||
['set', new Set()],
|
||||
['weakMap', new WeakMap()],
|
||||
['int8Array', new Int8Array()],
|
||||
['uint8Array', new Uint8Array()],
|
||||
['uint8ClampedArray', new Uint8ClampedArray()],
|
||||
['uint16Array', new Uint16Array()],
|
||||
['int32Array', new Int32Array()],
|
||||
['uint32Array', new Uint32Array()],
|
||||
['float32Array', new Float32Array()],
|
||||
['float64Array', new Float64Array()],
|
||||
['arrayBuffer', new ArrayBuffer(10)],
|
||||
['nan', [
|
||||
NaN,
|
||||
Number.NaN
|
||||
]],
|
||||
['nullOrUndefined', [
|
||||
null,
|
||||
undefined
|
||||
]],
|
||||
['plainObject', [
|
||||
{x: 1},
|
||||
Object.create(null),
|
||||
new Object() // eslint-disable-line no-new-object
|
||||
]],
|
||||
['integer', 6],
|
||||
['safeInteger', [
|
||||
Math.pow(2, 53) - 1,
|
||||
-Math.pow(2, 53) + 1
|
||||
]],
|
||||
['domElement', [
|
||||
'div',
|
||||
'input',
|
||||
'span',
|
||||
'img',
|
||||
'canvas',
|
||||
'script'
|
||||
].map(createDomElement)],
|
||||
['non-domElements', [
|
||||
document.createTextNode('data'),
|
||||
document.createProcessingInstruction('xml-stylesheet', 'href="mycss.css" type="text/css"'),
|
||||
document.createComment('This is a comment'),
|
||||
document,
|
||||
document.implementation.createDocumentType('svg:svg', '-//W3C//DTD SVG 1.1//EN', 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'),
|
||||
document.createDocumentFragment()
|
||||
]],
|
||||
['infinite', [
|
||||
Infinity,
|
||||
-Infinity
|
||||
]]
|
||||
['null', {
|
||||
is: m.null_,
|
||||
fixtures: [
|
||||
null
|
||||
]
|
||||
}],
|
||||
['string', {
|
||||
is: m.string,
|
||||
fixtures: [
|
||||
'🦄',
|
||||
'hello world',
|
||||
''
|
||||
]
|
||||
}],
|
||||
['number', {
|
||||
is: m.number,
|
||||
fixtures: [
|
||||
6,
|
||||
1.4,
|
||||
0,
|
||||
-0,
|
||||
Infinity,
|
||||
-Infinity
|
||||
]
|
||||
}],
|
||||
['boolean', {
|
||||
is: m.boolean,
|
||||
fixtures: [
|
||||
true, false
|
||||
]
|
||||
}],
|
||||
['symbol', {
|
||||
is: m.symbol,
|
||||
fixtures: [
|
||||
Symbol('🦄')
|
||||
]
|
||||
}],
|
||||
['array', {
|
||||
is: m.array,
|
||||
fixtures: [
|
||||
[1, 2],
|
||||
new Array(2) // tslint:disable-line:prefer-array-literal
|
||||
]
|
||||
}],
|
||||
['function', {
|
||||
is: m.function_,
|
||||
fixtures: [
|
||||
// tslint:disable:no-empty no-unused-variable only-arrow-functions no-function-expression
|
||||
function foo() {}, // tslint:disable-line:no-unused
|
||||
function() {},
|
||||
() => {},
|
||||
async function() {},
|
||||
function *(): any {}
|
||||
// tslint:enable:no-empty no-unused-variable only-arrow-functions no-function-expression
|
||||
]
|
||||
}],
|
||||
['buffer', {
|
||||
is: m.buffer,
|
||||
fixtures: [
|
||||
Buffer.from('🦄')
|
||||
]
|
||||
}],
|
||||
['object', {
|
||||
is: m.object,
|
||||
fixtures: [
|
||||
{x: 1},
|
||||
Object.create({x: 1})
|
||||
]
|
||||
}],
|
||||
['regExp', {
|
||||
is: m.regExp,
|
||||
fixtures: [
|
||||
/\w/,
|
||||
new RegExp('\\w')
|
||||
]
|
||||
}],
|
||||
['date', {
|
||||
is: m.date,
|
||||
fixtures: [
|
||||
new Date()
|
||||
]
|
||||
}],
|
||||
['error', {
|
||||
is: m.error,
|
||||
fixtures: [
|
||||
new Error('🦄'),
|
||||
new ErrorSubclassFixture()
|
||||
]
|
||||
}],
|
||||
['nativePromise', {
|
||||
is: m.nativePromise,
|
||||
fixtures: [
|
||||
Promise.resolve(),
|
||||
// PromiseSubclassFixture.resolve()
|
||||
]
|
||||
}],
|
||||
['promise', {
|
||||
is: m.promise,
|
||||
fixtures: [
|
||||
{then() {}, catch() {}} // tslint:disable-line:no-empty
|
||||
]
|
||||
}],
|
||||
['generator', {
|
||||
is: m.generator,
|
||||
fixtures: [
|
||||
(function *() { yield 4; })() // tslint:disable-line
|
||||
]
|
||||
}],
|
||||
['generatorFunction', {
|
||||
is: m.generatorFunction,
|
||||
fixtures: [
|
||||
function *() { yield 4; } // tslint:disable-line
|
||||
]
|
||||
}],
|
||||
['asyncFunction', {
|
||||
is: m.asyncFunction,
|
||||
fixtures: [
|
||||
async function() {}, // tslint:disable-line:no-empty only-arrow-functions no-function-expression
|
||||
async () => {} // tslint:disable-line:no-empty
|
||||
]
|
||||
}],
|
||||
['map', {
|
||||
is: m.map,
|
||||
fixtures: [
|
||||
new Map()
|
||||
]
|
||||
}],
|
||||
['set', {
|
||||
is: m.set,
|
||||
fixtures: [
|
||||
new Set()
|
||||
]
|
||||
}],
|
||||
['weakSet', {
|
||||
is: m.weakSet,
|
||||
fixtures: [
|
||||
new WeakSet()
|
||||
]
|
||||
}],
|
||||
['weakMap', {
|
||||
is: m.weakMap,
|
||||
fixtures: [
|
||||
new WeakMap()
|
||||
]
|
||||
}],
|
||||
['int8Array', {
|
||||
is: m.int8Array,
|
||||
fixtures: [
|
||||
new Int8Array(0)
|
||||
]
|
||||
}],
|
||||
['uint8Array', {
|
||||
is: m.uint8Array,
|
||||
fixtures: [
|
||||
new Uint8Array(0)
|
||||
]
|
||||
}],
|
||||
['uint8ClampedArray', {
|
||||
is: m.uint8ClampedArray,
|
||||
fixtures: [
|
||||
new Uint8ClampedArray(0)
|
||||
]
|
||||
}],
|
||||
['int16Array', {
|
||||
is: m.int16Array,
|
||||
fixtures: [
|
||||
new Int16Array(0)
|
||||
]
|
||||
}],
|
||||
['uint16Array', {
|
||||
is: m.uint16Array,
|
||||
fixtures: [
|
||||
new Uint16Array(0)
|
||||
]
|
||||
}],
|
||||
['int32Array', {
|
||||
is: m.int32Array,
|
||||
fixtures: [
|
||||
new Int32Array(0)
|
||||
]
|
||||
}],
|
||||
['uint32Array', {
|
||||
is: m.uint32Array,
|
||||
fixtures: [
|
||||
new Uint32Array(0)
|
||||
]
|
||||
}],
|
||||
['float32Array', {
|
||||
is: m.float32Array,
|
||||
fixtures: [
|
||||
new Float32Array(0)
|
||||
]
|
||||
}],
|
||||
['float64Array', {
|
||||
is: m.float64Array,
|
||||
fixtures: [
|
||||
new Float64Array(0)
|
||||
]
|
||||
}],
|
||||
['arrayBuffer', {
|
||||
is: m.arrayBuffer,
|
||||
fixtures: [
|
||||
new ArrayBuffer(10)
|
||||
]
|
||||
}],
|
||||
['nan', {
|
||||
is: m.nan,
|
||||
fixtures: [
|
||||
NaN,
|
||||
Number.NaN
|
||||
]
|
||||
}],
|
||||
['nullOrUndefined', {
|
||||
is: m.nullOrUndefined,
|
||||
fixtures: [
|
||||
null,
|
||||
undefined
|
||||
]
|
||||
}],
|
||||
['plainObject', {
|
||||
is: m.plainObject,
|
||||
fixtures: [
|
||||
{x: 1},
|
||||
Object.create(null),
|
||||
new Object()
|
||||
]
|
||||
}],
|
||||
['integer', {
|
||||
is: m.integer,
|
||||
fixtures: [
|
||||
6
|
||||
]
|
||||
}],
|
||||
['safeInteger', {
|
||||
is: m.safeInteger,
|
||||
fixtures: [
|
||||
Math.pow(2, 53) - 1,
|
||||
-Math.pow(2, 53) + 1
|
||||
]
|
||||
}],
|
||||
['domElement', {
|
||||
is: m.domElement,
|
||||
fixtures: [
|
||||
'div',
|
||||
'input',
|
||||
'span',
|
||||
'img',
|
||||
'canvas',
|
||||
'script'
|
||||
].map(createDomElement) }
|
||||
], ['non-domElements', {
|
||||
is: value => !m.domElement(value),
|
||||
fixtures: [
|
||||
document.createTextNode('data'),
|
||||
document.createProcessingInstruction('xml-stylesheet', 'href="mycss.css" type="text/css"'),
|
||||
document.createComment('This is a comment'),
|
||||
document,
|
||||
document.implementation.createDocumentType('svg:svg', '-//W3C//DTD SVG 1.1//EN', 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'), // tslint:disable-line
|
||||
document.createDocumentFragment()
|
||||
]
|
||||
}],
|
||||
['infinite', {
|
||||
is: m.infinite,
|
||||
fixtures: [
|
||||
Infinity,
|
||||
-Infinity
|
||||
]
|
||||
}]
|
||||
]);
|
||||
|
||||
// This ensures a certain method matches only the types
|
||||
// it's supposed to and none of the other methods' types
|
||||
const testType = (t, type, exclude) => {
|
||||
for (const [key, value] of types) {
|
||||
// This ensures a certain method matches only the types it's supposed to and none of the other methods' types
|
||||
const testType = (t: TestContext & Context<any>, type: string, exclude?: string[]) => {
|
||||
const testData = types.get(type);
|
||||
|
||||
if (testData === undefined) {
|
||||
t.fail(`is.${type} not defined`);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
const {is} = testData;
|
||||
|
||||
for (const [key, {fixtures}] of types) {
|
||||
// TODO: Automatically exclude value types in other tests that we have in the current one.
|
||||
// Could reduce the use of `exclude`.
|
||||
if (exclude && exclude.indexOf(key) !== -1) {
|
||||
|
|
@ -135,8 +313,6 @@ const testType = (t, type, exclude) => {
|
|||
}
|
||||
|
||||
const assert = key === type ? t.true.bind(t) : t.false.bind(t);
|
||||
const is = m[type];
|
||||
const fixtures = Array.isArray(value) ? value : [value];
|
||||
|
||||
for (const fixture of fixtures) {
|
||||
assert(is(fixture), `Value: ${util.inspect(fixture)}`);
|
||||
|
|
@ -188,7 +364,15 @@ test('is.buffer', t => {
|
|||
});
|
||||
|
||||
test('is.object', t => {
|
||||
for (const el of types.get('object')) {
|
||||
const testData = types.get('object');
|
||||
|
||||
if (testData === undefined) {
|
||||
t.fail('is.object not defined');
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
for (const el of testData.fixtures) {
|
||||
t.true(m.object(el));
|
||||
}
|
||||
});
|
||||
|
|
@ -213,6 +397,10 @@ if (isNode8orHigher) {
|
|||
test('is.promise', t => {
|
||||
testType(t, 'promise', ['nativePromise']);
|
||||
});
|
||||
|
||||
/*test('is.asyncFunction', t => {
|
||||
testType(t, 'asyncFunction', ['function']);
|
||||
});*/
|
||||
}
|
||||
|
||||
test('is.generator', t => {
|
||||
|
|
@ -223,12 +411,6 @@ test('is.generatorFunction', t => {
|
|||
testType(t, 'generatorFunction', ['function']);
|
||||
});
|
||||
|
||||
if (isNode8orHigher) {
|
||||
test('is.asyncFunction', t => {
|
||||
testType(t, 'asyncFunction', ['function']);
|
||||
});
|
||||
}
|
||||
|
||||
test('is.map', t => {
|
||||
testType(t, 'map');
|
||||
});
|
||||
|
|
@ -360,27 +542,29 @@ test('is.iterable', t => {
|
|||
});
|
||||
|
||||
test('is.class', t => {
|
||||
class Foo {}
|
||||
class Foo {} // tslint:disable-line
|
||||
const classDeclarations = [
|
||||
Foo,
|
||||
class Bar extends Foo {}
|
||||
class Bar extends Foo {} // tslint:disable-line
|
||||
];
|
||||
|
||||
for (const x of classDeclarations) {
|
||||
t.true(m.class(x));
|
||||
t.true(m.class_(x));
|
||||
}
|
||||
});
|
||||
|
||||
test('is.typedArray', t => {
|
||||
// Typescript currently does not support empty constructors for these
|
||||
// See https://github.com/Microsoft/TypeScript/issues/19680
|
||||
const typedArrays = [
|
||||
new Int8Array(),
|
||||
new Uint8Array(),
|
||||
new Uint8ClampedArray(),
|
||||
new Uint16Array(),
|
||||
new Int32Array(),
|
||||
new Uint32Array(),
|
||||
new Float32Array(),
|
||||
new Float64Array()
|
||||
new Int8Array(0),
|
||||
new Uint8Array(0),
|
||||
new Uint8ClampedArray(0),
|
||||
new Uint16Array(0),
|
||||
new Int32Array(0),
|
||||
new Uint32Array(0),
|
||||
new Float32Array(0),
|
||||
new Float64Array(0)
|
||||
];
|
||||
|
||||
for (const el of typedArrays) {
|
||||
|
|
@ -400,7 +584,7 @@ test('is.arrayLike', t => {
|
|||
t.true(m.arrayLike('unicorn'));
|
||||
|
||||
t.false(m.arrayLike({}));
|
||||
t.false(m.arrayLike(() => {}));
|
||||
t.false(m.arrayLike(() => {})); // tslint:disable-line:no-empty
|
||||
t.false(m.arrayLike(new Map()));
|
||||
});
|
||||
|
||||
|
|
@ -422,10 +606,6 @@ test('is.inRange', t => {
|
|||
t.false(m.inRange(x, 2));
|
||||
t.false(m.inRange(-3, -2));
|
||||
|
||||
t.throws(() => {
|
||||
m.inRange(0);
|
||||
});
|
||||
|
||||
t.throws(() => {
|
||||
m.inRange(0, []);
|
||||
});
|
||||
17
tsconfig.json
Normal file
17
tsconfig.json
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
{
|
||||
"compileOnSave": true,
|
||||
"compilerOptions": {
|
||||
/* es2015 requires moduleResolution and module to be set,
|
||||
see https://github.com/Microsoft/TypeScript/issues/8189 */
|
||||
"target": "es2015",
|
||||
"moduleResolution": "node",
|
||||
"module": "none",
|
||||
"strict": true,
|
||||
"declaration": true,
|
||||
"sourceMap": true,
|
||||
"outDir": "dist",
|
||||
"lib": [
|
||||
"es2015", "dom", "scripthost"
|
||||
]
|
||||
}
|
||||
}
|
||||
3
tslint.json
Normal file
3
tslint.json
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
{
|
||||
"extends": "tslint-xo"
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue