From b66faf461f0e0c309dfd67fe8b97166413d7c220 Mon Sep 17 00:00:00 2001 From: Lukas Tetzlaff Date: Thu, 2 Nov 2017 13:10:19 +0100 Subject: [PATCH] Fix linter issues --- src/index.ts | 101 +++++++++---------- tests/test.ts | 271 ++++++++++++++++++++++++++------------------------ 2 files changed, 191 insertions(+), 181 deletions(-) diff --git a/src/index.ts b/src/index.ts index f141110..f7d674d 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,11 +1,11 @@ -import * as util from "util"; +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; +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) { +function is(value: any) { // tslint:disable-line:only-arrow-functions if (value === null) { return 'null'; } @@ -54,38 +54,43 @@ function is(value: any) { } return 'Object'; -}; +} -namespace is { +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 boolean = (value: any) => value === true || value === false; - export const symbol = isOfType('symbol'); 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; - const isObject = (value: any) => typeof value === 'object'; - - export const object = (value: any) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value)); + 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) => - !is.null_(value) && + !null_(value) && isObject(value) && - is.function_(value.then) && - is.function_(value.catch); + function_(value.then) && + function_(value.catch); - export const promise = (value: any) => is.nativePromise(value) || hasPromiseAPI(value); - - export const generator = (value: any) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw); + 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) => is.function_(value) && is.function_(value.constructor) && value.constructor.name === type; + 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'); @@ -114,9 +119,7 @@ namespace is { export const truthy = (value: any) => Boolean(value); export const falsy = (value: any) => !value; - export const nan = (value: any) => Number.isNaN(value); - - export const nullOrUndefined = (value: any) => is.null_(value) || is.undefined(value); + export const nan = (value: any) => Number.isNaN(value); const primitiveTypes = new Set([ 'undefined', @@ -126,7 +129,7 @@ namespace is { 'symbol' ]); - export const primitive = (value: any) => is.null_(value) || primitiveTypes.has(typeof value); + 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); @@ -134,15 +137,12 @@ namespace is { 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 || + (prototype = Object.getPrototypeOf(value), prototype === null || // tslint:disable-line:ban-comma-operator prototype === Object.getPrototypeOf({})); }; - export const iterable = (value: any) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]); - - export const class_ = (value: any) => is.function_(value) && value.toString().startsWith('class '); - const typedArrayTypes = new Set([ 'Int8Array', 'Uint8Array', @@ -156,15 +156,15 @@ namespace is { ]); export const typedArray = (value: any) => typedArrayTypes.has(getObjectType(value)); - const isValidLength = (value: any) => is.safeInteger(value) && value > -1; - export const arrayLike = (value: any) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length); + 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 (is.number(range)) { + if (number(range)) { return value >= Math.min(0, range as number) && value <= Math.max(range as number, 0); } - if (is.array(range) && range.length === 2) { + if (array(range) && range.length === 2) { return value >= Math.min(...range) && value <= Math.max(...range); } @@ -180,51 +180,52 @@ namespace is { 'nodeValue' ]; - export const domElement = (value: any) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) && - !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value); + 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) => is.integer(rem) && Math.abs(rem % 2) === value; + 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) => is.string(value) && /\S/.test(value) === false; - const isEmptyStringOrArray = (value: any) => (is.string(value) || is.array(value)) && value.length === 0; - const isEmptyObject = (value: any) => !is.map(value) && !is.set(value) && is.object(value) && Object.keys(value).length === 0; - const isEmptyMapOrSet = (value: any) => (is.map(value) || is.set(value)) && value.size === 0; + 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) => is.falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value); - export const emptyOrWhitespace = (value: any) => is.empty(value) || isWhiteSpaceString(value); + 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 + type ArrayMethod = (fn: (value: any, index: number, arr: any[]) => boolean, thisArg?: any) => boolean; const predicateOnArray = (method: ArrayMethod, predicate: any, values: any[]) => { - if (is.function_(predicate) === false) { + if (function_(predicate) === false) { throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`); } if (values.length === 0) { - throw new TypeError(`Invalid number of values`); + throw new TypeError('Invalid number of values'); } return method.call(values, predicate); }; - export const any = function (predicate: any, ...values: any[]) { + // tslint:disable-next-line:variable-name + export const any = (predicate: any, ...values: any[]) => { return predicateOnArray(Array.prototype.some, predicate, values); }; - export const all = function (predicate: any, ...values: any[]) { + export const all = (predicate: any, ...values: any[]) => { return predicateOnArray(Array.prototype.every, predicate, values); }; } // 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_ } +// 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 +export default is; // tslint:disable-line:no-default-export diff --git a/tests/test.ts b/tests/test.ts index 76f7776..47574a1 100644 --- a/tests/test.ts +++ b/tests/test.ts @@ -1,139 +1,140 @@ import * as util from 'util'; -import test, { TestContext, Context } from 'ava'; +import test, {TestContext, Context} from 'ava'; import * as jsdom from 'jsdom'; -import m from '../src'; +import m from '../src'; // tslint:disable-line:import-name const isNode8orHigher = Number(process.versions.node.split('.')[0]) >= 8; -class PromiseSubclassFixture extends Promise {}; -class ErrorSubclassFixture extends Error {}; +/* Currently out of order, see https://github.com/Microsoft/TypeScript/issues/15202 +class PromiseSubclassFixture extends Promise {}*/ +class ErrorSubclassFixture extends Error {} -const document = new jsdom.JSDOM().window.document +const document = new jsdom.JSDOM().window.document; const createDomElement = (el: string) => document.createElement(el); -type Test = { is: (value: any) => boolean, fixtures: any[] } +interface Test {is(value: any): boolean; fixtures: any[]; } const types = new Map([ - ['undefined', - { is: m.undefined, fixtures: [undefined] } - ],['null', - { is: m.null_, fixtures: [null] } - ],['string', - { is: m.string, fixtures: [ + ['undefined', + {is: m.undefined, fixtures: [undefined]} + ], ['null', + {is: m.null_, fixtures: [null]} + ], ['string', + {is: m.string, fixtures: [ '🦄', 'hello world', '' - ] } - ],['number', - { is: m.number, fixtures: [ + ]} + ], ['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)] } - ],['function', - { is: m.function_, fixtures: [ - function foo() {}, // eslint-disable-line func-names - function () {}, + ]} + ], ['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 {} - ] } - ],['buffer', - { is: m.buffer, fixtures: [Buffer.from('🦄')] } - ],['object', - { is: m.object, fixtures: [ + 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: [ + ]} + ], ['regExp', + {is: m.regExp, fixtures: [ /\w/, new RegExp('\\w') - ] } - ],['date', - { is: m.date, fixtures: [new Date()] } - ],['error', - { is: m.error, fixtures: [ + ]} + ], ['date', + {is: m.date, fixtures: [new Date()]} + ], ['error', + {is: m.error, fixtures: [ new Error('🦄'), new ErrorSubclassFixture() - ] } - ],['nativePromise', - { is: m.nativePromise, fixtures: [ + ]} + ], ['nativePromise', + {is: m.nativePromise, fixtures: [ Promise.resolve(), - - // currently out of order, see https://github.com/Microsoft/TypeScript/issues/15202 - //PromiseSubclassFixture.resolve() - ] } - ],['promise', - { is: m.promise, fixtures: [{then() {}, catch() {}}] } - ],['generator', - { is: m.generator, fixtures: [(function * () { - yield 4; - })()] } - ],['generatorFunction', - { is: m.generatorFunction, fixtures: [function * () { - yield 4; - }] } - ],['asyncFunction', - { is: m.asyncFunction, fixtures: [ - async function () {}, - async () => {} - ] } - ],['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: [ + // 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() // eslint-disable-line no-new-object - ] } - ],['integer', - { is: m.integer, fixtures: [6] } - ],['safeInteger', - { is: m.safeInteger, fixtures: [ + 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: [ + ]} + ], ['domElement', + {is: m.domElement, fixtures: [ 'div', 'input', 'span', @@ -141,31 +142,34 @@ const types = new Map([ 'canvas', 'script' ].map(createDomElement) } - ],['non-domElements', - { is: value => !m.domElement(value), fixtures: [ + ], ['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'), + 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] } + ]} + ], ['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: TestContext & Context, type: string, exclude?: Array) => { - const test = types.get(type) - if (test === undefined) { - t.fail(`is.${type} not defined`) - return - } - const { is } = test as Test +/* 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, type: string, exclude?: string[]) => { + const testData = types.get(type); - types.forEach(({ fixtures }, key) => { + if (testData === undefined) { + t.fail(`is.${type} not defined`); + + return; + } + + const {is} = testData; + + types.forEach(({fixtures}, key) => { // 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) { @@ -177,7 +181,7 @@ const testType = (t: TestContext & Context, type: string, exclude?: Array { @@ -224,9 +228,15 @@ test('is.buffer', t => { }); test('is.object', t => { - const testData = types.get('object') - if (testData === undefined) t.fail("is.object not defined") - for (const el of (testData as Test).fixtures) { + 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)); } }); @@ -381,7 +391,6 @@ test('is.safeInteger', t => { t.false(m.safeInteger(-Math.pow(2, 53))); }); - test('is.plainObject', t => { testType(t, 'plainObject', ['object', 'promise']); }); @@ -399,10 +408,10 @@ 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) { @@ -412,7 +421,7 @@ test('is.class', t => { test('is.typedArray', t => { // Typescript currently does not support empty constructors for these - // see https://github.com/Microsoft/TypeScript/issues/19680 + // See https://github.com/Microsoft/TypeScript/issues/19680 const typedArrays = [ new Int8Array(0), new Uint8Array(0), @@ -441,7 +450,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())); });