UNPKG

19.9 kBJavaScriptView Raw
1"use strict";
2/// <reference lib="es2018"/>
3/// <reference lib="dom"/>
4/// <reference types="node"/>
5Object.defineProperty(exports, "__esModule", { value: true });
6const typedArrayTypeNames = [
7 'Int8Array',
8 'Uint8Array',
9 'Uint8ClampedArray',
10 'Int16Array',
11 'Uint16Array',
12 'Int32Array',
13 'Uint32Array',
14 'Float32Array',
15 'Float64Array',
16 'BigInt64Array',
17 'BigUint64Array'
18];
19function isTypedArrayName(name) {
20 return typedArrayTypeNames.includes(name);
21}
22const objectTypeNames = [
23 'Function',
24 'Generator',
25 'AsyncGenerator',
26 'GeneratorFunction',
27 'AsyncGeneratorFunction',
28 'AsyncFunction',
29 'Observable',
30 'Array',
31 'Buffer',
32 'Object',
33 'RegExp',
34 'Date',
35 'Error',
36 'Map',
37 'Set',
38 'WeakMap',
39 'WeakSet',
40 'ArrayBuffer',
41 'SharedArrayBuffer',
42 'DataView',
43 'Promise',
44 'URL',
45 'HTMLElement',
46 ...typedArrayTypeNames
47];
48function isObjectTypeName(name) {
49 return objectTypeNames.includes(name);
50}
51const primitiveTypeNames = [
52 'null',
53 'undefined',
54 'string',
55 'number',
56 'bigint',
57 'boolean',
58 'symbol'
59];
60function isPrimitiveTypeName(name) {
61 return primitiveTypeNames.includes(name);
62}
63// eslint-disable-next-line @typescript-eslint/ban-types
64function isOfType(type) {
65 return (value) => typeof value === type;
66}
67const { toString } = Object.prototype;
68const getObjectType = (value) => {
69 const objectTypeName = toString.call(value).slice(8, -1);
70 if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
71 return 'HTMLElement';
72 }
73 if (isObjectTypeName(objectTypeName)) {
74 return objectTypeName;
75 }
76 return undefined;
77};
78const isObjectOfType = (type) => (value) => getObjectType(value) === type;
79function is(value) {
80 if (value === null) {
81 return 'null';
82 }
83 switch (typeof value) {
84 case 'undefined':
85 return 'undefined';
86 case 'string':
87 return 'string';
88 case 'number':
89 return 'number';
90 case 'boolean':
91 return 'boolean';
92 case 'function':
93 return 'Function';
94 case 'bigint':
95 return 'bigint';
96 case 'symbol':
97 return 'symbol';
98 default:
99 }
100 if (is.observable(value)) {
101 return 'Observable';
102 }
103 if (is.array(value)) {
104 return 'Array';
105 }
106 if (is.buffer(value)) {
107 return 'Buffer';
108 }
109 const tagType = getObjectType(value);
110 if (tagType) {
111 return tagType;
112 }
113 if (value instanceof String || value instanceof Boolean || value instanceof Number) {
114 throw new TypeError('Please don\'t use object wrappers for primitive types');
115 }
116 return 'Object';
117}
118is.undefined = isOfType('undefined');
119is.string = isOfType('string');
120const isNumberType = isOfType('number');
121is.number = (value) => isNumberType(value) && !is.nan(value);
122is.bigint = isOfType('bigint');
123// eslint-disable-next-line @typescript-eslint/ban-types
124is.function_ = isOfType('function');
125is.null_ = (value) => value === null;
126is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
127is.boolean = (value) => value === true || value === false;
128is.symbol = isOfType('symbol');
129is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
130is.array = (value, assertion) => {
131 if (!Array.isArray(value)) {
132 return false;
133 }
134 if (!is.function_(assertion)) {
135 return true;
136 }
137 return value.every(assertion);
138};
139is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; };
140is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
141is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
142is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); };
143is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); };
144is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
145is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
146is.nativePromise = (value) => isObjectOfType('Promise')(value);
147const hasPromiseAPI = (value) => {
148 var _a, _b;
149 return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) &&
150 is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch);
151};
152is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
153is.generatorFunction = isObjectOfType('GeneratorFunction');
154is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
155is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
156// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
157is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
158is.regExp = isObjectOfType('RegExp');
159is.date = isObjectOfType('Date');
160is.error = isObjectOfType('Error');
161is.map = (value) => isObjectOfType('Map')(value);
162is.set = (value) => isObjectOfType('Set')(value);
163is.weakMap = (value) => isObjectOfType('WeakMap')(value);
164is.weakSet = (value) => isObjectOfType('WeakSet')(value);
165is.int8Array = isObjectOfType('Int8Array');
166is.uint8Array = isObjectOfType('Uint8Array');
167is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
168is.int16Array = isObjectOfType('Int16Array');
169is.uint16Array = isObjectOfType('Uint16Array');
170is.int32Array = isObjectOfType('Int32Array');
171is.uint32Array = isObjectOfType('Uint32Array');
172is.float32Array = isObjectOfType('Float32Array');
173is.float64Array = isObjectOfType('Float64Array');
174is.bigInt64Array = isObjectOfType('BigInt64Array');
175is.bigUint64Array = isObjectOfType('BigUint64Array');
176is.arrayBuffer = isObjectOfType('ArrayBuffer');
177is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
178is.dataView = isObjectOfType('DataView');
179is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
180is.urlInstance = (value) => isObjectOfType('URL')(value);
181is.urlString = (value) => {
182 if (!is.string(value)) {
183 return false;
184 }
185 try {
186 new URL(value); // eslint-disable-line no-new
187 return true;
188 }
189 catch (_a) {
190 return false;
191 }
192};
193// TODO: Use the `not` operator with a type guard here when it's available.
194// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
195is.truthy = (value) => Boolean(value);
196// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
197is.falsy = (value) => !value;
198is.nan = (value) => Number.isNaN(value);
199is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
200is.integer = (value) => Number.isInteger(value);
201is.safeInteger = (value) => Number.isSafeInteger(value);
202is.plainObject = (value) => {
203 // From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
204 if (toString.call(value) !== '[object Object]') {
205 return false;
206 }
207 const prototype = Object.getPrototypeOf(value);
208 return prototype === null || prototype === Object.getPrototypeOf({});
209};
210is.typedArray = (value) => isTypedArrayName(getObjectType(value));
211const isValidLength = (value) => is.safeInteger(value) && value >= 0;
212is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
213is.inRange = (value, range) => {
214 if (is.number(range)) {
215 return value >= Math.min(0, range) && value <= Math.max(range, 0);
216 }
217 if (is.array(range) && range.length === 2) {
218 return value >= Math.min(...range) && value <= Math.max(...range);
219 }
220 throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
221};
222const NODE_TYPE_ELEMENT = 1;
223const DOM_PROPERTIES_TO_CHECK = [
224 'innerHTML',
225 'ownerDocument',
226 'style',
227 'attributes',
228 'nodeValue'
229];
230is.domElement = (value) => {
231 return is.object(value) &&
232 value.nodeType === NODE_TYPE_ELEMENT &&
233 is.string(value.nodeName) &&
234 !is.plainObject(value) &&
235 DOM_PROPERTIES_TO_CHECK.every(property => property in value);
236};
237is.observable = (value) => {
238 var _a, _b, _c, _d;
239 if (!value) {
240 return false;
241 }
242 // eslint-disable-next-line no-use-extend-native/no-use-extend-native
243 if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
244 return true;
245 }
246 if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
247 return true;
248 }
249 return false;
250};
251is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
252is.infinite = (value) => value === Infinity || value === -Infinity;
253const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
254is.evenInteger = isAbsoluteMod2(0);
255is.oddInteger = isAbsoluteMod2(1);
256is.emptyArray = (value) => is.array(value) && value.length === 0;
257is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
258is.emptyString = (value) => is.string(value) && value.length === 0;
259// TODO: Use `not ''` when the `not` operator is available.
260is.nonEmptyString = (value) => is.string(value) && value.length > 0;
261const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
262is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
263is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
264// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
265// - https://github.com/Microsoft/TypeScript/pull/29317
266is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
267is.emptySet = (value) => is.set(value) && value.size === 0;
268is.nonEmptySet = (value) => is.set(value) && value.size > 0;
269is.emptyMap = (value) => is.map(value) && value.size === 0;
270is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
271const predicateOnArray = (method, predicate, values) => {
272 if (!is.function_(predicate)) {
273 throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
274 }
275 if (values.length === 0) {
276 throw new TypeError('Invalid number of values');
277 }
278 return method.call(values, predicate);
279};
280is.any = (predicate, ...values) => {
281 const predicates = is.array(predicate) ? predicate : [predicate];
282 return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
283};
284is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
285const assertType = (condition, description, value, options = {}) => {
286 if (!condition) {
287 const { multipleValues } = options;
288 const valuesMessage = multipleValues ?
289 `received values of types ${[
290 ...new Set(value.map(singleValue => `\`${is(singleValue)}\``))
291 ].join(', ')}` :
292 `received value of type \`${is(value)}\``;
293 throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
294 }
295};
296exports.assert = {
297 // Unknowns.
298 undefined: (value) => assertType(is.undefined(value), 'undefined', value),
299 string: (value) => assertType(is.string(value), 'string', value),
300 number: (value) => assertType(is.number(value), 'number', value),
301 bigint: (value) => assertType(is.bigint(value), 'bigint', value),
302 // eslint-disable-next-line @typescript-eslint/ban-types
303 function_: (value) => assertType(is.function_(value), 'Function', value),
304 null_: (value) => assertType(is.null_(value), 'null', value),
305 class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value),
306 boolean: (value) => assertType(is.boolean(value), 'boolean', value),
307 symbol: (value) => assertType(is.symbol(value), 'symbol', value),
308 numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value),
309 array: (value, assertion) => {
310 const assert = assertType;
311 assert(is.array(value), 'Array', value);
312 if (assertion) {
313 value.forEach(assertion);
314 }
315 },
316 buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
317 nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value),
318 object: (value) => assertType(is.object(value), 'Object', value),
319 iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value),
320 asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value),
321 generator: (value) => assertType(is.generator(value), 'Generator', value),
322 asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
323 nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value),
324 promise: (value) => assertType(is.promise(value), 'Promise', value),
325 generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
326 asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
327 // eslint-disable-next-line @typescript-eslint/ban-types
328 asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
329 // eslint-disable-next-line @typescript-eslint/ban-types
330 boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
331 regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
332 date: (value) => assertType(is.date(value), 'Date', value),
333 error: (value) => assertType(is.error(value), 'Error', value),
334 map: (value) => assertType(is.map(value), 'Map', value),
335 set: (value) => assertType(is.set(value), 'Set', value),
336 weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
337 weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
338 int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
339 uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
340 uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
341 int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
342 uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
343 int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
344 uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
345 float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
346 float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
347 bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
348 bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
349 arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
350 sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
351 dataView: (value) => assertType(is.dataView(value), 'DataView', value),
352 urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
353 urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value),
354 truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value),
355 falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value),
356 nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value),
357 primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value),
358 integer: (value) => assertType(is.integer(value), "integer" /* integer */, value),
359 safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value),
360 plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value),
361 typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value),
362 arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value),
363 domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* domElement */, value),
364 observable: (value) => assertType(is.observable(value), 'Observable', value),
365 nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value),
366 infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value),
367 emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value),
368 nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value),
369 emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value),
370 nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value),
371 emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value),
372 emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value),
373 nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value),
374 emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value),
375 nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value),
376 emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value),
377 nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value),
378 // Numbers.
379 evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value),
380 oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value),
381 // Two arguments.
382 directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance),
383 inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value),
384 // Variadic functions.
385 any: (predicate, ...values) => {
386 return assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values, { multipleValues: true });
387 },
388 all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values, { multipleValues: true })
389};
390// Some few keywords are reserved, but we'll populate them for Node.js users
391// See https://github.com/Microsoft/TypeScript/issues/2536
392Object.defineProperties(is, {
393 class: {
394 value: is.class_
395 },
396 function: {
397 value: is.function_
398 },
399 null: {
400 value: is.null_
401 }
402});
403Object.defineProperties(exports.assert, {
404 class: {
405 value: exports.assert.class_
406 },
407 function: {
408 value: exports.assert.function_
409 },
410 null: {
411 value: exports.assert.null_
412 }
413});
414exports.default = is;
415// For CommonJS default export support
416module.exports = is;
417module.exports.default = is;
418module.exports.assert = exports.assert;