@academyjs/rover
Version:
Rover allows you to learn programming interactively.
1,528 lines • 56 kB
JavaScript
"use strict";
/*!
* Majority of the function declarations and documentation was derived from Chai: http://chaijs.com.
* A few new functions were introduced based on our needs. Further, all the functions were migrated
* to TypeScript and were written from scratch.
*
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
* Copyright(c) 2021 AcademyJS <hello@academyjs.com>
* MIT Licensed
*/
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.property = exports.notMatch = exports.match = exports.notDeepInclude = exports.deepInclude = exports.notInclude = exports.include = exports.notInstanceOf = exports.instanceOf = exports.notTypeOf = exports.typeOf = exports.isNotBoolean = exports.isBoolean = exports.isFinite = exports.isNotNumber = exports.isNumber = exports.isNotString = exports.isString = exports.isNotArray = exports.isArray = exports.isNotObject = exports.isObject = exports.isNotFunction = exports.isFunction = exports.isDefined = exports.isUndefined = exports.notExists = exports.exists = exports.isNotNaN = exports.isNaN = exports.isNotNull = exports.isNull = exports.isNotFalse = exports.isFalse = exports.isNotTrue = exports.isTrue = exports.isAtMost = exports.isBelow = exports.isAtLeast = exports.isAbove = exports.notDeepEqual = exports.deepEqual = exports.notStrictEqual = exports.strictEqual = exports.notEqual = exports.equal = exports.isFalsy = exports.isTruthy = exports.fail = exports.assert = void 0;
exports.isEmpty = exports.isNotFrozen = exports.isFrozen = exports.isNotSealed = exports.isSealed = exports.isNotExtensible = exports.isExtensible = exports.oneOf = exports.notIncludeDeepOrderedMembers = exports.includeDeepOrderedMembers = exports.notIncludeOrderedMembers = exports.includeOrderedMembers = exports.notIncludeDeepMembers = exports.includeDeepMembers = exports.notIncludeMembers = exports.includeMembers = exports.notSameDeepOrderedMembers = exports.sameDeepOrderedMembers = exports.notSameOrderedMembers = exports.sameOrderedMembers = exports.notSameDeepMembers = exports.sameDeepMembers = exports.notSameMembers = exports.sameMembers = exports.approximately = exports.closeTo = exports.operator = exports.doesNotHaveAllKeys = exports.doesNotHaveAnyKeys = exports.containsAllKeys = exports.hasAllKeys = exports.hasAnyKeys = exports.length = exports.notDeepNestedPropertyValue = exports.deepNestedPropertyValue = exports.notNestedPropertyValue = exports.nestedPropertyValue = exports.notNestedProperty = exports.nestedProperty = exports.notDeepOwnPropertyValue = exports.deepOwnPropertyValue = exports.notOwnPropertyValue = exports.ownPropertyValue = exports.notOwnProperty = exports.ownProperty = exports.notDeepPropertyValue = exports.deepPropertyValue = exports.notPropertyValue = exports.propertyValue = exports.notProperty = void 0;
exports.spawnPrints = exports.fileExists = exports.isNotEmpty = void 0;
const assertion_error_1 = __importDefault(require("assertion-error"));
const lodash_1 = __importDefault(require("lodash"));
const fs_1 = __importDefault(require("fs"));
const util_1 = require("./util");
/**
* Create your own test expressions.
*
* ```js
* assert('two' !== 2, "string 'two' is not equivalent to integer 2");
* ```
*/
const assert = (expression, message) => {
if (!expression) {
throw new assertion_error_1.default(message);
}
};
exports.assert = assert;
/**
* Force a failure.
*
* ```js
* fail("samuel", "rowe", "values are not equal");
* ```
*/
const fail = (actual, expected, message) => {
throw new assertion_error_1.default(message, {
actual,
expected,
});
};
exports.fail = fail;
/**
* Asserts that the specified value is truthy.
*
* ```js
* isTruthy({}, "empty objects are truthy");
* isTruthy("", "empty strings are falsy"); // This will fail.
* ```
*/
const isTruthy = (value, message) => {
if (!value) {
throw new assertion_error_1.default(message, {
actual: value,
expected: true,
});
}
};
exports.isTruthy = isTruthy;
/**
* Asserts that the specified value is falsy.
*
* ```js
* isFalsy({}, "empty objects are truthy"); // This will fail.
* isFalsy("", "empty strings are falsy");
* ```
*/
const isFalsy = (value, message) => {
if (value) {
throw new assertion_error_1.default(message, {
actual: value,
expected: false,
});
}
};
exports.isFalsy = isFalsy;
/**
* Asserts non-strict equality (`==`) of `actual` and `expected`.
*
* ```js
* equal(3, '3', '== coerces values to strings');
* ```
*/
const equal = (actual, expected, message) => {
if (actual != expected) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.equal = equal;
/**
* Asserts non-strict inequality (`!=`) of `actual` and `expected`.
*
* ```js
* notEqual(3, 4, 'these numbers are not equal');
* ```
*/
const notEqual = (actual, expected, message) => {
if (actual == expected) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.notEqual = notEqual;
/**
* Asserts strict equality (`===`) of `actual` and `expected`.
*
* ```js
* strictEqual(true, true, 'these booleans are strictly equal');
* ```
*/
const strictEqual = (actual, expected, message) => {
if (actual !== expected) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.strictEqual = strictEqual;
/**
* Asserts strict inequality (`!==`) of `actual` and `expected`.
*
* ```js
* notStrictEqual(3, '3', 'no coercion for strict equality');
* ```
*/
const notStrictEqual = (actual, expected, message) => {
if (actual === expected) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.notStrictEqual = notStrictEqual;
/**
* Asserts that `actual` is deeply equal to `expected`.
*
* ```js
* deepEqual({ tea: 'green' }, { tea: 'green' });
* ```
*/
const deepEqual = (actual, expected, message) => {
if (!lodash_1.default.isEqual(actual, expected)) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.deepEqual = deepEqual;
/**
* Assert that `actual` is not deeply equal to `expected`.
*
* ```js
* notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
* ```
*/
const notDeepEqual = (actual, expected, message) => {
if (lodash_1.default.isEqual(actual, expected)) {
throw new assertion_error_1.default(message, {
actual,
expected,
});
}
};
exports.notDeepEqual = notDeepEqual;
/**
* Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`.
*
* ```js
* isAbove(5, 2, '5 is strictly greater than 2');
* ```
*/
const isAbove = (valueToCheck, valueToBeAbove, message) => {
if (!lodash_1.default.gt(valueToCheck, valueToBeAbove)) {
throw new assertion_error_1.default(message);
}
};
exports.isAbove = isAbove;
/**
* Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`.
*
* ```js
* isAtLeast(5, 2, '5 is greater or equal to 2');
* isAtLeast(3, 3, '3 is greater or equal to 3');
* ```
*/
const isAtLeast = (valueToCheck, valueToBeAtLeast, message) => {
if (!lodash_1.default.gte(valueToCheck, valueToBeAtLeast)) {
throw new assertion_error_1.default(message);
}
};
exports.isAtLeast = isAtLeast;
/**
* Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`.
*
* ```js
* isBelow(3, 6, '3 is strictly less than 6');
* ```
*/
const isBelow = (valueToCheck, valueToBeBelow, message) => {
if (!lodash_1.default.lt(valueToCheck, valueToBeBelow)) {
throw new assertion_error_1.default(message);
}
};
exports.isBelow = isBelow;
/**
* Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`.
*
* ```js
* isAtMost(3, 6, '3 is less than or equal to 6');
* isAtMost(4, 4, '4 is less than or equal to 4');
* ```
*/
const isAtMost = (valueToCheck, valueToBeAtMost, message) => {
if (!lodash_1.default.lte(valueToCheck, valueToBeAtMost)) {
throw new assertion_error_1.default(message);
}
};
exports.isAtMost = isAtMost;
/**
* Asserts that `value` is true.
*
* ```js
* let teaServed = true;
* isTrue(teaServed, 'the tea has been served');
* ```
*/
const isTrue = (value, message) => {
if (value !== true) {
throw new assertion_error_1.default(message);
}
};
exports.isTrue = isTrue;
/**
* Asserts that `value` is not true.
*
* ```js
* let tea = 'tasty chai';
* isNotTrue(tea, 'great, time for tea!');
* ```
*/
const isNotTrue = (value, message) => {
if (value === true) {
throw new assertion_error_1.default(message);
}
};
exports.isNotTrue = isNotTrue;
/**
* Asserts that `value` is false.
*
* ```js
* let teaServed = false;
* isFalse(teaServed, 'no tea yet? hmm...');
* ```
*/
const isFalse = (value, message) => {
if (value !== false) {
throw new assertion_error_1.default(message);
}
};
exports.isFalse = isFalse;
/**
* Asserts that `value` is not false.
*
* ```js
* let tea = 'tasty chai';
* isNotFalse(tea, 'great, time for tea!');
* ```
*/
const isNotFalse = (value, message) => {
if (!value === false) {
throw new assertion_error_1.default(message);
}
};
exports.isNotFalse = isNotFalse;
/**
* Asserts that `value` is null.
*
* ```js
* isNull(err, 'there was no error');
* ```
*/
const isNull = (value, message) => {
if (value !== null) {
throw new assertion_error_1.default(message);
}
};
exports.isNull = isNull;
/**
* Asserts that `value` is not null.
*
* ```js
* let tea = 'tasty chai';
* isNotNull(tea, 'great, time for tea!');
* ```
*/
const isNotNull = (value, message) => {
if (value === null) {
throw new assertion_error_1.default(message);
}
};
exports.isNotNull = isNotNull;
/**
* Asserts that value is NaN.
*
* ```js
* isNaN(NaN, 'NaN is NaN');
* ```
*/
const isNaN = (value, message) => {
if (value !== value) {
throw new assertion_error_1.default(message);
}
};
exports.isNaN = isNaN;
/**
* Asserts that value is not NaN.
*
* ```js
* isNotNaN(4, '4 is not NaN');
* ```
*/
const isNotNaN = (value, message) => {
if (value === value) {
throw new assertion_error_1.default(message);
}
};
exports.isNotNaN = isNotNaN;
/**
* Asserts that the target is neither `null` nor `undefined`.
*
* ```js
* let foo = 'hi';
* exists(foo, 'foo is neither `null` nor `undefined`');
* ```
*/
const exists = (value, message) => {
if (!lodash_1.default.exists(value)) {
throw new assertion_error_1.default(message);
}
};
exports.exists = exists;
/**
* Asserts that the target is either `null` or `undefined`.
*
* ```js
* let bar = null, baz;
* notExists(bar);
* notExists(baz, 'baz is either null or undefined');
* ```
*/
const notExists = (value, message) => {
if (lodash_1.default.exists(value)) {
throw new assertion_error_1.default(message);
}
};
exports.notExists = notExists;
/**
* Asserts that `value` is `undefined`.
*
* ```js
* let tea;
* isUndefined(tea, 'no tea defined');
* ```
*/
const isUndefined = (value, message) => {
if (!lodash_1.default.isUndefined(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isUndefined = isUndefined;
/**
* Asserts that `value` is not `undefined`.
*
* ```js
* let tea = 'cup of chai';
* isDefined(tea, 'tea has been defined');
* ```
*/
const isDefined = (value, message) => {
if (lodash_1.default.isUndefined(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isDefined = isDefined;
/**
* Asserts that `value` is a .
*
* ```js
* isFunction(serveTea, 'great, we can have tea now');
* ```
*/
const isFunction = (value, message) => {
if (!lodash_1.default.isFunction(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isFunction = isFunction;
/**
* Asserts that `value` is _not_ a .
*
* ```js
* let serveTea = [ 'heat', 'pour', 'sip' ];
* isNotFunction(serveTea, 'great, we have listed the steps');
* ```
*/
const isNotFunction = (value, message) => {
if (lodash_1.default.isFunction(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotFunction = isNotFunction;
/**
* Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).
* _The assertion does not match subclassed objects._
*
* ```js
* let selection = { name: 'Chai', serve: 'with spices' };
* isObject(selection, 'tea selection is an object');
* ```
*/
const isObject = (value, message) => {
if (!lodash_1.default.isObject(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isObject = isObject;
/**
* Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).
*
* ```js
* let selection = 'chai'
* isNotObject(selection, 'tea selection is not an object');
* isNotObject(null, 'null is not an object');
* ```
*/
const isNotObject = (value, message) => {
if (lodash_1.default.isObject(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotObject = isNotObject;
/**
* Asserts that `value` is an array.
*
* ```js
* let menu = [ 'green', 'chai', 'oolong' ];
* isArray(menu, 'what kind of tea do we want?');
* ```
*/
const isArray = (value, message) => {
if (!lodash_1.default.isArray(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isArray = isArray;
/**
* Asserts that `value` is _not_ an array.
*
* ```js
* let menu = 'green|chai|oolong';
* isNotArray(menu, 'what kind of tea do we want?');
* ```
*/
const isNotArray = (value, message) => {
if (lodash_1.default.isArray(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotArray = isNotArray;
/**
* Asserts that `value` is a string.
*
* ```js
* let teaOrder = 'chai';
* isString(teaOrder, 'order placed');
* ```
*/
const isString = (value, message) => {
if (!lodash_1.default.isString(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isString = isString;
/**
* Asserts that `value` is _not_ a string.
*
* ```js
* let teaOrder = 4;
* isNotString(teaOrder, 'order placed');
* ```
*/
const isNotString = (value, message) => {
if (lodash_1.default.isString(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotString = isNotString;
/**
* Asserts that `value` is a number.
*
* ```js
* let cups = 2;
* isNumber(cups, 'how many cups');
* ```
*/
const isNumber = (value, message) => {
if (!lodash_1.default.isNumber(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNumber = isNumber;
/**
* Asserts that `value` is _not_ a number.
*
* ```js
* let cups = '2 cups please';
* isNotNumber(cups, 'how many cups');
* ```
*/
const isNotNumber = (value, message) => {
if (lodash_1.default.isNumber(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotNumber = isNotNumber;
/**
* Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity`.
*
* ```js
* let cups = 2;
* isFinite(cups, 'how many cups');
* isFinite(NaN); // throws
* ```
*/
const isFinite = (value, message) => {
if (!lodash_1.default.isFinite(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isFinite = isFinite;
/**
* Asserts that `value` is a boolean.
*
* ```js
* let teaReady = true, teaServed = false;
* isBoolean(teaReady, 'is the tea ready');
* isBoolean(teaServed, 'has tea been served');
* ```
*/
const isBoolean = (value, message) => {
if (!lodash_1.default.isBoolean(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isBoolean = isBoolean;
/**
* Asserts that `value` is _not_ a boolean.
*
* ```js
* let teaReady = 'yep', teaServed = 'nope';
* isNotBoolean(teaReady, 'is the tea ready');
* isNotBoolean(teaServed, 'has tea been served');
* ```
*/
const isNotBoolean = (value, message) => {
if (!lodash_1.default.isBoolean(value)) {
throw new assertion_error_1.default(message);
}
};
exports.isNotBoolean = isNotBoolean;
/**
* Asserts that `value`'s type is `name`, as determined by
* `Object.prototype.toString`.
*
* ```js
* typeOf({ tea: 'chai' }, 'object', 'we have an object');
* typeOf(['chai', 'jasmine'], 'array', 'we have an array');
* typeOf('tea', 'string', 'we have a string');
* typeOf(/tea/, 'regexp', 'we have a regular expression');
* typeOf(null, 'null', 'we have a null');
* typeOf(undefined, 'undefined', 'we have an undefined');
* ```
*/
const typeOf = (value, type, message) => {
if (typeof value !== type) {
throw new assertion_error_1.default(message);
}
};
exports.typeOf = typeOf;
/**
* Asserts that `value`'s type is _not_ `name`, as determined by
* `Object.prototype.toString`.
*
* ```js
* notTypeOf('tea', 'number', 'strings are not numbers');
* ```
*/
const notTypeOf = (value, type, message) => {
if (typeof value === type) {
throw new assertion_error_1.default(message);
}
};
exports.notTypeOf = notTypeOf;
/**
* Asserts that `value` is an instance of `constructor`.
*
* ```js
* let Tea = (name) { this.name = name; }, chai = new Tea('chai');
* instanceOf(chai, Tea, 'chai is an instance of tea');
* ```
*/
const instanceOf = (value, constructor, message) => {
if (!lodash_1.default.isInstanceOf(value, constructor)) {
throw new assertion_error_1.default(message);
}
};
exports.instanceOf = instanceOf;
/**
* Asserts `value` is not an instance of `constructor`.
*
* ```js
* let Tea = (name) { this.name = name; }, chai = new String('chai');
* notInstanceOf(chai, Tea, 'chai is not an instance of tea');
* ```
*/
const notInstanceOf = (value, constructor, message) => {
if (lodash_1.default.isInstanceOf(value, constructor)) {
throw new assertion_error_1.default(message);
}
};
exports.notInstanceOf = notInstanceOf;
/**
* Asserts that `haystack` includes `needle`. Can be used to assert the
* inclusion of a value in an array, a substring in a string, or a subset of
* properties in an object.
*
* ```js
* include([1,2,3], 2, 'array contains value');
* include('foobar', 'foo', 'string contains substring');
* include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property');
* ```
*
* Strict equality (===) is used. When asserting the inclusion of a value in
* an array, the array is searched for an element that's strictly equal to the
* given value. When asserting a subset of properties in an object, the object
* is searched for the given property keys, checking that each one is present
* and strictly equal to the given property value. For instance:
*
* ```js
* let obj1 = {a: 1}, obj2 = {b: 2};
* include([obj1, obj2], obj1);
* include({foo: obj1, bar: obj2}, {foo: obj1});
* include({foo: obj1, bar: obj2}, {foo: obj1, bar: obj2});
* ```
*/
const include = (expression, includedValue, message) => {
if (!lodash_1.default.includes(expression, includedValue)) {
throw new assertion_error_1.default(message);
}
};
exports.include = include;
/**
* Asserts that `haystack` does not include `needle`. Can be used to assert
* the absence of a value in an array, a substring in a string, or a subset of
* properties in an object.
*
* ```js
* notInclude([1,2,3], 4, "array doesn't contain value");
* notInclude('foobar', 'baz', "string doesn't contain substring");
* notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn't contain property');
* ```
*
* Strict equality (===) is used. When asserting the absence of a value in an
* array, the array is searched to confirm the absence of an element that's
* strictly equal to the given value. When asserting a subset of properties in
* an object, the object is searched to confirm that at least one of the given
* property keys is either not present or not strictly equal to the given
* property value. For instance:
*
* ```js
* let obj1 = {a: 1}, obj2 = {b: 2};
* notInclude([obj1, obj2], {a: 1});
* notInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
* notInclude({foo: obj1, bar: obj2}, {foo: obj1, bar: {b: 2}});
* ```
*/
const notInclude = (expression, includedValue, message) => {
if (lodash_1.default.includes(expression, includedValue)) {
throw new assertion_error_1.default(message);
}
};
exports.notInclude = notInclude;
/**
* Asserts that `haystack` includes `needle`. Can be used to assert the
* inclusion of a value in an array or a subset of properties in an object.
* Deep equality is used.
*
* ```js
* let obj1 = {a: 1}, obj2 = {b: 2};
* deepInclude([obj1, obj2], {a: 1});
* deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
* deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 2}});
* ```
*/
const deepInclude = (expression, includedValue, message) => {
const element = lodash_1.default.find(expression, includedValue);
if (!lodash_1.default.isEqual(element, includedValue)) {
throw new assertion_error_1.default(message);
}
};
exports.deepInclude = deepInclude;
/**
* Asserts that `haystack` does not include `needle`. Can be used to assert
* the absence of a value in an array or a subset of properties in an object.
* Deep equality is used.
*
* ```js
* let obj1 = {a: 1}, obj2 = {b: 2};
* notDeepInclude([obj1, obj2], {a: 9});
* notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 9}});
* notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 9}});
* ```
*/
const notDeepInclude = (expression, includedValue, message) => {
const element = lodash_1.default.find(expression, includedValue);
if (lodash_1.default.isEqual(element, includedValue)) {
throw new assertion_error_1.default(message);
}
};
exports.notDeepInclude = notDeepInclude;
/**
* Asserts that `value` matches the regular expression `regexp`.
*
* ```js
* match('foobar', /^foo/, 'regexp matches');
* ```
*/
const match = (expression, regularExpression, message) => {
if (!expression.match(regularExpression)) {
throw new assertion_error_1.default(message);
}
};
exports.match = match;
/**
* Asserts that `value` does not match the regular expression `regexp`.
*
* ```js
* notMatch('foobar', /^foo/, 'regexp does not match');
* ```
*/
const notMatch = (expression, regularExpression, message) => {
if (expression.match(regularExpression)) {
throw new assertion_error_1.default(message);
}
};
exports.notMatch = notMatch;
/**
* Asserts that `object` has a direct or inherited property named by
* `property`.
*
* ```js
* property({ tea: { green: 'matcha' }}, 'tea');
* property({ tea: { green: 'matcha' }}, 'toString');
* ```
*/
const property = (value, property, message) => {
if (!lodash_1.default.has(value, property)) {
throw new assertion_error_1.default(message);
}
};
exports.property = property;
/**
* Asserts that `object` does _not_ have a direct or inherited property named
* by `property`.
*
* ```js
* notProperty({ tea: { green: 'matcha' }}, 'coffee');
* ```
*/
const notProperty = (value, property, message) => {
if (lodash_1.default.has(value, property)) {
throw new assertion_error_1.default(message);
}
};
exports.notProperty = notProperty;
/**
* Asserts that `object` has a direct or inherited property named by
* `property` with a value given by `value`. Uses a strict equality check
* (===).
*
* ```js
* propertyVal({ tea: 'is good' }, 'tea', 'is good');
* ```
*/
const propertyValue = (object0, property, value, message) => {
if (!lodash_1.default.has(object0, property) || object0[property] !== value) {
throw new assertion_error_1.default(message);
}
};
exports.propertyValue = propertyValue;
/**
* Asserts that `object` does _not_ have a direct or inherited property named
* by `property` with value given by `value`. Uses a strict equality check
* (===).
*
* ```js
* notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');
* notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');
* ```
*/
const notPropertyValue = (object0, property, value, message) => {
if (lodash_1.default.has(object0, property) && object0[property] === value) {
throw new assertion_error_1.default(message);
}
};
exports.notPropertyValue = notPropertyValue;
/**
* Asserts that `object` has a direct or inherited property named by
* `property` with a value given by `value`. Uses a deep equality check.
*
* ```js
* deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });
* ```
*/
const deepPropertyValue = (object0, property, value, message) => {
if (!lodash_1.default.has(object0, property) ||
!lodash_1.default.isEqual(object0[property], value)) {
throw new assertion_error_1.default(message);
}
};
exports.deepPropertyValue = deepPropertyValue;
/**
* Asserts that `object` does _not_ have a direct or inherited property named
* by `property` with value given by `value`. Uses a deep equality check.
*
* ```js
* notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });
* notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });
* notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });
* ```
*/
const notDeepPropertyValue = (object0, property, value, message) => {
if (lodash_1.default.has(object0, property) &&
lodash_1.default.isEqual(object0[property], value)) {
throw new assertion_error_1.default(message);
}
};
exports.notDeepPropertyValue = notDeepPropertyValue;
/**
* Asserts that `object` has a direct property named by `property`. Inherited
* properties aren't checked.
*
* ```js
* ownProperty({ tea: { green: 'matcha' }}, 'tea');
* ```
*/
const ownProperty = (object0, property, message) => {
if (object0 === undefined ||
object0 === null ||
!object0.hasOwnProperty(property)) {
throw new assertion_error_1.default(message);
}
};
exports.ownProperty = ownProperty;
/**
* Asserts that `object` does _not_ have a direct property named by
* `property`. Inherited properties aren't checked.
*
* ```js
* notOwnProperty({ tea: { green: 'matcha' }}, 'coffee');
* notOwnProperty({}, 'toString');
* ```
*/
const notOwnProperty = (object0, property, message) => {
if (object0 === undefined ||
object0 === null ||
object0.hasOwnProperty(property)) {
throw new assertion_error_1.default(message);
}
};
exports.notOwnProperty = notOwnProperty;
/**
* Asserts that `object` has a direct property named by `property` and a value
* equal to the provided `value`. Uses a strict equality check (===).
* Inherited properties aren't checked.
*
* ```js
* ownPropertyVal({ coffee: 'is good'}, 'coffee', 'is good');
* ```
*/
const ownPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
!object0.hasOwnProperty(property) ||
object0[property] !== value) {
throw new assertion_error_1.default(message);
}
};
exports.ownPropertyValue = ownPropertyValue;
/**
* Asserts that `object` does _not_ have a direct property named by `property`
* with a value equal to the provided `value`. Uses a strict equality check
* (===). Inherited properties aren't checked.
*
* ```js
* notOwnPropertyVal({ tea: 'is better'}, 'tea', 'is worse');
* notOwnPropertyVal({}, 'toString', Object.prototype.toString);
* ```
*/
const notOwnPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
(object0.hasOwnProperty(property) && object0[property] === value)) {
throw new assertion_error_1.default(message);
}
};
exports.notOwnPropertyValue = notOwnPropertyValue;
/**
* Asserts that `object` has a direct property named by `property` and a value
* equal to the provided `value`. Uses a deep equality check. Inherited
* properties aren't checked.
*
* ```js
* deepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });
* ```
*/
const deepOwnPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
!object0.hasOwnProperty(property) ||
!lodash_1.default.isEqual(object0[property], value)) {
throw new assertion_error_1.default(message);
}
};
exports.deepOwnPropertyValue = deepOwnPropertyValue;
/**
* Asserts that `object` does _not_ have a direct property named by `property`
* with a value equal to the provided `value`. Uses a deep equality check.
* Inherited properties aren't checked.
*
* ```js
* notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });
* notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });
* notDeepOwnPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });
* notDeepOwnPropertyVal({}, 'toString', Object.prototype.toString);
* ```
*/
const notDeepOwnPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
(object0.hasOwnProperty(property) &&
lodash_1.default.isEqual(object0[property], value))) {
throw new assertion_error_1.default(message);
}
};
exports.notDeepOwnPropertyValue = notDeepOwnPropertyValue;
/**
* Asserts that `object` has a direct or inherited property named by
* `property`, which can be a string using dot- and bracket-notation for
* nested reference.
*
* ```js
* nestedProperty({ tea: { green: 'matcha' }}, 'tea.green');
* ```
*/
const nestedProperty = (object0, property, message) => {
if (object0 === undefined ||
object0 === null ||
lodash_1.default.get(object0, property, "notAProperty") === "notAProperty") {
throw new assertion_error_1.default(message);
}
};
exports.nestedProperty = nestedProperty;
/**
* Asserts that `object` does _not_ have a property named by `property`, which
* can be a string using dot- and bracket-notation for nested reference. The
* property cannot exist on the object nor anywhere in its prototype chain.
*
* ```js
* notNestedProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
* ```
*/
const notNestedProperty = (object0, property, message) => {
if (object0 === undefined ||
object0 === null ||
lodash_1.default.get(object0, property, "notAProperty") !== "notAProperty") {
throw new assertion_error_1.default(message);
}
};
exports.notNestedProperty = notNestedProperty;
/**
* Asserts that `object` has a property named by `property` with value given
* by `value`. `property` can use dot- and bracket-notation for nested
* reference. Uses a strict equality check (===).
*
* ```js
* nestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
* ```
*/
const nestedPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
!lodash_1.default.get(object0, property) ||
lodash_1.default.get(object0, property) !== value) {
throw new assertion_error_1.default(message);
}
};
exports.nestedPropertyValue = nestedPropertyValue;
/**
* Asserts that `object` does _not_ have a property named by `property` with
* value given by `value`. `property` can use dot- and bracket-notation for
* nested reference. Uses a strict equality check (===).
*
* ```js
* notNestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
* notNestedPropertyVal({ tea: { green: 'matcha' }}, 'coffee.green', 'matcha');
* ```
*/
const notNestedPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
(lodash_1.default.get(object0, property) &&
lodash_1.default.get(object0, property) === value)) {
throw new assertion_error_1.default(message);
}
};
exports.notNestedPropertyValue = notNestedPropertyValue;
/**
* Asserts that `object` has a property named by `property` with a value given
* by `value`. `property` can use dot- and bracket-notation for nested
* reference. Uses a deep equality check.
*
* ```js
* deepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yum' });
* ```
*/
const deepNestedPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
!lodash_1.default.get(object0, property) ||
!lodash_1.default.isEqual(lodash_1.default.get(object0, property), value)) {
throw new assertion_error_1.default(message);
}
};
exports.deepNestedPropertyValue = deepNestedPropertyValue;
/**
* Asserts that `object` does _not_ have a property named by `property` with
* value given by `value`. `property` can use dot- and bracket-notation for
* nested reference. Uses a deep equality check.
*
* ```js
* notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' });
* notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' });
* notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' });
* ```
*/
const notDeepNestedPropertyValue = (object0, property, value, message) => {
if (object0 === undefined ||
object0 === null ||
(lodash_1.default.get(object0, property) &&
lodash_1.default.isEqual(lodash_1.default.get(object0, property), value))) {
throw new assertion_error_1.default(message);
}
};
exports.notDeepNestedPropertyValue = notDeepNestedPropertyValue;
/**
* Asserts that `object` has a `length` or `size` with the expected value.
*
* ```js
* lengthOf([1,2,3], 3, 'array has length of 3');
* lengthOf('foobar', 6, 'string has length of 6');
* lengthOf(new Set([1,2,3]), 3, 'set has size of 3');
* lengthOf(new Map([['a',1],['b',2],['c',3]]), 3, 'map has size of 3');
* ```
*/
const length = (expression, length, message) => {
if (lodash_1.default.size(expression) !== length) {
throw new assertion_error_1.default(message);
}
};
exports.length = length;
/**
* Asserts that `object` has at least one of the `keys` provided.
* You can also provide a single object instead of a `keys` array and its keys
* will be used as the expected set of keys.
*
* ```js
* hasAnyKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'iDontExist', 'baz']);
* hasAnyKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, iDontExist: 99, baz: 1337});
* hasAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
* hasAnyKeys(new Set([{foo: 'bar'}, 'anotherKey']), [{foo: 'bar'}, 'anotherKey']);
* ```
*/
const hasAnyKeys = (object0, keys, message) => {
if (!lodash_1.default.some(lodash_1.default.intersection(keys, lodash_1.default.keys(object0)))) {
throw new assertion_error_1.default(message);
}
};
exports.hasAnyKeys = hasAnyKeys;
/**
* Asserts that `object` has all and only all of the `keys` provided.
* You can also provide a single object instead of a `keys` array and its keys
* will be used as the expected set of keys.
*
* ```js
* hasAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
* hasAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337]);
* hasAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
* hasAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
* ```
*/
const hasAllKeys = (object0, keys, message) => {
if (!lodash_1.default.isEqual(keys, lodash_1.default.keys(object0))) {
throw new assertion_error_1.default(message);
}
};
exports.hasAllKeys = hasAllKeys;
/**
* Asserts that `object` has all of the `keys` provided but may have more keys not listed.
* You can also provide a single object instead of a `keys` array and its keys
* will be used as the expected set of keys.
*
* ```js
* containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'baz']);
* containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
* containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, baz: 1337});
* containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337});
* containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}]);
* containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
* containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}]);
* containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
* ```
*/
const containsAllKeys = (object0, keys, message) => {
if (!lodash_1.default.isEqual(lodash_1.default.intersection(keys, lodash_1.default.keys(object0)), keys)) {
throw new assertion_error_1.default(message);
}
};
exports.containsAllKeys = containsAllKeys;
/**
* Asserts that `object` has none of the `keys` provided.
* You can also provide a single object instead of a `keys` array and its keys
* will be used as the expected set of keys.
*
* ```js
* doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
* doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
* doesNotHaveAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
* doesNotHaveAnyKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
* ```
*/
const doesNotHaveAnyKeys = (object0, keys, message) => {
if (lodash_1.default.some(lodash_1.default.intersection(keys, lodash_1.default.keys(object0)))) {
throw new assertion_error_1.default(message);
}
};
exports.doesNotHaveAnyKeys = doesNotHaveAnyKeys;
/**
* Asserts that `object` does not have at least one of the `keys` provided.
* You can also provide a single object instead of a `keys` array and its keys
* will be used as the expected set of keys.
*
* ```js
* doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
* doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
* doesNotHaveAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
* doesNotHaveAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
* ```
*/
const doesNotHaveAllKeys = (object0, keys, message) => {
if (lodash_1.default.isEqual(keys, lodash_1.default.keys(object0))) {
throw new assertion_error_1.default(message);
}
};
exports.doesNotHaveAllKeys = doesNotHaveAllKeys;
/**
* Compares two values using `operator`.
*
* ```js
* operator(1, '<', 2, 'everything is ok');
* operator(1, '>', 2, 'this will fail');
* ```
*/
const operator = (value, operator, val2, message) => {
let ok;
switch (operator) {
case "==":
ok = value == val2;
break;
case "===":
ok = value === val2;
break;
case ">":
ok = value > val2;
break;
case ">=":
ok = value >= val2;
break;
case "<":
ok = value < val2;
break;
case "<=":
ok = value <= val2;
break;
case "!=":
ok = value != val2;
break;
case "!==":
ok = value !== val2;
break;
default:
message = message ? message + ": " : message;
throw new assertion_error_1.default(message + 'Invalid operator "' + operator + '"', {
operator,
});
}
};
exports.operator = operator;
/**
* Asserts that the target is equal `expected`, to within a +/- `delta` range.
*
* ```js
* closeTo(1.5, 1, 0.5, 'numbers are close');
* ```
*/
const closeTo = (actual, expression, delta, message) => {
if (!(expression - delta <= actual && actual <= expression + delta)) {
throw new assertion_error_1.default(message);
}
};
exports.closeTo = closeTo;
/**
* Asserts that the target is equal `expected`, to within a +/- `delta` range.
*
* ```js
* approximately(1.5, 1, 0.5, 'numbers are close');
* ```
*/
const approximately = (actual, expression, delta, message) => {
if (!(expression - delta <= actual && actual <= expression + delta)) {
throw new assertion_error_1.default(message);
}
};
exports.approximately = approximately;
/**
* Asserts that `set1` and `set2` have the same members in any order. Uses a
* strict equality check (===).
*
* ```js
* sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
* ```
*/
const sameMembers = (set1, set2, message) => {
if (!lodash_1.default.isEqual(set1.sort(), set2.sort())) {
throw new assertion_error_1.default(message);
}
};
exports.sameMembers = sameMembers;
/**
* Asserts that `set1` and `set2` don't have the same members in any order.
* Uses a strict equality check (===).
*
* ```js
* notSameMembers([ 1, 2, 3 ], [ 5, 1, 3 ], 'not same members');
* ```
*/
const notSameMembers = (set1, set2, message) => {
if (lodash_1.default.isEqual(set1.sort(), set2.sort())) {
throw new assertion_error_1.default(message);
}
};
exports.notSameMembers = notSameMembers;
/**
* Asserts that `set1` and `set2` have the same members in any order. Uses a
* deep equality check.
*
* ```js
* sameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members');
* ```
*/
const sameDeepMembers = (set1, set2, message) => {
if (!lodash_1.default.isEqual(set1.sort(), set2.sort())) {
throw new assertion_error_1.default(message);
}
};
exports.sameDeepMembers = sameDeepMembers;
/**
* Asserts that `set1` and `set2` don't have the same members in any order.
* Uses a deep equality check.
*
* ```js
* notSameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { f: 5 }], 'not same deep members');
* ```
*/
const notSameDeepMembers = (set1, set2, message) => {
if (lodash_1.default.isEqual(set1.sort(), set2.sort())) {
throw new assertion_error_1.default(message);
}
};
exports.notSameDeepMembers = notSameDeepMembers;
/**
* Asserts that `set1` and `set2` have the same members in the same order.
* Uses a strict equality check (===).
*
* ```js
* sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');
* ```
*/
const sameOrderedMembers = (set1, set2, message) => {
if (!lodash_1.default.isEqual(set1, set2)) {
throw new assertion_error_1.default(message);
}
};
exports.sameOrderedMembers = sameOrderedMembers;
/**
* Asserts that `set1` and `set2` don't have the same members in the same
* order. Uses a strict equality check (===).
*
* ```js
* notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');
* ```
*/
const notSameOrderedMembers = (set1, set2, message) => {
if (lodash_1.default.isEqual(set1, set2)) {
throw new assertion_error_1.default(message);
}
};
exports.notSameOrderedMembers = notSameOrderedMembers;
/**
* Asserts that `set1` and `set2` have the same members in the same order.
* Uses a deep equality check.
*
* ```js
* sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');
* ```
*/
const sameDeepOrderedMembers = (set1, set2, message) => {
if (!lodash_1.default.isEqual(set1, set2)) {
throw new assertion_error_1.default(message);
}
};
exports.sameDeepOrderedMembers = sameDeepOrderedMembers;
/**
* Asserts that `set1` and `set2` don't have the same members in the same
* order. Uses a deep equality check.
*
* ```js
* notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { z: 5 } ], 'not same deep ordered members');
* notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');
* ```
*/
const notSameDeepOrderedMembers = (set1, set2, message) => {
if (lodash_1.default.isEqual(set1, set2)) {
throw new assertion_error_1.default(message);
}
};
exports.notSameDeepOrderedMembers = notSameDeepOrderedMembers;
const isSubset = (subset, superset) => {
subset.map((item) => {
if (!lodash_1.default.includes(superset, item)) {
return false;
}
});
return true;
};
/**
* Asserts that `subset` is included in `superset` in any order. Uses a
* strict equality check (===). Duplicates are ignored.
*
* ```js
* includeMembers([ 1, 2, 3 ], [ 2, 1, 2 ], 'include members');
* ```
*/
const includeMembers = (superset, subset, message) => {
if (!isSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.includeMembers = includeMembers;
/**
* Asserts that `subset` isn't included in `superset` in any order. Uses a
* strict equality check (===). Duplicates are ignored.
*
* ```js
* notIncludeMembers([ 1, 2, 3 ], [ 5, 1 ], 'not include members');
* ```
*/
const notIncludeMembers = (superset, subset, message) => {
if (isSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.notIncludeMembers = notIncludeMembers;
const isDeepSubset = (subset, superset) => {
subset.map((item) => {
if (!lodash_1.default.includes(superset, item)) {
return false;
}
else {
const index = lodash_1.default.indexOf(superset, item);
if (!lodash_1.default.isEqual(item, superset[index])) {
return false;
}
}
});
return true;
};
/**
* Asserts that `subset` is included in `superset` in any order. Uses a deep
* equality check. Duplicates are ignored.
*
* ```js
* includeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { b: 2 } ], 'include deep members');
* ```
*/
const includeDeepMembers = (superset, subset, message) => {
if (!isDeepSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.includeDeepMembers = includeDeepMembers;
/**
* Asserts that `subset` isn't included in `superset` in any order. Uses a
* deep equality check. Duplicates are ignored.
*
* ```js
* notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');
* ```
*/
const notIncludeDeepMembers = (superset, subset, message) => {
if (isDeepSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.notIncludeDeepMembers = notIncludeDeepMembers;
const isOrderedSubset = (subset, superset) => {
if (!lodash_1.default.includes(superset, subset[0])) {
return false;
}
let index = lodash_1.default.indexOf(superset, subset[0]);
for (let i = 1; i < subset.length; i++) {
if (superset[index + i] !== subset[i]) {
return false;
}
}
return true;
};
/**
* Asserts that `subset` is included in `superset` in the same order
* beginning with the first element in `superset`. Uses a strict equality
* check (===).
*
* ```js
* includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');
* ```
*/
const includeOrderedMembers = (superset, subset, message) => {
if (!isOrderedSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.includeOrderedMembers = includeOrderedMembers;
/**
* Asserts that `subset` isn't included in `superset` in the same order
* beginning with the first element in `superset`. Uses a strict equality
* check (===).
*
* ```js
* notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');
* notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 3 ], 'not include ordered members');
* ```
*/
const notIncludeOrderedMembers = (superset, subset, message) => {
if (isOrderedSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.notIncludeOrderedMembers = notIncludeOrderedMembers;
const isDeepOrderedSubset = (subset, superset) => {
if (!lodash_1.default.includes(superset, subset[0])) {
return false;
}
let index = lodash_1.default.indexOf(superset, subset[0]);
for (let i = 1; i < subset.length; i++) {
if (!lodash_1.default.isEqual(superset[index + i], subset[i])) {
return false;
}
}
return true;
};
/**
* Asserts that `subset` is included in `superset` in the same order
* beginning with the first element in `superset`. Uses a deep equality
* check.
*
* ```js
* includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');
* ```
*/
const includeDeepOrderedMembers = (superset, subset, message) => {
if (!isDeepOrderedSubset(subset, superset)) {
throw new assertion_error_1.default(message);
}
};
exports.includeDeepOrderedMembers = includeDee