Enable debouncing of callbacks, with various styles of debounce supported in DebounceStyle +
Enable debouncing of callbacks, with various styles of debounce supported in DebounceStyle
(see its docs for debounce style details). A callback can be provided on construction or to the
.execute() method.
import {Debounce} from '@augment-vir/common';
const debounce = new Debounce(
DebounceStyle.FirstThenWait,
{
milliseconds: 500,
},
// callback can optionally be provided on construction
() => {
console.log('called');
},
);
debounce.execute();
// providing a callback in `.execute()` permanently overrides the callback provided in construction.
debounce.execute(() => {});
Duration between debounces.
Optionalcallback: () => MaybePromise<void>Set the callback to be triggered on .execute(). If this is not set, the callback to be
called can be passed in .execute() instead.
OptionalcallbackSet the callback to be triggered on .execute(). If this is not set, the callback to be
called can be passed in .execute() instead.
Duration between debounces.
-Debounce style. See DebounceStyle for more details.
-Call the callback, if one has been set yet, if the current debounce timer is up.
-Optionalcallback: () => MaybePromise<void>Duration between debounces.
+Debounce style. See DebounceStyle for more details.
+Call the callback, if one has been set yet, if the current debounce timer is up.
+Optionalcallback: () => MaybePromise<void>Creates a promise that can be resolved or rejected at any later time. It also includes indication +
Creates a promise that can be resolved or rejected at any later time. It also includes indication on whether its been settled yet or not.
ReadonlyisIndicates whether the promise has been settled (resolved or rejected) yet.
-The deferred promise which can be awaited.
-Call this to reject the deferred promise with the given reason.
-Call this to resolve the deferred promise with the given value.
-ReadonlyisIndicates whether the promise has been settled (resolved or rejected) yet.
+The deferred promise which can be awaited.
+Call this to reject the deferred promise with the given reason.
+Call this to resolve the deferred promise with the given value.
+An error thrown by the Prisma API that indicates that applying migrations in dev failed such that +
An error thrown by the Prisma API that indicates that applying migrations in dev failed such that
a new migration is needed. You can do that by prompting user for a new migration name and passing
it to prisma.migration.create.
An error thrown by the Prisma API that indicates that applying migrations in dev failed such that +
An error thrown by the Prisma API that indicates that applying migrations in dev failed such that
the entire database needs to be reset. You can do that by calling prisma.database.resetDev.
An error thrown by the Prisma API that indicates that something is wrong with the given Prisma +
An error thrown by the Prisma API that indicates that something is wrong with the given Prisma schema. See the error message for more details.
A queue that manages its items with promises.
+A queue that manages its items with promises.
Add an item to the queue.
+Add an item to the queue.
A promise that resolves at the same time as the added item.
-ProtectedhandleHandles a queue item finishing, whether it be a rejection or a resolution.
-ProtectedtriggerTries to trigger the next queue item, if there is one.
+ProtectedhandleHandles a queue item finishing, whether it be a rejection or a resolution.
+ProtectedtriggerThe event emitted from a PromiseQueue instance whenever the queue is updated (an item is +
The event emitted from a PromiseQueue instance whenever the queue is updated (an item is resolved or an item is added).
An error thrown by wrapPromiseInTimeout when the timeout is reached.
+An error thrown by wrapPromiseInTimeout when the timeout is reached.
OptionalfailureMessage: stringOptionalfailureMessage: stringThrow this Error to indicate that something was attempted that cannot be done in the current +
Throw this Error to indicate that something was attempted that cannot be done in the current runtime.
Optionalmessage: stringOptionalmessage: stringOptionaloptions: ErrorOptionsOptionalmessage: stringOptionalmessage: stringOptionaloptions: ErrorOptionsAn event that indicates that the shell command is finished. This contains an exit code or an exit +
An event that indicates that the shell command is finished. This contains an exit code or an exit signal. Based on the Node.js documentation, either one or the other is defined, never both at the same time.
An event that indicates that the shell command errored.
+An event that indicates that the shell command errored.
An event that indicates that the shell command just wrote to stderr.
+An event that indicates that the shell command just wrote to stderr.
An event that indicates that the shell command just wrote to stdout.
+An event that indicates that the shell command just wrote to stdout.
A shell command listen target that emits events.
+A shell command listen target that emits events.
An error that is thrown from assertSnapshot when the snapshot comparison fails due to the +
An error that is thrown from assertSnapshot when the snapshot comparison fails due to the snapshot expectation file simply not existing.
Different types of debouncing for the Debounce class.
+Different types of debouncing for the Debounce class.
Waits the given amount of milliseconds after the first call and then fires the latest assigned callback.
@@ -35,7 +35,7 @@ -Fires on the first call, then waits the given amount of milliseconds until another call is +
Fires on the first call, then waits the given amount of milliseconds until another call is allowed through.
.execute() calls with a 25ms debounce time looks like this:
All possible statuses for an existing container.
+All possible statuses for an existing container.
This is not a native Docker status but indicates that the container does not exist.
-This is not a native Docker status but indicates that the container does not exist.
+Used for type in DockerVolumeMap. These types are apparently only relevant for running
+
Used for type in DockerVolumeMap. These types are apparently only relevant for running
Docker on macOS and are potentially irrelevant now. It's likely best to leave the type property
empty (undefined).
All standardized HTTP status codes.
+All standardized HTTP status codes.
These values are automatically parsed from https://developer.mozilla.org/docs/Web/HTTP/Status via https://github.com/electrovir/augment-vir/blob/dev/packages/scripts/src/scripts/generate-http-status.script.ts
Used inside a dav:propstat response element to avoid repeatedly enumerating +
Used inside a dav:propstat response element to avoid repeatedly enumerating the internal members of multiple bindings to the same collection.
-This error response means that the server, while working as a gateway to get a response +
This error response means that the server, while working as a gateway to get a response needed to handle the request, got an invalid response.
-The server cannot or will not process the request due to something that is perceived to be a +
The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
-This response is sent when a request conflicts with the current state of the server.
+This response is sent when a request conflicts with the current state of the server.
-This interim response indicates that the client should continue the request or ignore the +
This interim response indicates that the client should continue the request or ignore the response if the request is already finished.
-The request succeeded, and a new resource was created as a result. This is typically the +
The request succeeded, and a new resource was created as a result. This is typically the response sent after POST requests, or some PUT requests.
-This status code is primarily intended to be used with the Link header, letting the user +
This status code is primarily intended to be used with the Link header, letting the user agent start preloading resources while the server prepares a response or preconnect to an origin from which the page will need resources.
-This response code means the expectation indicated by the Expect request header field cannot +
This response code means the expectation indicated by the Expect request header field cannot be met by the server.
-The request failed due to failure of a previous request.
+The request failed due to failure of a previous request.
-The client does not have access rights to the content; that is, it is unauthorized, so the +
The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
-This response code means that the URI of requested resource has been changed temporarily. +
This response code means that the URI of requested resource has been changed temporarily. Further changes in the URI might be made in the future. Therefore, this same URI should be used by the client in future requests.
-This error response is given when the server is acting as a gateway and cannot get a response +
This error response is given when the server is acting as a gateway and cannot get a response in time.
-This response is sent when the requested content has been permanently deleted from server, +
This response is sent when the requested content has been permanently deleted from server, with no forwarding address. Clients are expected to remove their caches and links to the resource. The HTTP specification intends this status code to be used for "limited-time, promotional services". APIs should not feel compelled to indicate resources that have been deleted with this status code.
-The HTTP version used in the request is not supported by the server.
+The HTTP version used in the request is not supported by the server.
-The server refuses the attempt to brew coffee with a teapot.
+The server refuses the attempt to brew coffee with a teapot.
-The server has fulfilled a GET request for the resource, and the response is a representation +
The server has fulfilled a GET request for the resource, and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
-The method could not be performed on the resource because the server is unable to store the +
The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request.
-The server has encountered a situation it does not know how to handle.
+The server has encountered a situation it does not know how to handle.
-Server rejected the request because the Content-Length header field is not defined and the +
Server rejected the request because the Content-Length header field is not defined and the server requires it.
-The resource that is being accessed is locked.
+The resource that is being accessed is locked.
-The server detected an infinite loop while processing the request.
+The server detected an infinite loop while processing the request.
-The request method is known by the server but is not supported by the target resource. For +
The request method is known by the server but is not supported by the target resource. For example, an API may not allow calling DELETE to remove a resource.
-The request was directed at a server that is not able to produce a response. This can be sent +
The request was directed at a server that is not able to produce a response. This can be sent by a server that is not configured to produce responses for the combination of scheme and authority that are included in the request URI.
-The URL of the requested resource has been changed permanently. The new URL is given in the +
The URL of the requested resource has been changed permanently. The new URL is given in the response.
-The request has more than one possible response. The user agent or user should choose one of +
The request has more than one possible response. The user agent or user should choose one of them. (There is no standardized way of choosing one of the responses, but HTML links to the possibilities are recommended so the user can pick.)
-Conveys information about multiple resources, for situations where multiple status codes +
Conveys information about multiple resources, for situations where multiple status codes might be appropriate.
-Indicates that the client needs to authenticate to gain network access.
+Indicates that the client needs to authenticate to gain network access.
-There is no content to send for this request, but the headers may be useful. The user agent +
There is no content to send for this request, but the headers may be useful. The user agent may update its cached headers for this resource with the new ones.
-This response code means the returned metadata is not exactly the same as is available from +
This response code means the returned metadata is not exactly the same as is available from the origin server, but is collected from a local or a third-party copy. This is mostly used for mirrors or backups of another resource. Except for that specific case, the 200 OK response is preferred to this status.
-This response is sent when the web server, after performing server-driven content +
This response is sent when the web server, after performing server-driven content negotiation, doesn't find any content that conforms to the criteria given by the user agent.
-Further extensions to the request are required for the server to fulfill it.
+Further extensions to the request are required for the server to fulfill it.
-The server cannot find the requested resource. In the browser, this means the URL is not +
The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
-The request method is not supported by the server and cannot be handled. The only methods +
The request method is not supported by the server and cannot be handled. The only methods that servers are required to support (and therefore that must not return this code) are GET and HEAD.
-This is used for caching purposes. It tells the client that the response has not been +
This is used for caching purposes. It tells the client that the response has not been modified, so the client can continue to use the same cached version of the response.
-The request succeeded. The result meaning of "success" depends on the HTTP method:
+The request succeeded. The result meaning of "success" depends on the HTTP method:
This response code is used when the Range header is sent from the client to request only part +
This response code is used when the Range header is sent from the client to request only part of a resource.
-Request entity is larger than limits defined by server. The server might close the connection +
Request entity is larger than limits defined by server. The server might close the connection or return an Retry-After header field.
-This response code is reserved for future use. The initial aim for creating this code was +
This response code is reserved for future use. The initial aim for creating this code was using it for digital payment systems, however this status code is used very rarely and no standard convention exists.
-This means that the resource is now permanently located at another URI, specified by the +
This means that the resource is now permanently located at another URI, specified by the Location: HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.
-The client has indicated preconditions in its headers which the server does not meet.
+The client has indicated preconditions in its headers which the server does not meet.
-The origin server requires the request to be conditional. This response is intended to +
The origin server requires the request to be conditional. This response is intended to prevent the 'lost update' problem, where a client GETs a resource's state, modifies it and PUTs it back to the server, when meanwhile a third party has modified the state on the server, leading to a conflict.
-This code indicates that the server has received and is processing the request, but no +
This code indicates that the server has received and is processing the request, but no response is available yet.
-This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
+This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
-The range specified by the Range header field in the request cannot be fulfilled. It's +
The range specified by the Range header field in the request cannot be fulfilled. It's possible that the range is outside the size of the target URI's data.
-The server is unwilling to process the request because its header fields are too large. The +
The server is unwilling to process the request because its header fields are too large. The request may be resubmitted after reducing the size of the request header fields.
-This response is sent on an idle connection by some servers, even without any previous +
This response is sent on an idle connection by some servers, even without any previous request by the client. It means that the server would like to shut down this unused connection. This response is used much more since some browsers, like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing. Also note that some servers merely shut down the connection without sending this message.
-Tells the user agent to reset the document which sent this request.
+Tells the user agent to reset the document which sent this request.
-The server sent this response to direct the client to get the requested resource at another +
The server sent this response to direct the client to get the requested resource at another URI with a GET request.
-The server is not ready to handle the request. Common causes are a server that is down for +
The server is not ready to handle the request. Common causes are a server that is down for maintenance or that is overloaded. Note that together with this response, a user-friendly page explaining the problem should be sent. This response should be used for temporary conditions and the Retry-After HTTP header should, if possible, contain the estimated time @@ -239,46 +239,46 @@ caching-related headers that are sent along with this response, as these temporary condition responses should usually not be cached.
-This code is sent in response to an Upgrade request header from the client and indicates the +
This code is sent in response to an Upgrade request header from the client and indicates the protocol the server is switching to.
-The server sends this response to direct the client to get the requested resource at another +
The server sends this response to direct the client to get the requested resource at another URI with the same method that was used in the prior request. This has the same semantics as the 302 Found HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.
-Indicates that the server is unwilling to risk processing a request that might be replayed.
+Indicates that the server is unwilling to risk processing a request that might be replayed.
-The user has sent too many requests in a given amount of time ("rate limiting").
+The user has sent too many requests in a given amount of time ("rate limiting").
-Although the HTTP standard specifies "unauthorized", semantically this response means +
Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
-The user agent requested a resource that cannot legally be provided, such as a web page +
The user agent requested a resource that cannot legally be provided, such as a web page censored by a government.
-The request was well-formed but was unable to be followed due to semantic errors.
+The request was well-formed but was unable to be followed due to semantic errors.
-The media format of the requested data is not supported by the server, so the server is +
The media format of the requested data is not supported by the server, so the server is rejecting the request.
-This response code is no longer used; it is just reserved. It was used in a previous version +
This response code is no longer used; it is just reserved. It was used in a previous version of the HTTP/1.1 specification.
-The server refuses to perform the request using the current protocol but might be willing to +
The server refuses to perform the request using the current protocol but might be willing to do so after the client upgrades to a different protocol. The server sends an Upgrade header in a 426 response to indicate the required protocol(s).
-The URI requested by the client is longer than the server is willing to interpret.
+The URI requested by the client is longer than the server is willing to interpret.
-Defined in a previous version of the HTTP specification to indicate that a requested response +
Defined in a previous version of the HTTP specification to indicate that a requested response must be accessed by a proxy. It has been deprecated due to security concerns regarding in-band configuration of a proxy.
-The server has an internal configuration error: the chosen variant resource is configured to +
The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.
-All standardized HTTP status code categories. These are determined by the first number in the +
Standardized color keys for logging. If you want to use customized colors, use +
Standardized color keys for logging. If you want to use customized colors, use ansi-styles in Node.js or custom CSS in browsers.
Supported log output types.
+Logged to stdout if the current environment supports it, or just console.log.
The three major operating system types.
+The three major operating system types.
JavaScript runtime env.
+The different string cases.
+Convert the given number into a string, then add commas like a normal number would have.
+Adds the '%' suffix to a string if it does not already exist.
Adds the '%' suffix to a string if it does not already exist.
Adds a prefix to a string if it does not already exist.
+Adds a prefix to a string if it does not already exist.
Creates a new RegExp by adding the given flags to the original RegExp.
Adds a suffix to a string if it does not already exist.
+Adds a suffix to a string if it does not already exist.
Appends all provided JSON values together. undefined values will be ignored. The first value
+
Appends all provided JSON values together. undefined values will be ignored. The first value
determines whether the output will be an object or an array. Any value appended to an array will
work just fine, but primitives append to an object will likely behave unexpectedly. Arrays
appended to arrays will be flattened (but only by one level).
Append the given newData to the contents of the existing JSON file. If the file does not yet
+
Append the given newData to the contents of the existing JSON file. If the file does not yet
exist, newData is written as its only JSON contents.
Useful for debugging purposes, this sticks an absolutely positioned and brightly colored div at +
Similar to groupArrayBy but maps array entries to a single key and requires key and
+
Similar to groupArrayBy but maps array entries to a single key and requires key and
value outputs from the callback. The resulting object does not have an array of elements
(unless the original array itself contains arrays). Automatically handles the case where the
callback returns a promise.
Asks the user a question in their terminal and then waits for them to type something in response. +
Asks the user a question in their terminal and then waits for them to type something in response. The response is accepted once the user inputs a new line.
Asks the user a question in their terminal and then waits for them to type something in response. +
Asks the user a question in their terminal and then waits for them to type something in response. The response is submitted once the user inputs a new line. If the response fails validation, the question is presented again.
A group of guard methods that assert their conditions and do nothing else.
+A group of guard methods that assert their conditions and do nothing else.
This can also be called as a standalone assertion function which asserts that its input is truthy.
import {assert} from '@augment-vir/assert';
const value: unknown = 'some value' as unknown;
assert.isString(value);
// `value` will now be typed as a `string`
@@ -6,7 +6,7 @@
AssertionError When the assertion fails.
Asserts that a parent string or array does not end with a specific child. This uses +
Asserts that a parent string or array does not end with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {assert} from '@augment-vir/assert';
assert.endsWithout('ab', 'b'); // fails
assert.endsWithout('ab', 'a'); // passes
assert.endsWithout(['a', 'b'], 'b'); // fails
assert.endsWithout(['a', 'b'], 'a'); // passes
@@ -120,19 +120,19 @@
assert.endsWith : the opposite assertion.
assert.startsWithout : assertion on the other end.
-Immediately throw an assertion error.
+Immediately throw an assertion error.
Asserts that a value is an instance of the built-in Error class and compares it to the
+
Asserts that a value is an instance of the built-in Error class and compares it to the
given ErrorMatchOptions, if provided.
Type guards the input.
import {assert} from '@augment-vir/assert';
assert.isError(new Error()); // passes
assert.isError(new Error(), {matchMessage: 'hi'}); // fails
assert.isError({message: 'not an error'}); // fails
AssertionError If the assertion fails.
-Asserts that an array or string has at least the given length.
+Asserts that an array or string has at least the given length.
Type guards an array into an AtLeastTuple. Performs no type guarding on a string.
import {assert} from '@augment-vir/assert';
assert.isLengthAtLeast(['a', 'b', 'c'], 2); // passes
assert.isLengthAtLeast(['a', 'b', 'c'], 3); // passes
assert.isLengthAtLeast(['a', 'b'], 3); // fails
Asserts that an array or string has exactly the given length.
+Asserts that an array or string has exactly the given length.
Type guards an array into a Tuple. Performs no type guarding on a string.
import {assert} from '@augment-vir/assert';
assert.isLengthExactly(['a', 'b', 'c'], 2); // fails
assert.isLengthExactly(['a', 'b', 'c'], 3); // passes
assert.isLengthExactly(['a', 'b'], 3); // fails
Asserts that the output of the given function deeply equals expectations. A custom asserter +
Asserts that the output of the given function deeply equals expectations. A custom asserter can optionally be provided as the first argument to change the expectation checking from "deeply equals" to whatever you want.
Performs no type guarding.
@@ -158,7 +158,7 @@AssertionError If the assertion fails.
-Asserts that a parent string or array starts with a specific child. This uses reference +
Asserts that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {assert} from '@augment-vir/assert';
assert.startsWith('ab', 'b'); // fails
assert.startsWith('ab', 'a'); // passes
assert.startsWith(['a', 'b'], 'b'); // fails
assert.startsWith(['a', 'b'], 'a'); // passes
@@ -169,7 +169,7 @@
assert.startsWithout : the opposite assertion.
assert.endsWith : assertion on the other end.
-Asserts that a parent string or array starts with a specific child. This uses reference +
Asserts that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {assert} from '@augment-vir/assert';
assert.startsWith('ab', 'b'); // passes
assert.startsWith('ab', 'a'); // fails
assert.startsWith(['a', 'b'], 'b'); // passes
assert.startsWith(['a', 'b'], 'a'); // fails
@@ -180,7 +180,7 @@
assert.startsWithout : the opposite assertion.
assert.endsWith : assertion on the other end.
-If a function input is provided:
+If a function input is provided:
Calls that function and asserts that the function throw an error, comparing the error with the given ErrorMatchOptions, if provided.
If a promise is provided:
@@ -193,7 +193,7 @@AssertionError If the assertion fails.
-Asserts within the TypeScript type system that a given type or value matches type +
Asserts within the TypeScript type system that a given type or value matches type
expectations (using the expect-type package.
Make sure to call a method on the first call to actually assert anything.
Use this to write type tests. Don't use this in production code. It won't cause issues, but @@ -206,7 +206,7 @@
Asserts that two values are deeply equal using the deep-eql package.
Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).
@@ -220,7 +220,7 @@Asserts that two objects are deeply equal by checking only their top-level values for strict
(non-deep, reference, using
===)
equality.
Asserts that a parent value has the key.
Type guards the parent value.
import {assert} from '@augment-vir/assert';
assert.hasKey({a: 0, b: 1}, 'a'); // passes
assert.hasKey({a: 0, b: 1}, 'c'); // fails
Asserts that a parent value has all the keys.
Type guards the parent value.
import {assert} from '@augment-vir/assert';
assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
Asserts that an object/array parent includes a child value through reference equality.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
const child = {a: 'a'};
assert.hasValue({child}, child); // passes
assert.hasValue({child: {a: 'a'}}, child); // fails
assert.hasValue([child], child); // passes
Asserts that an object/array parent includes all child values through reference equality.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
assert.hasValues({child, child2}, [child, child2]); // passes
assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
assert.hasValues([child], [child, child2]); // passes
Asserts that a value is an instance of the given class constructor.
Type guards the value.
The constructor that the "instance" input will be checked against.
OptionalfailureMessage: stringMessage to include in error message if this assertion fails.
@@ -286,7 +286,7 @@Asserts that a number is above the expectation (actual > expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isAbove(10, 5); // passes
assert.isAbove(5, 5); // fails
assert.isAbove(5, 10); // fails
Asserts that a number is within ±delta of the expectation.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isApproximately(10, 8, 4); // passes
assert.isApproximately(10, 12, 4); // passes
assert.isApproximately(10, 8, 1); // fails
assert.isApproximately(10, 12, 1); // fails
Asserts that a value is an array.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isArray([]); // passes
assert.isArray({length: 4}); // fails
Asserts that a number is at least the expectation (actual >= expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isAtLeast(10, 5); // passes
assert.isAtLeast(5, 5); // passes
assert.isAtLeast(5, 10); // fails
Asserts that a number is at most the expectation (actual <= expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isAtMost(10, 5); // fails
assert.isAtMost(5, 5); // passes
assert.isAtMost(5, 10); // passes
Asserts that a number is below the expectation (actual < expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isBelow(10, 5); // fails
assert.isBelow(5, 5); // fails
assert.isBelow(5, 10); // passes
Asserts that a value is a BigInt.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isBigInt(123n); // passes
assert.isBigInt(123); // fails
Asserts that a value is a boolean.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isBoolean(true); // passes
assert.isBoolean('true'); // fails
Asserts that a value is defined (not null and not undefined).
Type guards the value.
The value to check.
OptionalfailureMessage: stringMessage to include in error message if this assertion fails.
@@ -373,7 +373,7 @@Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
+Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isEmpty({}); // passes
assert.isEmpty(''); // passes
assert.isEmpty([]); // passes
assert.isEmpty('a'); // fails
assert.isEmpty({a: 'a'}); // fails
Asserts that a child value is an enum member.
+Asserts that a child value is an enum member.
Type guards the child value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
enum MyEnum {
A = 'a',
B = 'b',
}
assert.isEnumValue('a', MyEnum); // passes
assert.isEnumValue('A', MyEnum); // fails
Asserts that a value is exactly false.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isFalse(true); // fails
assert.isFalse(false); // passes
assert.isFalse(1); // fails
assert.isFalse(0); // fails
Asserts that a value is falsy.
+Asserts that a value is falsy.
Type guards the value when possible.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isFalsy(true); // fails
assert.isFalsy(false); // passes
assert.isFalsy(1); // fails
assert.isFalsy(0); // passes
Asserts that a number is finite: meaning, not NaN and not Infinity or -Infinity.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isFinite(10); // passes
assert.isFinite(parseInt('invalid')); // fails
assert.isFinite(Infinity); // fails
assert.isFinite(-Infinity); // fails
Asserts that a value is a function.
+Asserts that a value is a function.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isFunction(() => {}); // passes
assert.isFunction({}); // fails
Asserts that a value is an HttpStatus.
+Asserts that a value is an HttpStatus.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isHttpStatus(400); // passes
assert.isHttpStatus(500); // passes
assert.isHttpStatus(99); // fails
Asserts that a value is an HttpStatus within a specific HttpStatusCategory.
+Asserts that a value is an HttpStatus within a specific HttpStatusCategory.
Type guards the value.
import {assert} from '@augment-vir/assert';
assert.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // passes
assert.isHttpStatusCategory(500, HttpStatusCategory.Success); // fails
assert.isHttpStatusCategory(99, HttpStatusCategory.Information); // fails
Asserts that child value is contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
const child = {a: 'a'};
assert.isIn(child, {child}); // passes
assert.isIn('a', 'ab'); // passes
assert.isIn(child, [child]); // passes
assert.isIn(child, {child: {a: 'a'}}); // fails
assert.isIn('a', 'bc'); // fails
@@ -463,7 +463,7 @@
Asserts that a number is inside the provided min and max bounds, inclusive.
+Asserts that a number is inside the provided min and max bounds, inclusive.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isInBounds(5, {min: 1, max: 10}); // passes
assert.isInBounds(10, {min: 1, max: 10}); // passes
assert.isInBounds(11, {min: 1, max: 10}); // fails
assert.isInBounds(0, {min: 1, max: 10}); // fails
Asserts that a number is either Infinity or -Infinity.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isInfinite(10); // fails
assert.isInfinite(parseInt('invalid')); // fails
assert.isInfinite(Infinity); // passes
assert.isInfinite(-Infinity); // passes
Asserts that a number is an integer. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isInteger(5); // passes
assert.isInteger(5.0000000000000001); // passes
assert.isInteger(5.1); // fails
assert.isInteger(NaN); // fails
@@ -492,7 +492,7 @@
Asserts that a key is contained within a parent value.
Type guards the key.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isKeyof('a', {a: 0, b: 1}); // passes
assert.isKeyof('c', {a: 0, b: 1}); // fails
Asserts that a number is
NaN.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNaN(10); // fails
assert.isNaN(parseInt('invalid')); // passes
assert.isNaN(Infinity); // fails
@@ -511,7 +511,7 @@
Asserts that a number is outside ±delta of the expectation.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotApproximately(10, 8, 4); // fails
assert.isNotApproximately(10, 12, 4); // fails
assert.isNotApproximately(10, 8, 1); // passes
assert.isNotApproximately(10, 12, 1); // passes
Asserts that a value is not an array.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotArray([]); // fails
assert.isNotArray({length: 4}); // passes
Asserts that a value is not a BigInt.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotBigInt(123n); // fails
assert.isNotBigInt(123); // passes
Asserts that a value is not a boolean.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotBoolean(true); // fails
assert.isNotBoolean('true'); // passes
Asserts that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
+Asserts that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotEmpty({}); // fails
assert.isNotEmpty(''); // fails
assert.isNotEmpty([]); // fails
assert.isNotEmpty('a'); // passes
assert.isNotEmpty({a: 'a'}); // passes
Asserts that a child value is not an enum member.
Type guards the child value.
import {assert} from '@augment-vir/assert';
enum MyEnum {
A = 'a',
B = 'b',
}
assert.isNotEnumValue('a', MyEnum); // fails
assert.isNotEnumValue('A', MyEnum); // passes
Asserts that a value is not a function.
+Asserts that a value is not a function.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotFunction(() => {}); // fails
assert.isNotFunction({}); // passes
Asserts that child value is not contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
import {assert} from '@augment-vir/assert';
const child = {a: 'a'};
assert.isNotIn(child, {child}); // fails
assert.isNotIn('a', 'ab'); // fails
assert.isNotIn(child, [child]); // fails
assert.isNotIn(child, {child: {a: 'a'}}); // passes
assert.isNotIn('a', 'bc'); // passes
@@ -584,7 +584,7 @@
Asserts that a number is not an integer. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotInteger(5); // fails
assert.isNotInteger(5.0000000000000001); // fails
assert.isNotInteger(5.1); // passes
assert.isNotInteger(NaN); // passes
@@ -594,7 +594,7 @@
Asserts that a key is not contained within a parent value.
Type guards the key.
import {assert} from '@augment-vir/assert';
assert.isNotKeyOf('a', {a: 0, b: 1}); // fails
assert.isNotKeyOf('c', {a: 0, b: 1}); // passes
Asserts that a value is not exactly null.
Type guards the value.
OptionalfailureMessage: stringAsserts that a value is not a number. This includes NaN.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotNumber(123); // fails
assert.isNotNumber(123n); // passes
Asserts that a value is not an object. This includes arrays.
+Asserts that a value is not an object. This includes arrays.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotObject({}); // fails
assert.isNotObject([]); // passes
Asserts that a value is not a JavaScript primitive.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isPrimitive('key'); // fails
assert.isPrimitive(true); // fails
assert.isPrimitive({}); // passes
@@ -645,7 +645,7 @@
Asserts that a value is a not Promise instance.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
}
}
assert.isNotPromise(Promise.resolve(5)); // fails
assert.isNotPromise(new CustomThenable(5)); // passes
assert.isNotPromise(5); // passes
Asserts that a value is not a PromiseLike.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like a
promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Asserts that a value is not a valid PropertyKey. PropertyKey is a built-in TypeScript
type which refers to all possible key types for a JavaScript object.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotPropertyKey('key'); // fails
assert.isNotPropertyKey(true); // passes
assert.isNotPropertyKey({}); // passes
@@ -678,7 +678,7 @@
Asserts that a value is not a string.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotString(''); // fails
assert.isNotString(5); // passes
Asserts that a value is not a symbol.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotSymbol(Symbol('my-symbol')); // fails
assert.isNotSymbol('my-symbol'); // passes
Asserts that a value is not exactly undefined.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNotUndefined(undefined); // fails
assert.isNotUndefined(null); // passes
Asserts that a value is not a valid UUID. The nil or max UUIDs are included as not valid.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
assert.isNotUuid(createUuidV4()); // fails
assert.isNotUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // fails
assert.isNotUuid('00000000-0000-0000-0000-000000000000'); // passes
assert.isNotUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // passes
assert.isNotUuid('not-a-uuid'); // passes
Asserts that a value is exactly null.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNull(null); // passes
assert.isNull(undefined); // fails
Asserts that a value is nullish (null or undefined).
Type guards the value.
The value to check.
OptionalfailureMessage: stringMessage to include in error message if this assertion fails.
@@ -734,7 +734,7 @@Asserts that a value is a number. This excludes NaN.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isNumber(123); // passes
assert.isNumber(123n); // fails
Asserts that a value is an object. This excludes arrays.
+Asserts that a value is an object. This excludes arrays.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isObject({}); // passes
assert.isObject([]); // fails
Asserts that a number is outside the provided min and max bounds, exclusive.
+Asserts that a number is outside the provided min and max bounds, exclusive.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isOutBounds(5, {min: 1, max: 10}); // fails
assert.isOutBounds(10, {min: 1, max: 10}); // fails
assert.isOutBounds(11, {min: 1, max: 10}); // passes
assert.isOutBounds(0, {min: 1, max: 10}); // passes
Asserts that a value is a JavaScript primitive.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isPrimitive('key'); // passes
assert.isPrimitive(true); // passes
assert.isPrimitive({}); // fails
@@ -771,7 +771,7 @@
Asserts that a value is a Promise instance.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(onFulfilled ? onFulfilled(this.value) : this.value);
}
}
assert.isPromise(Promise.resolve(5)); // passes
assert.isPromise(new CustomThenable(5)); // fails
assert.isPromise(5); // fails
Asserts that a value is a PromiseLike.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like a
promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Asserts that a value is a valid PropertyKey. PropertyKey is a built-in TypeScript type
which refers to all possible key types for a JavaScript object.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isPropertyKey('key'); // passes
assert.isPropertyKey(true); // fails
assert.isPropertyKey({}); // fails
@@ -804,7 +804,7 @@
Asserts that a value is a string.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isString(''); // passes
assert.isString(5); // fails
Asserts that a value is a symbol.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isSymbol(Symbol('my-symbol')); // passes
assert.isSymbol('my-symbol'); // fails
Asserts that a value is exactly true.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isTrue(true); // passes
assert.isTrue(false); // fails
assert.isTrue(1); // fails
assert.isTrue(0); // fails
Asserts that a value is truthy.
+Asserts that a value is truthy.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isTruthy(true); // passes
assert.isTruthy(false); // fails
assert.isTruthy(1); // passes
assert.isTruthy(0); // fails
Asserts that a value is exactly undefined.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.isUndefined(undefined); // passes
assert.isUndefined(null); // fails
Asserts that a value is a valid UUID. Does not accept the nil or max UUIDs.
Type guards the value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
assert.isUuid(createUuidV4()); // passes
assert.isUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // passes
assert.isUuid('00000000-0000-0000-0000-000000000000'); // fails
assert.isUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // fails
assert.isUuid('not-a-uuid'); // fails
Asserts that two values are deeply equal when stringified into JSON. This will fail or may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order.
Type guards the first value.
@@ -873,7 +873,7 @@Asserts that a parent value does not have the key.
Type guards the parent value.
import {assert} from '@augment-vir/assert';
assert.lacksKey({a: 0, b: 1}, 'a'); // fails
assert.lacksKey({a: 0, b: 1}, 'c'); // passes
Asserts that a parent value none of the keys.
Type guards the parent value.
import {assert} from '@augment-vir/assert';
assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
Asserts that an object/array parent does not include a child value through reference equality.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
const child = {a: 'a'};
assert.lacksValue({child}, child); // fails
assert.lacksValue({child: {a: 'a'}}, child); // passes
assert.lacksValue([child], child); // fails
@@ -904,7 +904,7 @@
- assert.hasValue : the opposite assertion.
- assert.lacksValues : the multi-value assertion.
-Asserts that an object/array parent includes none of the provided child values through reference equality.
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
assert.lacksValues({}, [child, child2]); // passes
assert.lacksValues({child, child2}, [child, child2]); // fails
assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
@@ -915,7 +915,7 @@
- assert.lacksValues : the opposite assertion.
- assert.hasValue : the single-value assertion.
-Asserts that two values are loosely equal (using
==).
Type guards the first value.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.looseEquals('a', 'a'); // passes
assert.looseEquals('1', 1); // passes
assert.looseEquals({a: 'a'}, {a: 'a'}); // fails
const objectExample = {a: 'a'};
assert.looseEquals(objectExample, objectExample); // passes
@@ -926,7 +926,7 @@
- assert.notLooseEquals : the opposite assertion.
- assert.strictEquals : the strict equality assertion.
-Asserts that a string (first input, actual) matches a RegExp (second input, expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.matches('hi', /^h/); // passes
assert.matches('hi', /^g/); // fails
Asserts that a string (first input, actual) does not match a RegExp (second input,
expected).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.mismatches('hi', /^h/); // fails
assert.mismatches('hi', /^g/); // passes
@@ -945,7 +945,7 @@
Asserts that two values are not deeply equal using the deep-eql package.
Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).
@@ -959,7 +959,7 @@Asserts that two objects are not deeply equal by checking only their top-level values for
strict (non-deep, reference, using
===)
equality.
Asserts that a value is not an instance of the given class constructor.
Type guards the value.
import {assert} from '@augment-vir/assert';
assert.notInstanceOf(/abc/, RegExp); // fails
assert.notInstanceOf('abc', RegExp); // passes
Asserts that two values are not deeply equal when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order.
Performs no type guarding.
@@ -995,7 +995,7 @@Asserts that two values are not loosely equal (using
==).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.notLooseEquals('a', 'a'); // fails
assert.notLooseEquals('1', 1); // fails
assert.notLooseEquals({a: 'a'}, {a: 'a'}); // passes
const objectExample = {a: 'a'};
assert.notLooseEquals(objectExample, objectExample); // fails
@@ -1006,7 +1006,7 @@
- assert.looseEquals : the opposite assertion.
- assert.strictEquals : the strict equality assertion.
-Asserts that two values are not strictly equal (using
===).
Performs no type guarding.
OptionalfailureMessage: stringimport {assert} from '@augment-vir/assert';
assert.notStrictEquals('a', 'a'); // fails
assert.notStrictEquals('1', 1); // passes
assert.notStrictEquals({a: 'a'}, {a: 'a'}); // passes
const objectExample = {a: 'a'};
assert.notStrictEquals(objectExample, objectExample); // fails
@@ -1017,7 +1017,7 @@
- assert.strictEquals : the opposite assertion.
- assert.notLooseEquals : the loose equality assertion.
-Asserts that two values are strictly equal (using
===).
Type guards the first value.
import {assert} from '@augment-vir/assert';
assert.strictEquals('a', 'a'); // passes
assert.strictEquals('1', 1); // fails
assert.strictEquals({a: 'a'}, {a: 'a'}); // fails
const objectExample = {a: 'a'};
assert.strictEquals(objectExample, objectExample); // passes
@@ -1028,4 +1028,4 @@
- assert.notStrictEquals : the opposite assertion.
- assert.looseEquals : the loose equality assertion.
-Assert that the given snapshot data matches already-saved snapshot file's expectations. Note that +
Assert that the given snapshot data matches already-saved snapshot file's expectations. Note that the given data will be serialized into a JSON string if it is not already a string. This works in both Node and web tests.
Web tests require a web-test-runner config with the snapshotPlugin plugin from
@virmator/test/dist/web-snapshot-plugin/web-snapshot-plugin.js in order to work.
Asserts that the given context is for the given env, otherwise throws an Error.
-Asserts that the given context is for the given env, otherwise throws an Error.
+A group of guard methods that do the following:
+A group of guard methods that do the following:
AssertionError When the assertion fails.
Asserts that a parent string or array does not end with a specific child. This uses +
Asserts that a parent string or array does not end with a specific child. This uses reference equality when the parent is an array. Returns the parent if the assertion passes.
Performs no type guarding.
@@ -127,7 +127,7 @@Asserts that an array or string has at least the given length. Returns the value if the +
Asserts that an array or string has at least the given length. Returns the value if the assertion passes.
Type guards an array into an AtLeastTuple. Performs no type guarding on a string.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
assertWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
assertWrap.isLengthAtLeast(['a', 'b'], 3); // throws an error
@@ -138,7 +138,7 @@
Asserts that an array or string has exactly the given length. Returns the value if the +
Asserts that an array or string has exactly the given length. Returns the value if the assertion passes.
Type guards an array into a Tuple. Performs no type guarding on a string.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isLengthExactly(['a', 'b', 'c'], 2); // throws an error
assertWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
assertWrap.isLengthExactly(['a', 'b'], 3); // throws an error
@@ -149,7 +149,7 @@
Asserts that the output of the given function deeply equals expectations. A custom +
Asserts that the output of the given function deeply equals expectations. A custom asserter can optionally be provided as the first argument to change the expectation checking from the default "deeply equals" to whatever you want. Returns the output if the assertion passes.
@@ -159,7 +159,7 @@AssertionError If the assertion fails.
-Checks that a parent string or array starts with a specific child. This uses reference +
Checks that a parent string or array starts with a specific child. This uses reference equality when the parent is an array. Returns the parent if the assertion passes.
Performs no type guarding.
import {assertWrap} from '@augment-vir/assert';
assertWrap.startsWith('ab', 'b'); // throws an error
assertWrap.startsWith('ab', 'a'); // returns `'ab'`
assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
@@ -171,7 +171,7 @@
assertWrap.startsWithout : the opposite assertion.
assertWrap.endsWith : assertion on the other end.
-Asserts that a parent string or array starts with a specific child. This uses reference +
Asserts that a parent string or array starts with a specific child. This uses reference equality when the parent is an array. Returns the parent if the assertion passes.
Performs no type guarding.
import {assertWrap} from '@augment-vir/assert';
assertWrap.startsWith('ab', 'b'); // returns `'ab'`
assertWrap.startsWith('ab', 'a'); // throws an error
assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
@@ -183,7 +183,7 @@
assertWrap.startsWithout : the opposite assertion.
assertWrap.endsWith : assertion on the other end.
-If a function input is provided:
+If a function input is provided:
Calls that function and asserts that the function throw an error, comparing the error with the given ErrorMatchOptions, if provided. Returns the Error if the assertion passes.
@@ -199,7 +199,7 @@AssertionError If the assertion fails.
-Asserts that two values are deeply equal using the deep-eql package. Returns the first value if the assertion passes.
Note that this check may be expensive, depending on what values it is passed. Whenever @@ -214,7 +214,7 @@
Asserts that two objects are deeply equal by checking only their top-level values for
strict (non-deep, reference, using
===)
equality and, if so, returns the first object.
Asserts that a parent value has the key. Returns the parent if the assertion passes.
Type guards the parent value.
The parent if it has the key.
import {assertWrap} from '@augment-vir/assert';
assertWrap.hasKey({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
assertWrap.hasKey({a: 0, b: 1}, 'c'); // throws an error
@@ -240,7 +240,7 @@
- assertWrap.lacksKey : the opposite assertion.
- assertWrap.hasKeys : the multi-key assertion.
-Asserts that a parent value has all the keys. Returns the parent if the assertion passes.
Type guards the parent value.
The parent if it has all the keys.
import {assertWrap} from '@augment-vir/assert';
assertWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
assertWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
@@ -251,7 +251,7 @@
- assertWrap.lacksKeys : the opposite assertion.
- assertWrap.hasKey : the single-key assertion.
-Asserts that an object/array parent includes a child value through reference equality. Returns the parent value if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -263,7 +263,7 @@Asserts that an object/array parent includes all child values through reference equality. Returns the parent value if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -275,7 +275,7 @@Asserts that a value is an instance of the given class constructor. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringimport {assertWrap} from '@augment-vir/assert';
assertWrap.instanceOf(/abc/, RegExp); // returns `/abc/`
assertWrap.instanceOf('abc', RegExp); // throws an error
@@ -286,7 +286,7 @@
Asserts that a number is above the expectation (actual > expected). Returns the number
if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -298,7 +298,7 @@Asserts that a number is within ±delta of the expectation. Returns the number if the
assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -309,7 +309,7 @@Asserts that a value is an array. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isArray([]); // returns `[]`
assertWrap.isArray({length: 4}); // throws an error
@@ -319,7 +319,7 @@
Asserts that a number is at least the expectation (actual >= expected). Returns the
number if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -331,7 +331,7 @@Asserts that a number is at most the expectation (actual <= expected). Returns the
number if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -343,7 +343,7 @@Asserts that a number is below the expectation (actual < expected). Returns the number
if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -355,7 +355,7 @@Asserts that a value is a BigInt. Returns the value if the assertion passes.
+Asserts that a value is a BigInt. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isBigInt(123n); // returns `123n`
assertWrap.isBigInt(123); // throws an error
@@ -365,7 +365,7 @@
Asserts that a value is a boolean. Returns the value if the assertion passes.
+Asserts that a value is a boolean. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isBoolean(true); // returns `true`
assertWrap.isBoolean('true'); // throws an error
@@ -375,7 +375,7 @@
Asserts that a value is defined (not null and not undefined). Returns the value if
the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -386,7 +386,7 @@Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays. Returns +
Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -397,7 +397,7 @@Asserts that a child value is an enum member. Returns the child value if the assertion +
Asserts that a child value is an enum member. Returns the child value if the assertion passes.
Type guards the child value.
The child value if it is an enum member.
@@ -408,7 +408,7 @@Asserts that a value is an instance of the built-in Error class and compares it to the
+
Asserts that a value is an instance of the built-in Error class and compares it to the
given ErrorMatchOptions, if provided.
Type guards the input.
OptionalmatchOptions: PartialWithNullable<OptionalfailureMessage: stringThe value if the assertion passes.
@@ -416,7 +416,7 @@AssertionError If the assertion fails.
-Asserts that a value is exactly false. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isFalse(true); // throws an error
assertWrap.isFalse(false); // returns `false`
assertWrap.isFalse(1); // throws an error
assertWrap.isFalse(0); // throws an error
@@ -427,7 +427,7 @@
- assertWrap.isTrue : the opposite assertion.
- assertWrap.isFalsy : a less exact assertion.
-Asserts that a value is falsy. Returns the value if the assertion passes.
+Asserts that a value is falsy. Returns the value if the assertion passes.
Type guards the value when possible.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isFalsy(true); // throws an error
assertWrap.isFalsy(false); // returns `false`
assertWrap.isFalsy(1); // throws an error
assertWrap.isFalsy(0); // returns `0`
@@ -438,7 +438,7 @@
- assertWrap.isTruthy : the opposite assertion.
- assertWrap.isFalse : a more exact assertion.
-Asserts that a number is finite: meaning, not NaN and not Infinity or -Infinity.
Returns the number if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -450,7 +450,7 @@Asserts that a value is a function. Returns the value if the assertion passes.
+Asserts that a value is a function. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isFunction(() => {}); // returns `() => {}`
assertWrap.isFunction({}); // throws an error
@@ -460,7 +460,7 @@
Asserts that a value is an HttpStatus. Returns the value if the assertion passes.
+Asserts that a value is an HttpStatus. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringimport {assertWrap} from '@augment-vir/assert';
assertWrap.isHttpStatus(400); // returns `400`
assertWrap.isHttpStatus(500); // returns `500`
assertWrap.isHttpStatus(99); // throws an error
Checks that a value is an HttpStatus within a specific HttpStatusCategory. +
Checks that a value is an HttpStatus within a specific HttpStatusCategory. Returns the value if the assertion passes.
Type guards the value.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // returns `400`
assertWrap.isHttpStatusCategory(500, HttpStatusCategory.Success); // throws an error
assertWrap.isHttpStatusCategory(99, HttpStatusCategory.Information); // throws an error
@@ -482,7 +482,7 @@
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
-Asserts that child value is contained within a parent object, array, or string through reference equality. Returns the child value if the assertion passes.
Type guards the child when possible.
The value if the assertion passes.
@@ -493,7 +493,7 @@Asserts that a number is inside the provided min and max bounds, inclusive. Returns the number if the assertion passes.
Performs no type guarding.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
assertWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
assertWrap.isInBounds(11, {min: 1, max: 10}); // fails
assertWrap.isInBounds(0, {min: 1, max: 10}); // fails
@@ -503,7 +503,7 @@
Asserts that a number is either Infinity or -Infinity. Returns the number if the
assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -515,7 +515,7 @@Asserts that a number is an integer. Returns the number if the assertion passes. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
@@ -526,7 +526,7 @@Asserts that a key is contained within a parent value. Returns the key if the assertion passes.
Type guards the key.
The key if it is in the parent.
@@ -537,7 +537,7 @@Asserts that a number is
NaN.
Returns the number if the assertion passes.
Performs no type guarding.
@@ -549,7 +549,7 @@Asserts that a number is outside ±delta of the expectation. Returns the number if the
assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -560,7 +560,7 @@Asserts that a value is not an array. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotArray([]); // throws an error
assertWrap.isNotArray({length: 4}); // returns `{length: 4}`
@@ -570,7 +570,7 @@
Asserts that a value is not a BigInt. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotBigInt(123n); // throws an error
assertWrap.isNotBigInt(123); // returns `123`
@@ -580,7 +580,7 @@
Asserts that a value is not a boolean. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotBoolean(true); // throws an error
assertWrap.isNotBoolean('true'); // returns `'true'`
@@ -590,7 +590,7 @@
Asserts that a value is not empty. Supports strings, Maps, Sets, objects, and arrays. +
Asserts that a value is not empty. Supports strings, Maps, Sets, objects, and arrays. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -601,7 +601,7 @@Asserts that a child value is not an enum member. Returns the child value if the assertion passes.
Type guards the child value.
The child value if it is not an enum member.
@@ -612,7 +612,7 @@Asserts that a value is not a function. Returns the value if the assertion passes.
+Asserts that a value is not a function. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotFunction(() => {}); // throws an error
assertWrap.isNotFunction({}); // returns `{}`
@@ -622,7 +622,7 @@
Asserts that child value is not contained within a parent object, array, or string through reference equality. Returns the child value if the assertion passes.
Type guards the child when possible.
The value if the assertion passes.
@@ -633,7 +633,7 @@Asserts that a number is not an integer. Returns the number if the assertion passes. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
@@ -644,7 +644,7 @@Asserts that a key is not contained within a parent value. Returns the key if the assertion passes.
Type guards the key.
The key if it is not in the parent.
@@ -655,7 +655,7 @@Asserts that a value is not exactly `null. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
Asserts that a value is not a number. This includes `NaN. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -681,7 +681,7 @@Asserts that a value is not an object. This includes arrays. Returns the value if the +
Asserts that a value is not an object. This includes arrays. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -692,7 +692,7 @@Asserts that a value is a valid PropertyKey. PropertyKey is a built-in TypeScript
type which refers to all possible key types for a JavaScript object. Returns the value if
the assertion passes.
Type guards the value.
@@ -704,7 +704,7 @@Asserts that a value is a not Promise instance. Returns the value if the assertion
passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -716,7 +716,7 @@Asserts that a value is not a PromiseLike. Returns the value if the assertion passes.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Asserts that a value is not a valid PropertyKey. PropertyKey is a built-in
TypeScript type which refers to all possible key types for a JavaScript object. Returns
the value if the assertion passes.
Type guards the value.
@@ -742,7 +742,7 @@Asserts that a value is not a string. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotString(''); // throws an error
assertWrap.isNotString(5); // returns `5`
@@ -752,7 +752,7 @@
Asserts that a value is not a symbol. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNotSymbol(Symbol('my-symbol')); // throws an error
assertWrap.isNotSymbol('my-symbol'); // returns `'my-symbol'`
@@ -762,7 +762,7 @@
Asserts that a value is not exactly `undefined. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -773,7 +773,7 @@Asserts that a value is not a valid UUID. The nil or max UUIDs are included as not valid. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringimport {assertWrap} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
assertWrap.isNotUuid(createUuidV4()); // throws an error
assertWrap.isNotUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // throws an error
assertWrap.isNotUuid('00000000-0000-0000-0000-000000000000'); // returns `'00000000-0000-0000-0000-000000000000'`
assertWrap.isNotUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // returns `'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'`
assertWrap.isNotUuid('not-a-uuid'); // returns `'not-a-uuid'`
@@ -783,7 +783,7 @@
Asserts that a value is exactly `null. Returns the value if the assertion passes.
+Asserts that a value is exactly `null. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isNull(null); // returns `null`
assertWrap.isNull(undefined); // throws an error
@@ -793,7 +793,7 @@
Asserts that a value is nullish (null or undefined). Returns the value if the
assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -804,7 +804,7 @@Asserts that a value is a number. This excludes `NaN. Returns the value if the assertion +
Asserts that a value is a number. This excludes `NaN. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -815,7 +815,7 @@Asserts that a value is an object. This excludes arrays. Returns the value if the +
Asserts that a value is an object. This excludes arrays. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -826,7 +826,7 @@Asserts that a number is outside the provided min and max bounds, exclusive. Returns the number if the assertion passes.
Performs no type guarding.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isOutBounds(5, {min: 1, max: 10}); // fails
assertWrap.isOutBounds(10, {min: 1, max: 10}); // fails
assertWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
assertWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
@@ -836,7 +836,7 @@
Asserts that a value is a JavaScript primitive. Returns the value if the assertion passes.
Type guards the value.
@@ -848,7 +848,7 @@Asserts that a value is a Promise instance. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(
onFulfilled ? onFulfilled(this.value) : this.value,
);
}
}
assertWrap.isPromise(Promise.resolve(5)); // returns the `Promise` instance
assertWrap.isPromise(new CustomThenable(5)); // throws an error
assertWrap.isPromise(5); // throws an error
@@ -859,7 +859,7 @@
- assertWrap.isNotPromise : the opposite assertion.
- assertWrap.isPromiseLike : the more lenient assertion.
-Asserts that a value is a PromiseLike. Returns the value if the assertion passes.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Asserts that a value is not a JavaScript primitive. Returns the value if the assertion passes.
Type guards the value.
@@ -885,7 +885,7 @@Asserts that a value is a string. Returns the value if the assertion passes.
+Asserts that a value is a string. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isString(''); // returns `''`
assertWrap.isString(5); // throws an error
@@ -895,7 +895,7 @@
Asserts that a value is a symbol. Returns the value if the assertion passes.
+Asserts that a value is a symbol. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isSymbol(Symbol('my-symbol')); // returns the created symbol
assertWrap.isSymbol('my-symbol'); // throws an error
@@ -905,7 +905,7 @@
Asserts that a value is exactly true. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isTrue(true); // returns `true`
assertWrap.isTrue(false); // throws an error
assertWrap.isTrue(1); // throws an error
assertWrap.isTrue(0); // throws an error
@@ -916,7 +916,7 @@
- assertWrap.isFalse : the opposite assertion.
- assertWrap.isTruthy : a less exact assertion.
-Asserts that a value is truthy. Returns the value if the assertion passes.
+Asserts that a value is truthy. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isTruthy(true); // returns `true`
assertWrap.isTruthy(false); // throws an error
assertWrap.isTruthy(1); // returns `1`
assertWrap.isTruthy(0); // throws an error
@@ -927,7 +927,7 @@
- assertWrap.isFalsy : the opposite assertion.
- assertWrap.isTrue : a more exact assertion.
-Asserts that a value is exactly `undefined. Returns the value if the assertion passes.
+Asserts that a value is exactly `undefined. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringThe value if the assertion passes.
import {assertWrap} from '@augment-vir/assert';
assertWrap.isUndefined(undefined); // returns `undefined`
assertWrap.isUndefined(null); // throws an error
@@ -937,7 +937,7 @@
Asserts that a value is a valid UUID. Does not accept the nil or max UUIDs. Returns the +
Asserts that a value is a valid UUID. Does not accept the nil or max UUIDs. Returns the value if the assertion passes.
Type guards the value.
OptionalfailureMessage: stringimport {assertWrap} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
assertWrap.isUuid(createUuidV4()); // returns the generated UUID
assertWrap.isUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // returns `'29e0f18e-6115-4982-8342-0afcadf5d611'`
assertWrap.isUuid('00000000-0000-0000-0000-000000000000'); // throws an error
assertWrap.isUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // throws an error
assertWrap.isUuid('not-a-uuid'); // throws an error
@@ -947,7 +947,7 @@
Asserts that two values are deeply equal when stringified into JSON. This will fail or may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the assertion passes.
@@ -961,7 +961,7 @@Asserts that a parent value does not have the key. Returns the parent if the assertion passes.
Type guards the parent value.
The parent if it does not have the key.
@@ -973,7 +973,7 @@Asserts that a parent value none of the keys. Returns the parent if the assertion passes.
Type guards the parent value.
The parent if it does not have any of the keys.
import {assertWrap} from '@augment-vir/assert';
assertWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
assertWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
@@ -984,7 +984,7 @@
- assertWrap.hasKeys : the opposite assertion.
- assertWrap.lacksKey : the single-key assertion.
-Asserts that an object/array parent does not include a child value through reference equality. Returns the parent value if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -996,7 +996,7 @@Asserts that an object/array parent includes none of the provided child values through reference equality. Returns the parent value if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -1008,7 +1008,7 @@Asserts that two values are loosely equal (using
==).
Returns the first value if the assertion passes.
Type guards the first value.
@@ -1020,7 +1020,7 @@Asserts that a string (first input, actual) matches a RegExp (second input,
expected). Returns the string if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -1031,7 +1031,7 @@Asserts that a string (first input, actual) does not match a RegExp (second input,
expected). Returns the string if the assertion passes.
Performs no type guarding.
OptionalfailureMessage: stringThe value if the assertion passes.
@@ -1042,7 +1042,7 @@Asserts that two values are not deeply equal using the deep-eql package. Returns the first value if the assertion passes.
Note that this check may be expensive, depending on what values it is passed. Whenever @@ -1057,7 +1057,7 @@
Asserts that two objects are not deeply equal by checking only their top-level values
for strict (non-deep, reference, using
===)
equality and, if so, returns the first object.
Asserts that a value is not an instance of the given class constructor. Returns the value if the assertion passes.
Type guards the value.
import {assertWrap} from '@augment-vir/assert';
assertWrap.notInstanceOf(/abc/, RegExp); // throws an error
assertWrap.notInstanceOf('abc', RegExp); // returns `'abc'`
@@ -1083,7 +1083,7 @@
Asserts that two values are not deeply equal when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the assertion passes.
@@ -1097,7 +1097,7 @@Asserts that two values are not loosely equal (using
==).
Returns the first value if the assertion passes.
Performs no type guarding.
@@ -1109,7 +1109,7 @@Asserts that two values are not strictly equal (using
===).
Returns the first value if the assertion passes.
Performs no type guarding.
@@ -1121,7 +1121,7 @@Asserts that two values are strictly equal (using
===).
Returns the first value if the assertion passes.
Type guards the first value.
@@ -1133,4 +1133,4 @@Asserts that the given context is for the given env and returns that context.
-TypeError if the context does not match the env.
Asserts that the given context is for the given env and returns that context.
+Performs +
Performs
[].map()
on an array but supports an async callback. The async callback is blocking. Meaning,
awaitedForEach will wait for a callback on array element 1 to finish before moving on to array
@@ -9,4 +9,4 @@
Performs +
Performs
[].filter()
on an array but supports an async callback.
Optionaloptions: { blocking?: boolean }Optionalblocking?: booleanEach call to the filter callback is blocking, meaning the next one won't start until the @@ -8,4 +8,4 @@
Performs +
Performs
[].forEach()
on an array but supports an async callback. The async callback is blocking. Meaning,
awaitedForEach will wait for a callback on array element 1 to finish before moving on to array
@@ -7,4 +7,4 @@
Calculate the dimensions needed for an element's text. This is a relatively expensive operation, +
Calculate the dimensions needed for an element's text. This is a relatively expensive operation, so it should not be called excessively.
OptionalcustomOptions: PartialWithUndefined<Call a function asynchronously without interrupting current synchronous execution, even if the +
Call a function asynchronously without interrupting current synchronous execution, even if the function was originally synchronous.
Calls callback until it doesn't throw an error or throws an error when maxRetries is reached.
+
Calls callback until it doesn't throw an error or throws an error when maxRetries is reached.
Similar to the waitUntil guard from '@augment-vir/assert' but doesn't check the callback's
output.
Capitalize the first letter of the input.
+Capitalize the first letter of the input.
A group of guard methods that return a boolean type guard rather than an assertion type guard.
+A group of guard methods that return a boolean type guard rather than an assertion type guard.
This can also be called as a standalone check function which returns a boolean to indicate whether its input is truthy or not.
Checks that a parent string or array does not end with a specific child. This uses +
Checks that a parent string or array does not end with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.endsWithout('ab', 'b'); // returns `false`
check.endsWithout('ab', 'a'); // returns `true`
check.endsWithout(['a', 'b'], 'b'); // returns `false`
check.endsWithout(['a', 'b'], 'a'); // returns `true`
@@ -116,7 +116,7 @@
check.endsWith : the opposite check.
check.startsWithout : check on the other end.
-Checks that a parent value has the key.
+Checks that a parent value has the key.
Type guards the parent value.
import {check} from '@augment-vir/assert';
check.hasKey({a: 0, b: 1}, 'a'); // returns `true`
check.hasKey({a: 0, b: 1}, 'c'); // returns `false`
Checks that a child value is an enum member.
+Checks that a child value is an enum member.
Type guards the child value.
import {check} from '@augment-vir/assert';
enum MyEnum {
A = 'a',
B = 'b',
}
check.isEnumValue('a', MyEnum); // returns `true`
check.isEnumValue('A', MyEnum); // returns `false`
Checks that an array or string has at least the given length.
+Checks that an array or string has at least the given length.
Type guards an array into an AtLeastTuple. Performs no type guarding on a string.
import {check} from '@augment-vir/assert';
check.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `true`
check.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `true`
check.isLengthAtLeast(['a', 'b'], 3); // returns `false`
Checks that an array or string has exactly the given length.
+Checks that an array or string has exactly the given length.
Type guards an array into a Tuple. Performs no type guarding on a string.
import {check} from '@augment-vir/assert';
check.isLengthExactly(['a', 'b', 'c'], 2); // fails
check.isLengthExactly(['a', 'b', 'c'], 3); // passes
check.isLengthExactly(['a', 'b'], 3); // fails
Checks that the output of the given function deeply equals expectations. A custom +
Checks that the output of the given function deeply equals expectations. A custom asserter can optionally be provided as the first argument to change the expectation checking from the default "deeply equals" to whatever you want.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.output((input: number) => String(input), [5], '5'); // returns `true`
check.output((input: number) => String(input), [10], '5'); // returns `false`
check.output(assert.isLengthAtLeast, (input: number) => String(input), [5], 2); // returns `false`
check.output(assert.isLengthAtLeast, (input: number) => String(input), [10], 2); // returns `true`
Checks that a parent string or array starts with a specific child. This uses reference +
Checks that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.startsWith('ab', 'b'); // returns `false`
check.startsWith('ab', 'a'); // returns `true`
check.startsWith(['a', 'b'], 'b'); // returns `false`
check.startsWith(['a', 'b'], 'a'); // returns `true`
@@ -166,7 +166,7 @@
check.startsWithout : the opposite check.
check.endsWith : check on the other end.
-Checks that a parent string or array starts with a specific child. This uses reference +
Checks that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.startsWith('ab', 'b'); // returns `false`
check.startsWith('ab', 'a'); // returns `true`
check.startsWith(['a', 'b'], 'b'); // returns `false`
check.startsWith(['a', 'b'], 'a'); // returns `true`
@@ -176,7 +176,7 @@
check.startsWithout : the opposite check.
check.endsWith : check on the other end.
-If a function input is provided:
+If a function input is provided:
Calls that function and checks that the function throw an error, comparing the error with the given ErrorMatchOptions, if provided.
If a promise is provided:
@@ -188,7 +188,7 @@Checks that two values are deeply equal using the deep-eql package.
Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).
@@ -201,7 +201,7 @@Checks that two objects are deeply equal by checking only their top-level values for
strict (non-deep, reference, using
===)
equality.
Checks that a parent value has all the keys.
Type guards the parent value.
import {check} from '@augment-vir/assert';
check.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `true`
check.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
Checks that an object/array parent includes a child value through reference equality.
Performs no type guarding.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
check.hasValue({child}, child); // returns `true`
check.hasValue({child: {a: 'a'}}, child); // returns `false`
check.hasValue([child], child); // returns `true`
Checks that an object/array parent includes all child values through reference equality.
Performs no type guarding.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
check.hasValues({child, child2}, [child, child2]); // returns `true`
check.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
check.hasValues([child], [child, child2]); // returns `true`
Checks that a value is an instance of the given class constructor.
Type guards the value.
import {check} from '@augment-vir/assert';
check.instanceOf(/abc/, RegExp); // returns `true`
check.instanceOf('abc', RegExp); // returns `false`
Checks that a number is above the expectation (actual > expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isAbove(10, 5); // returns `true`
check.isAbove(5, 5); // returns `false`
check.isAbove(5, 10); // returns `false`
Checks that a number is within ±delta of the expectation.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isApproximately(10, 8, 4); // returns `true`
check.isApproximately(10, 12, 4); // returns `true`
check.isApproximately(10, 8, 1); // returns `false`
check.isApproximately(10, 12, 1); // returns `false`
Checks that a value is an array.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isArray([]); // returns `true`
check.isArray({length: 4}); // returns `false`
Checks that a number is at least the expectation (actual >= expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isAtLeast(10, 5); // returns `true`
check.isAtLeast(5, 5); // returns `true`
check.isAtLeast(5, 10); // returns `false`
Checks that a number is at most the expectation (actual <= expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isAtMost(10, 5); // returns `false`
check.isAtMost(5, 5); // returns `true`
check.isAtMost(5, 10); // returns `true`
Checks that a number is below the expectation (actual < expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isBelow(10, 5); // returns `false`
check.isBelow(5, 5); // returns `false`
check.isBelow(5, 10); // returns `true`
Checks that a value is a BigInt.
+Checks that a value is a BigInt.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isBigInt(123n); // returns `true`
check.isBigInt(123); // returns `false`
Checks that a value is a boolean.
+Checks that a value is a boolean.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isBoolean(true); // returns `true`
check.isBoolean('true'); // returns `false`
Checks that a value is defined (not null and not undefined).
Type guards the value.
import {check} from '@augment-vir/assert';
check.isDefined(0); // returns `true`
check.isDefined(''); // returns `true`
check.isDefined(null); // returns `false`
check.isDefined(undefined); // returns `false`
Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
+Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isEmpty({}); // returns `true`
check.isEmpty(''); // returns `true`
check.isEmpty([]); // returns `true`
check.isEmpty('a'); // returns `false`
check.isEmpty({a: 'a'}); // returns `false`
Checks that a value is an instance of the built-in Error class and compares it to the
+
Checks that a value is an instance of the built-in Error class and compares it to the
given ErrorMatchOptions, if provided.
Type guards the input.
OptionalmatchOptions: PartialWithNullable<Checks that a value is exactly false.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isFalse(true); // returns `false`
check.isFalse(false); // returns `true`
check.isFalse(1); // returns `false`
check.isFalse(0); // returns `false`
Checks that a value is falsy.
+Checks that a value is falsy.
Type guards the value when possible.
import {check} from '@augment-vir/assert';
check.isFalsy(true); // returns `false`
check.isFalsy(false); // returns `true`
check.isFalsy(1); // returns `false`
check.isFalsy(0); // returns `true`
Checks that a number is finite: meaning, not NaN and not Infinity or -Infinity.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isFinite(10); // returns `true`
check.isFinite(parseInt('invalid')); // returns `false`
check.isFinite(Infinity); // returns `false`
check.isFinite(-Infinity); // returns `false`
Checks that a value is a function.
+Checks that a value is a function.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isFunction(() => {}); // returns `true`
check.isFunction({}); // returns `false`
Checks that a value is an HttpStatus.
+Checks that a value is an HttpStatus.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isHttpStatus(400); // returns `true`
check.isHttpStatus(500); // returns `true`
check.isHttpStatus(99); // returns `false`
Checks that a value is an HttpStatus within a specific HttpStatusCategory.
+Checks that a value is an HttpStatus within a specific HttpStatusCategory.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // returns `true`
check.isHttpStatusCategory(500, HttpStatusCategory.Success); // returns `false`
check.isHttpStatusCategory(99, HttpStatusCategory.Information); // returns `false`
Checks that child value is contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
check.isIn(child, {child}); // returns `true`
check.isIn('a', 'ab'); // returns `true`
check.isIn(child, [child]); // returns `true`
check.isIn(child, {child: {a: 'a'}}); // returns `false`
check.isIn('a', 'bc'); // returns `false`
@@ -403,7 +403,7 @@
Checks that a number is inside the provided min and max bounds, inclusive.
+Checks that a number is inside the provided min and max bounds, inclusive.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isInBounds(5, {min: 1, max: 10}); // passes
check.isInBounds(10, {min: 1, max: 10}); // passes
check.isInBounds(11, {min: 1, max: 10}); // fails
check.isInBounds(0, {min: 1, max: 10}); // fails
Checks that a number is either Infinity or -Infinity.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isInfinite(10); // returns `false`
check.isInfinite(parseInt('invalid')); // returns `false`
check.isInfinite(Infinity); // returns `true`
check.isInfinite(-Infinity); // returns `true`
Checks that a number is an integer. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isInteger(5); // passes
check.isInteger(5.0000000000000001); // passes
check.isInteger(5.1); // fails
check.isInteger(NaN); // fails
@@ -429,7 +429,7 @@
Checks that a key is contained within a parent value.
Type guards the key.
import {check} from '@augment-vir/assert';
check.isKeyof('a', {a: 0, b: 1}); // returns `true`
check.isKeyof('c', {a: 0, b: 1}); // returns `false`
Checks that a number is
NaN.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isNaN(10); // returns `false`
check.isNaN(parseInt('invalid')); // returns `true`
check.isNaN(Infinity); // returns `false`
@@ -446,7 +446,7 @@
Checks that a number is outside ±delta of the expectation.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isNotApproximately(10, 8, 4); // returns `false`
check.isNotApproximately(10, 12, 4); // returns `false`
check.isNotApproximately(10, 8, 1); // returns `true`
check.isNotApproximately(10, 12, 1); // returns `true`
Checks that a value is not an array.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotArray([]); // returns `false`
check.isNotArray({length: 4}); // returns `true`
Checks that a value is not a BigInt.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotBigInt(123n); // returns `false`
check.isNotBigInt(123); // returns `true`
Checks that a value is not a boolean.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotBoolean(true); // returns `false`
check.isNotBoolean('true'); // returns `true`
Checks that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
+Checks that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotEmpty({}); // returns `false`
check.isNotEmpty(''); // returns `false`
check.isNotEmpty([]); // returns `false`
check.isNotEmpty('a'); // returns `true`
check.isNotEmpty({a: 'a'}); // returns `true`
Checks that a child value is not an enum member.
Type guards the child value.
import {check} from '@augment-vir/assert';
enum MyEnum {
A = 'a',
B = 'b',
}
check.isNotEnumValue('a', MyEnum); // returns `false`
check.isNotEnumValue('A', MyEnum); // returns `true`
Checks that a value is not a function.
+Checks that a value is not a function.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotFunction(() => {}); // returns `false`
check.isNotFunction({}); // returns `true`
Checks that child value is not contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
check.isNotIn(child, {child}); // returns `false`
check.isNotIn('a', 'ab'); // returns `false`
check.isNotIn(child, [child]); // returns `false`
check.isNotIn(child, {child: {a: 'a'}}); // returns `true`
check.isNotIn('a', 'bc'); // returns `true`
@@ -511,7 +511,7 @@
Checks that a number is not an integer. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isNotInteger(5); // fails
check.isNotInteger(5.0000000000000001); // fails
check.isNotInteger(5.1); // passes
check.isNotInteger(NaN); // passes
@@ -520,7 +520,7 @@
Checks that a key is not contained within a parent value.
Type guards the key.
import {check} from '@augment-vir/assert';
check.isNotKeyOf('a', {a: 0, b: 1}); // returns `false`
check.isNotKeyOf('c', {a: 0, b: 1}); // returns `true`
Checks that a value is not exactly null.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotNull(null); // returns `false`
check.isNotNull(undefined); // returns `true`
Checks that a value is not a number. This includes NaN.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotNumber(123); // returns `false`
check.isNotNumber(123n); // returns `true`
Checks that a value is not an object. This includes arrays.
+Checks that a value is not an object. This includes arrays.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotObject({}); // returns `false`
check.isNotObject([]); // returns `true`
Checks that a value is a valid PropertyKey. PropertyKey is a built-in TypeScript type
which refers to all possible key types for a JavaScript object.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotPrimitive('key'); // returns `false`
check.isNotPrimitive(true); // returns `false`
check.isNotPrimitive({}); // returns `true`
@@ -561,7 +561,7 @@
Checks that a value is a not Promise instance.
Type guards the value.
import {check} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(
onFulfilled ? onFulfilled(this.value) : this.value,
);
}
}
check.isNotPromise(Promise.resolve(5)); // returns `false`
check.isNotPromise(new CustomThenable(5)); // returns `true`
check.isNotPromise(5); // returns `true`
Checks that a value is not a PromiseLike.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Checks that a value is not a valid PropertyKey. PropertyKey is a built-in
TypeScript type which refers to all possible key types for a JavaScript object.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotPropertyKey('key'); // returns `false`
check.isNotPropertyKey(true); // returns `true`
check.isNotPropertyKey({}); // returns `true`
@@ -591,7 +591,7 @@
Checks that a value is not a string.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotString(''); // returns `false`
check.isNotString(5); // returns `true`
Checks that a value is not a symbol.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotSymbol(Symbol('my-symbol')); // returns `false`
check.isNotSymbol('my-symbol'); // returns `true`
Checks that a value is not exactly undefined.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNotUndefined(undefined); // returns `false`
check.isNotUndefined(null); // returns `true`
Checks that a value is not a valid UUID. The nil or max UUIDs are included as not valid.
Type guards the value.
import {check} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
check.isNotUuid(createUuidV4()); // returns `false`
check.isNotUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // returns `false`
check.isNotUuid('00000000-0000-0000-0000-000000000000'); // returns `true`
check.isNotUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // returns `true`
check.isNotUuid('not-a-uuid'); // returns `true`
@@ -624,7 +624,7 @@
Checks that a value is exactly null.
Checks that a value is exactly null.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNull(null); // returns `true`
check.isNull(undefined); // returns `false`
Checks that a value is nullish (null or undefined).
Type guards the value.
The value to check.
import {check} from '@augment-vir/assert';
check.isNullish(0); // returns `false`
check.isNullish(''); // returns `false`
check.isNullish(null); // returns `true`
check.isNullish(undefined); // returns `true`
@@ -641,7 +641,7 @@
Checks that a value is a number. This excludes NaN.
Checks that a value is a number. This excludes NaN.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isNumber(123); // returns `true`
check.isNumber(123n); // returns `false`
Checks that a value is an object. This excludes arrays.
+Checks that a value is an object. This excludes arrays.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isObject({}); // returns `true`
check.isObject([]); // returns `false`
Checks that a number is outside the provided min and max bounds, exclusive.
+Checks that a number is outside the provided min and max bounds, exclusive.
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.isOutBounds(5, {min: 1, max: 10}); // fails
check.isOutBounds(10, {min: 1, max: 10}); // fails
check.isOutBounds(11, {min: 1, max: 10}); // passes
check.isOutBounds(0, {min: 1, max: 10}); // passes
Checks that a value is a JavaScript primitive.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isPrimitive('key'); // returns `true`
check.isPrimitive(true); // returns `true`
check.isPrimitive({}); // returns `false`
@@ -674,7 +674,7 @@
Checks that a value is a Promise instance.
Type guards the value.
import {check} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(
onFulfilled ? onFulfilled(this.value) : this.value,
);
}
}
check.isPromise(Promise.resolve(5)); // returns `true`
check.isPromise(new CustomThenable(5)); // returns `false`
check.isPromise(5); // returns `false`
Checks that a value is a PromiseLike.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
promise implementations that aren't instances of the built-in Promise class.
Checks that a value is not a JavaScript primitive.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isPropertyKey('key'); // returns `true`
check.isPropertyKey(true); // returns `false`
check.isPropertyKey({}); // returns `false`
@@ -704,7 +704,7 @@
Checks that a value is a string.
+Checks that a value is a string.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isString(''); // returns `true`
check.isString(5); // returns `false`
Checks that a value is a symbol.
+Checks that a value is a symbol.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isSymbol(Symbol('my-symbol')); // returns `true`
check.isSymbol('my-symbol'); // returns `false`
Checks that a value is exactly true.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isTrue(true); // returns `true`
check.isTrue(false); // returns `false`
check.isTrue(1); // returns `false`
check.isTrue(0); // returns `false`
Checks that a value is truthy.
+Checks that a value is truthy.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isTruthy(true); // passes
check.isTruthy(false); // fails
check.isTruthy(1); // passes
check.isTruthy(0); // fails
Checks that a value is exactly undefined.
Checks that a value is exactly undefined.
Type guards the value.
import {check} from '@augment-vir/assert';
check.isUndefined(undefined); // returns `true`
check.isUndefined(null); // returns `false`
Checks that a value is a valid UUID. Does not accept the nil or max UUIDs.
Type guards the value.
import {check} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';
check.isUuid(createUuidV4()); // returns `true`
check.isUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // returns `true`
check.isUuid('00000000-0000-0000-0000-000000000000'); // returns `false`
check.isUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // returns `false`
check.isUuid('not-a-uuid'); // returns `false`
Checks that two values are deeply equal when stringified into JSON. This will fail or may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order.
Type guards the first value.
@@ -766,7 +766,7 @@Checks that a parent value does not have the key.
Type guards the parent value.
import {check} from '@augment-vir/assert';
check.lacksKey({a: 0, b: 1}, 'a'); // returns `false`
check.lacksKey({a: 0, b: 1}, 'c'); // returns `true`
Checks that a parent value none of the keys.
Type guards the parent value.
import {check} from '@augment-vir/assert';
check.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
check.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `true`
Checks that an object/array parent does not include a child value through reference equality.
Performs no type guarding.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
check.lacksValue({child}, child); // returns `false`
check.lacksValue({child: {a: 'a'}}, child); // returns `true`
check.lacksValue([child], child); // returns `false`
@@ -794,7 +794,7 @@
- check.hasValue : the opposite check.
- check.lacksValues : the multi-value check.
-Checks that an object/array parent includes none of the provided child values through reference equality.
Performs no type guarding.
import {check} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
check.lacksValues({}, [child, child2]); // returns `true`
check.lacksValues({child, child2}, [child, child2]); // returns `false`
check.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
@@ -804,7 +804,7 @@
- check.lacksValues : the opposite check.
- check.hasValue : the single-value check.
-Checks that two values are loosely equal (using
==).
Type guards the first value.
import {check} from '@augment-vir/assert';
check.looseEquals('a', 'a'); // true
check.looseEquals('1', 1); // true
check.looseEquals({a: 'a'}, {a: 'a'}); // false
const objectExample = {a: 'a'};
check.looseEquals(objectExample, objectExample); // true
@@ -814,7 +814,7 @@
- check.notLooseEquals : the opposite check.
- check.strictEquals : the strict equality check.
-Checks that a string (first input, actual) matches a RegExp (second input, expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.matches('hi', /^h/); // returns `true`
check.matches('hi', /^g/); // returns `false`
Checks that a string (first input, actual) does not match a RegExp (second input,
expected).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.mismatches('hi', /^h/); // returns `false`
check.mismatches('hi', /^g/); // returns `true`
@@ -831,7 +831,7 @@
Checks that two values are not deeply equal using the deep-eql package.
Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).
@@ -844,7 +844,7 @@Checks that two objects are not deeply equal by checking only their top-level values
for strict (non-deep, reference, using
===)
equality.
Checks that a value is not an instance of the given class constructor.
Type guards the value.
import {check} from '@augment-vir/assert';
check.notInstanceOf(/abc/, RegExp); // returns `false`
check.notInstanceOf('abc', RegExp); // returns `true`
Checks that two values are not deeply equal when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order.
Performs no type guarding.
@@ -877,7 +877,7 @@Checks that two values are not loosely equal (using
==).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.notLooseEquals('a', 'a'); // false
check.notLooseEquals('1', 1); // false
check.notLooseEquals({a: 'a'}, {a: 'a'}); // true
const objectExample = {a: 'a'};
check.notLooseEquals(objectExample, objectExample); // false
@@ -887,7 +887,7 @@
- check.looseEquals : the opposite check.
- check.strictEquals : the strict equality check.
-Checks that two values are not strictly equal (using
===).
Performs no type guarding.
import {check} from '@augment-vir/assert';
check.notStrictEquals('a', 'a'); // false
check.notStrictEquals('1', 1); // true
check.notStrictEquals({a: 'a'}, {a: 'a'}); // true
const objectExample = {a: 'a'};
check.notStrictEquals(objectExample, objectExample); // false
@@ -897,7 +897,7 @@
- check.strictEquals : the opposite check.
- check.notLooseEquals : the loose equality check.
-Checks that two values are strictly equal (using
===).
Type guards the first value.
import {check} from '@augment-vir/assert';
check.strictEquals('a', 'a'); // true
check.strictEquals('1', 1); // false
check.strictEquals({a: 'a'}, {a: 'a'}); // false
const objectExample = {a: 'a'};
check.strictEquals(objectExample, objectExample); // true
@@ -907,4 +907,4 @@
- check.notStrictEquals : the opposite check.
- check.looseEquals : the loose equality check.
-Deeply checks inputs for equality with a custom checker callback. All objects are recursed into +
Deeply checks inputs for equality with a custom checker callback. All objects are recursed into and the custom checker is only run on primitives. This function automatically handles async custom checkers and circular references.
Deeply checks inputs for equality with a custom checker callback. All objects are recursed into and the custom checker is only run on primitives. This function automatically handles async custom checkers and circular references.
-Deeply checks inputs for equality with a custom checker callback. All objects are recursed into +
Deeply checks inputs for equality with a custom checker callback. All objects are recursed into and the custom checker is only run on primitives. This function automatically handles async custom checkers and circular references.
-Deeply checks inputs for equality with a custom checker callback. All objects are recursed into +
Deeply checks inputs for equality with a custom checker callback. All objects are recursed into and the custom checker is only run on primitives. This function automatically handles async custom checkers and circular references.
-Check if the given element is visible in its scroll container to the degree of the given ratio.
+A group of guard methods that do the following:
+A group of guard methods that do the following:
undefined.Checks that a parent string or array does not end with a specific child. This uses +
Checks that a parent string or array does not end with a specific child. This uses
reference equality when the parent is an array. Returns the value if the check passes,
otherwise undefined.
Performs no type guarding.
@@ -124,7 +124,7 @@Checks that an array or string has at least the given length. Returns the value if the +
Checks that an array or string has at least the given length. Returns the value if the
check passes, otherwise undefined.
Type guards an array into an AtLeastTuple. Performs no type guarding on a string.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
checkWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
checkWrap.isLengthAtLeast(['a', 'b'], 3); // returns `undefined`
@@ -134,7 +134,7 @@
Checks that an array or string has exactly the given length. Returns the value if the +
Checks that an array or string has exactly the given length. Returns the value if the
check passes, otherwise undefined.
Type guards an array into a Tuple. Performs no type guarding on a string.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isLengthExactly(['a', 'b', 'c'], 2); // returns `undefined`
checkWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
checkWrap.isLengthExactly(['a', 'b'], 3); // returns `undefined`
@@ -144,7 +144,7 @@
Asserts that the output of the given function deeply equals expectations. A custom +
Asserts that the output of the given function deeply equals expectations. A custom
asserter can optionally be provided as the first argument to change the expectation
checking from the default "deeply equals" to whatever you want. Returns the output if the
check passes, otherwise undefined.
Checks that a parent string or array starts with a specific child. This uses reference +
Checks that a parent string or array starts with a specific child. This uses reference
equality when the parent is an array. Returns the value if the check passes, otherwise
undefined.
Performs no type guarding.
@@ -165,7 +165,7 @@Checks that a parent string or array starts with a specific child. This uses reference +
Checks that a parent string or array starts with a specific child. This uses reference
equality when the parent is an array. Returns the value if the check passes, otherwise
undefined.
Performs no type guarding.
@@ -177,7 +177,7 @@If a function input is provided:
+If a function input is provided:
Calls that function and checks that the function throw an error, comparing the error with
the given ErrorMatchOptions, if provided. Returns the error if the check passes,
otherwise undefined.
Checks that two values are deeply equal using the deep-eql package. Returns the first value if the check passes.
Note that this check may be expensive, depending on what values it is passed. Whenever @@ -207,7 +207,7 @@
Checks that two objects are deeply equal by checking only their top-level values for
strict (non-deep, reference, using
===)
equality. If the check passes the first object is returned. If not, undefined is
@@ -222,7 +222,7 @@
Checks that a parent value has the key. Returns the parent value if the check passes,
otherwise undefined.
Type guards the parent value.
The parent value if the check passes, otherwise undefined.
Checks that a parent value has all the keys. Returns the parent value if the check
passes, otherwise undefined.
Type guards the parent value.
The parent value if the check passes, otherwise undefined.
Checks that an object/array parent includes a child value through reference equality.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
checkWrap.hasValue({child}, child); // returns `{child}`
checkWrap.hasValue({child: {a: 'a'}}, child); // returns `undefined`
checkWrap.hasValue([child], child); // returns `[child]`
Checks that an object/array parent includes all child values through reference equality.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
checkWrap.hasValues([child], [child, child2]); // returns `[child]`
Checks that a value is an instance of the given class constructor. Returns the value if
the check passes, otherwise undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a number is above the expectation (actual > expected). Returns the number
if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a number is within ±delta of the expectation. Returns the number if the
check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a value is an array. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a number is at least the expectation (actual >= expected). Returns the
number if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a number is at most the expectation (actual <= expected). Returns the
number if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a number is below the expectation (actual < expected). Returns the number
if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a value is a BigInt. Returns the value if the check passes, otherwise +
Checks that a value is a BigInt. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is a boolean. Returns the value if the check passes, otherwise +
Checks that a value is a boolean. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
+Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isEmpty({}); // returns `{}`
checkWrap.isEmpty(''); // returns `''`
checkWrap.isEmpty([]); // returns `[]`
checkWrap.isEmpty('a'); // returns `undefined`
checkWrap.isEmpty({a: 'a'}); // returns `undefined`
Checks that a child value is an enum member. Returns the child value if the check passes, +
Checks that a child value is an enum member. Returns the child value if the check passes,
otherwise undefined.
Type guards the child value.
The child value if the check passes, otherwise undefined.
Checks that a value is an instance of the built-in Error class and compares it to the
+
Checks that a value is an instance of the built-in Error class and compares it to the
given ErrorMatchOptions, if provided. Returns the error if the check passes,
otherwise undefined.
Type guards the input.
@@ -382,7 +382,7 @@Checks that a value is exactly false. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a value is falsy. Returns the value if the check passes, otherwise +
Checks that a value is falsy. Returns the value if the check passes, otherwise
undefined.
Type guards the value when possible.
The value if the check passes, otherwise undefined.
Checks that a number is finite: meaning, not NaN and not Infinity or -Infinity.
Returns the number if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a value is a function. Returns the value if the check passes, otherwise +
Checks that a value is a function. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is an HttpStatus. Returns the value if the check passes, +
Checks that a value is an HttpStatus. Returns the value if the check passes,
otherwise undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a value is an HttpStatus within a specific HttpStatusCategory. +
Checks that a value is an HttpStatus within a specific HttpStatusCategory.
Returns the value if the check passes, otherwise undefined.
Type guards the value.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // returns `400`
checkWrap.isHttpStatusCategory(500, HttpStatusCategory.Success); // returns `undefined`
checkWrap.isHttpStatusCategory(99, HttpStatusCategory.Information); // returns `undefined`
@@ -448,7 +448,7 @@
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
-Checks that child value is contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
checkWrap.isIn(child, {child}); // returns `child`
checkWrap.isIn('a', 'ab'); // returns `'a'`
checkWrap.isIn(child, [child]); // returns `child`
checkWrap.isIn(child, {child: {a: 'a'}}); // returns `undefined`
checkWrap.isIn('a', 'bc'); // returns `undefined`
@@ -457,7 +457,7 @@
Checks that a number is inside the provided min and max bounds, inclusive. Returns the
number if the check passes, otherwise undefined.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
checkWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
checkWrap.isInBounds(11, {min: 1, max: 10}); // returns `undefined`
checkWrap.isInBounds(0, {min: 1, max: 10}); // returns `undefined`
@@ -466,7 +466,7 @@
Checks that a number is either Infinity or -Infinity. Returns the number if the check
passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a number is an integer. Returns the number if the check passes, otherwise
undefined. This has the same limitations as
https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
@@ -487,7 +487,7 @@Checks that a key is contained within a parent value. Returns the key if the check
passes, otherwise undefined.
Type guards the key.
The key if the check passes, otherwise undefined.
Checks that a number is
NaN.
Returns the number if the check passes, otherwise undefined.
Performs no type guarding.
@@ -508,7 +508,7 @@Checks that a number is outside ±delta of the expectation. Returns the number if the
check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a value is not an array. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is not a BigInt. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is not a boolean. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
+Checks that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.
Type guards the value.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isNotEmpty({}); // returns `undefined`
checkWrap.isNotEmpty(''); // returns `undefined`
checkWrap.isNotEmpty([]); // returns `undefined`
checkWrap.isNotEmpty('a'); // returns `'a'`
checkWrap.isNotEmpty({a: 'a'}); // returns `{a: 'a'}`
Checks that a child value is not an enum member. Returns the child value if the check
passes, otherwise undefined.
Type guards the child value.
The child value if the check passes, otherwise undefined.
Checks that a value is not a function. Returns the value if the check passes, otherwise +
Checks that a value is not a function. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that child value is not contained within a parent object, array, or string through reference equality.
Type guards the child when possible.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
checkWrap.isNotIn(child, {child}); // returns `undefined`
checkWrap.isNotIn('a', 'ab'); // returns `undefined`
checkWrap.isNotIn(child, [child]); // returns `undefined`
checkWrap.isNotIn(child, {child: {a: 'a'}}); // returns `child`
checkWrap.isNotIn('a', 'bc'); // returns `'a'`
@@ -585,7 +585,7 @@
Checks that a number is not an integer. Returns the number if the check passes, otherwise
undefined. This has the same limitations, as
https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.
Performs no type guarding.
@@ -595,7 +595,7 @@Checks that a key is not contained within a parent value. Returns the key if the check
passes, otherwise undefined.
Type guards the key.
The key if the check passes, otherwise undefined.
Checks that a value is not exactly null. Returns the value if the check passes, otherwise undefined`.
Type guards the value.
The value if the check passes. Otherwise, undefined.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isNotNull(null); // returns `undefined`
checkWrap.isNotNull(undefined); // returns `undefined`
@@ -614,7 +614,7 @@
Checks that a value is not a number. This includes NaN. Returns the value if the check passes, otherwise undefined`.
Type guards the value.
The value if the check passes. Otherwise, undefined.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isNotNumber(123); // returns `undefined`
checkWrap.isNotNumber(123n); // returns `123n`
@@ -623,7 +623,7 @@
Checks that a value is not an object. This includes arrays. Returns the value if the +
Checks that a value is not an object. This includes arrays. Returns the value if the
check passes, otherwise undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is a valid PropertyKey. PropertyKey is a built-in TypeScript type
which refers to all possible key types for a JavaScript object. Returns the value if the
check passes, otherwise undefined.
Type guards the value.
@@ -644,7 +644,7 @@Checks that a value is a not Promise instance. Returns the value if the check passes,
otherwise undefined.
Type guards the value.
import {checkWrap} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(
onFulfilled ? onFulfilled(this.value) : this.value,
);
}
}
checkWrap.isNotPromise(Promise.resolve(5)); // returns `false`
checkWrap.isNotPromise(new CustomThenable(5)); // returns `true`
checkWrap.isNotPromise(5); // returns `true`
@@ -654,7 +654,7 @@
- checkWrap.isPromise : the opposite check.
- checkWrap.isNotPromiseLike : the more lenient check.
-Checks that a value is not a PromiseLike. Returns the value if the check passes,
otherwise undefined.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
@@ -667,7 +667,7 @@
Checks that a value is not a valid PropertyKey. PropertyKey is a built-in
TypeScript type which refers to all possible key types for a JavaScript object. Returns
the value if the check passes, otherwise undefined.
Type guards the value.
@@ -678,7 +678,7 @@Checks that a value is not a string. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is not a symbol. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is not a valid UUID. The nil or max UUIDs are included as not
valid. Returns the value if the check passes, otherwise undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a value is exactly null. Returns the value if the check passes, otherwise undefined`.
Checks that a value is exactly null. Returns the value if the check passes, otherwise undefined`.
Type guards the value.
The value if the check passes. Otherwise, undefined.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isNull(null); // returns `null`
checkWrap.isNull(undefined); // returns `undefined`
@@ -717,7 +717,7 @@
Checks that a value is a number. This excludes NaN. Returns the value if the check passes, otherwise undefined`.
Checks that a value is a number. This excludes NaN. Returns the value if the check passes, otherwise undefined`.
Type guards the value.
The value if the check passes. Otherwise, undefined.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isNumber(123); // returns `123`
checkWrap.isNumber(123n); // returns `undefined`
@@ -726,7 +726,7 @@
Checks that a value is an object. This excludes arrays. Returns the value if the check +
Checks that a value is an object. This excludes arrays. Returns the value if the check
passes, otherwise undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a number is outside the provided min and max bounds, exclusive. Returns the
number if the check passes, otherwise undefined.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
checkWrap.isOutBounds(5, {min: 1, max: 10}); // returns `undefined`
checkWrap.isOutBounds(10, {min: 1, max: 10}); // returns `undefined`
checkWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
checkWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
@@ -745,7 +745,7 @@
Checks that a value is a JavaScript
primitive. Returns the value if
the check passes, otherwise undefined.
Type guards the value.
@@ -756,7 +756,7 @@Checks that a value is a Promise instance. Returns the value if the check passes,
otherwise undefined.
Type guards the value.
import {checkWrap} from '@augment-vir/assert';
class CustomThenable {
constructor(public value: any) {}
then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
return new CustomThenable(
onFulfilled ? onFulfilled(this.value) : this.value,
);
}
}
checkWrap.isPromise(Promise.resolve(5)); // returns `true`
checkWrap.isPromise(new CustomThenable(5)); // returns `false`
checkWrap.isPromise(5); // returns `false`
@@ -766,7 +766,7 @@
- checkWrap.isNotPromise : the opposite check.
- checkWrap.isPromiseLike : the more lenient check.
-Checks that a value is a PromiseLike. Returns the value if the check passes, otherwise
undefined.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
@@ -779,7 +779,7 @@
Checks that a value is not a JavaScript
primitive. Returns the value if
the check passes, otherwise undefined.
Type guards the value.
@@ -790,7 +790,7 @@Checks that a value is a string. Returns the value if the check passes, otherwise +
Checks that a value is a string. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is a symbol. Returns the value if the check passes, otherwise +
Checks that a value is a symbol. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes. Otherwise, undefined.
Checks that a value is exactly true. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a value is truthy. Returns the value if the check passes, otherwise +
Checks that a value is truthy. Returns the value if the check passes, otherwise
undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that a value is a valid UUID. Does not accept the nil or max UUIDs. Returns the +
Checks that a value is a valid UUID. Does not accept the nil or max UUIDs. Returns the
value if the check passes, otherwise undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that two values are deeply equal when stringified into JSON. This will fail or may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the check passes.
@@ -855,7 +855,7 @@Checks that a parent value does not have the key. Returns the parent value if the check
passes, otherwise undefined.
Type guards the parent value.
The parent value if the check passes, otherwise undefined.
Checks that a parent value none of the keys. Returns the parent value if the check
passes, otherwise undefined.
Type guards the parent value.
The parent value if the check passes, otherwise undefined.
Checks that an object/array parent does not include a child value through reference equality.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
checkWrap.lacksValue({child}, child); // returns `undefined`
checkWrap.lacksValue({child: {a: 'a'}}, child); // returns `{child: {a: 'a'}}`
checkWrap.lacksValue([child], child); // returns `undefined`
@@ -887,7 +887,7 @@
- checkWrap.hasValue : the opposite check.
- checkWrap.lacksValues : the multi-value check.
-Checks that an object/array parent includes none of the provided child values through reference equality.
Performs no type guarding.
import {checkWrap} from '@augment-vir/assert';
const child = {a: 'a'};
const child2 = {b: 'b'};
checkWrap.lacksValues({}, [child, child2]); // returns `{}`
checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
@@ -897,7 +897,7 @@
- checkWrap.lacksValues : the opposite check.
- checkWrap.hasValue : the single-value check.
-Checks that two values are loosely equal (using
==).
Returns the first value if the check passes, otherwise undefined.
Type guards the first value.
@@ -909,7 +909,7 @@Checks that a string (first input, actual) matches a RegExp (second input, expected).
Returns the string if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that a string (first input, actual) does not match a RegExp (second input,
expected). Returns the string if the check passes, otherwise undefined.
Performs no type guarding.
The value if the check passes, otherwise undefined.
Checks that two values are not deeply equal using the deep-eql package. Returns the first value if the check passes.
Note that this check may be expensive, depending on what values it is passed. Whenever @@ -944,7 +944,7 @@
Checks that two objects are not deeply equal by checking only their top-level values
for strict (non-deep, reference, using
===)
equality. If the check passes the first object is returned. If not, undefined is
@@ -959,7 +959,7 @@
Checks that a value is not an instance of the given class constructor. Returns the
value if the check passes, otherwise undefined.
Type guards the value.
The value if the check passes, otherwise undefined.
Checks that two values are not deeply equal when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the check passes.
@@ -982,7 +982,7 @@Checks that two values are not loosely equal (using
==).
Returns the first value if the check passes, otherwise undefined.
Performs no type guarding.
@@ -994,7 +994,7 @@Checks that two values are not strictly equal (using
===).
Returns the first value if the check passes, otherwise undefined.
Performs no type guarding.
@@ -1006,7 +1006,7 @@Checks that two values are strictly equal (using
===).
Returns the first value if the check passes, otherwise undefined.
Type guards the first value.
@@ -1018,4 +1018,4 @@Clamp's the given value to within the min and max bounds, inclusive.
+Collapse all consecutive white space into just one space and trim surrounding whitespace. +
Collapse all consecutive white space into just one space and trim surrounding whitespace. Optionally, collapsed newlines can be preserved.
Combines an array of errors into a single array.
+Deeply copy an object through JSON. This is the fastest deep copy, but the input must already be +
Creates an array of size size and calls the given callback for each entry in the array and
+
Creates an array of size size and calls the given callback for each entry in the array and
fills the array with the results. The returned array is typed to exactly fit the given size.
This function automatically awaits async callbacks.
A new array filled with the results of the given callback typed as a Tuple,
@@ -7,4 +7,4 @@
Creates a custom logger that doesn't actually log but stores the logs into a object for later +
Creates a custom logger that doesn't actually log but stores the logs into a object for later usage. This is particularly useful in tests.
Optionaloptions: PartialWithUndefined<LoggerOptions>Creates a custom Logger.
+Creates a custom Logger.
OptionaloptionsOverride: PartialWithUndefined<LoggerOptions>Creates a symlink.
+Creates a symlink.
Path that the symlink will link to. If relative, it will be linked relative to the symlink location.
The location and name the symlink file to be created.
Creates a cryptographically secure random v4 UUID using +
Creates a cryptographically secure random v4 UUID using
crypto.randomUUID.
A test suite declaration. This can be used in both web tests and node tests, so you only have +
A test suite declaration. This can be used in both web tests and node tests, so you only have import from a single place and learn a single interface.
This should be passed a noun (preferably a single word, when possible) of what is going to be
tested inside the test suite. Its callback should call it from this same package.
Determine the current RuntimeEnv value. Usually you shouldn't need to call this, you can +
Determine the current RuntimeEnv value. Usually you shouldn't need to call this, you can simply import currentRuntimeEnv directly.
Determine the env for the given test context.
-Determine the env for the given test context.
+Extract all entries in the given arrays that are not equal.
+Extract all entries in the given arrays that are not equal.
An empty tuple if the values are equal. Otherwise, the first tuple entry contains the changes in the first value, second entry contains the changes in the second value.
Simple diff check that is useful simply to return the same format as the other diff functions.
+Simple diff check that is useful simply to return the same format as the other diff functions.
A custom equality checker. Defaults to a strict equality check (===).
An empty tuple if the values are equal. Otherwise, the first tuple entry contains the changes in the first value, second entry contains the changes in the second value.
Extract all nested object keys and values that are different between the two given objects.
+Extract all nested object keys and values that are different between the two given objects.
An empty tuple if the values are equal. Otherwise, the first tuple entry contains the changes in the first value, second entry contains the changes in the second value.
Diff any values. For diffing objects, use diffObjects to get better types.
Diff any values. For diffing objects, use diffObjects to get better types.
An empty tuple if the values are equal. Otherwise, the first tuple entry contains the changes in the first value, second entry contains the changes in the second value.
Ensures that the given input is an error and prepends the given message to the ensured Error +
This is a type helper that ensures the given input matches the given generic type. The generic is +
This is a type helper that ensures the given input matches the given generic type. The generic is setup in such a way that if it is omitted (which is typically allowed in TypeScript, resulting in the generic being inferred from the inputs), there will actually be a type error. This forces each usage of this function to explicitly specify the generic, thus giving us type safety for the input.
Extract the event target element from an Event.
+Extract the event target element from an Event.
Trims arguments list to remove all arguments that take place before the script's file name or +
Trims arguments list to remove all arguments that take place before the script's file name or executable bin name.
extractRelevantArgs({
rawArgs: ['npx', 'ts-node', './my-script.ts', 'arg1', '--arg2'], // typically will be process.argv
binName: 'my-script', // should be your package.json "bin" property name, can be undefined
fileName: 'my-script.ts', // should be __filename from the script that will be executed
});
// will output ['arg1', '--arg2']
Performs +
Performs
[].map()
and
[].filter()
@@ -8,5 +8,5 @@
Performs filterMap with a type guard filter.
Performs a regular filterMap.
Performs a regular filterMap.
Filters an object. Like +
Filters an object. Like
[].filter
but for objects.
Removes all given indexes from the given array.
+Filters the input array to all valid values from the given enum.
+Filters the input array to all valid values from the given enum.
A new array (does not mutate).
Find an ancestor file path that matches the given callback. If no matches are found all the way
+
Find an ancestor file path that matches the given callback. If no matches are found all the way
up until the system root, this returns undefined.
undefined if no matches are found.
Find an ancestor file path that matches the given callback. If no matches are found all the way
+
Find an ancestor file path that matches the given callback. If no matches are found all the way
up until the system root, this returns undefined.
undefined if no matches are found.
Find an ancestor file path that matches the given callback. If no matches are found all the way
+
Find an ancestor file path that matches the given callback. If no matches are found all the way
up until the system root, this returns undefined.
undefined if no matches are found.
Recursively search for an ancestor of the starting element that passes the given callback.
+Finds the path to an npm package executable bin by searching in all ancestor node_modules/.bin
+
Finds the path to an npm package executable bin by searching in all ancestor node_modules/.bin
folders, starting at the given startPath.
Finds all indexes of a searchFor string or RegExp in searchIn. Ths is similar to
+
Finds all indexes of a searchFor string or RegExp in searchIn. Ths is similar to
''.indexOf
except that it finds all indexes of.
OptionalincludeLength?: IncludeLengthSet to true to get an array of objects with the found indexes and their lengths.
Get the center of the current element. This is a relatively expensive operation as it uses +
Get the center of the current element. This is a relatively expensive operation as it uses
.getBoundingClientRect()
so this should not be called excessively.
Gets an element's direct children. Includes slotted elements, direct <slot> children
+
Gets an element's direct children. Includes slotted elements, direct <slot> children
themselves, and all direct children of a shadow DOM. Default <slot> children are not included
(since they're not "direct" children as they are nested under <slot>).
Note that that slotted elements and light dom elements will always be shown above shadow dom elements. Besides that, the order of children is preserved.
Gets an object's entries and sorts them by their key values. This is the same as +
Gets an object's entries and sorts them by their key values. This is the same as
Object.entries
except that it has better TypeScript types and sorts the entries.
Gets all values within an enum as an array.
+Gets all values within an enum as an array.
Creates the equivalent of CJS's +
Creates the equivalent of CJS's
__dirname and
__filename for ESM modules.
This is the equivalent of @@ -9,4 +9,4 @@
Gets all deeply nested elements contained within the given element. Shadow DOMs are traversed.
+Gets all deeply nested elements contained within the given element. Shadow DOMs are traversed.
Note that <slot> elements are included, as well as their nested elements (even if a slot filler
is provided by the parent) and the slot filler itself (if provided).
Optionally define a second "depth" input to control how far nestings should be pursued. Leave depth out or set it to undefined or any value <= 0 to allow full depth search.
Optionaldepth: numberGets an object's entries. This is the same as +
Gets an object's entries. This is the same as
Object.entries
except that it has better TypeScript types.
Gets all keys of an object. This is similar to +
Gets all keys of an object. This is similar to
Object.keys
except that it also grabs symbol keys and has better TypeScript typing.
Gets an object's values. This is the same as +
Gets an object's values. This is the same as
Object.values
except that it has better TypeScript types.
Given an object, tries to get the given key in that object. If the key is not in that object, +
Given an object, tries to get the given key in that object. If the key is not in that object,
then the given createCallback is used to create a new value which is then stored in the given
object and returned. Automatically handles an async createCallback.
Given an map, tries to get the given key in that map. If the key is not in that map, then the +
Given an map, tries to get the given key in that map. If the key is not in that map, then the
given createCallback is used to create a new value which is then stored in the given map and
returned. Automatically handles an async createCallback.
Polyfill for Object.groupBy:
+
Polyfill for Object.groupBy:
https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
Checks an input for truthiness then calls the respective callback, returning the callback's +
Checks an input for truthiness then calls the respective callback, returning the callback's output.
The called callback's output.
Checks if the given string is exclusively of the specific case.
+Checks if the given string is exclusively of the specific case.
Note that some characters have no casing, such as punctuation (they have no difference between
upper and lower casings). By default, those letters always return true for this function,
regardless of which caseType is provided. To instead return false for any such characters,
pass in an options object and set rejectNoCaseCharacters to true.
Optionaloptions: PartialWithUndefined<IsCaseOptions>Checks if the current operating system is the requested one.
+Checks if the current operating system is the requested one.
Checks if the given RuntimeEnv value is the current RuntimeEnv value.
+Checks if the given RuntimeEnv value is the current RuntimeEnv value.
true if the given RuntimeEnv is the current RuntimeEnv.
Checks that the given context is for the given env.
-Checks that the given context is for the given env.
+A single test declaration. This can be used in both web tests and node tests, so you only have +
A single test declaration. This can be used in both web tests and node tests, so you only have import from a single place and learn a single interface.
This should be nested within a describe call. The it name should form a sentence fragment
that is attached to the parent describe's input. The sentence should ultimately read like this:
@@ -10,6 +10,6 @@
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
Compatible with both Node.js's test runner and
web-test-runner or other Mocha-style test
runners.
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
Compatible with both Node.js's test runner and
web-test-runner or other Mocha-style test
runners.
import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
+import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
Compatible with both Node.js's test runner and
web-test-runner or other Mocha-style test
runners.
import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
+import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+Compatible with both Node.js's test runner and
+web-test-runner or other Mocha-style test
+runners.
import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
+Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+Compatible with both Node.js's test runner and
+web-test-runner or other Mocha-style test
+runners.
import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
+Succinctly run many input / output tests for a pure function without repeating it boilerplate.
+Compatible with both Node.js's test runner and
+web-test-runner or other Mocha-style test
+runners.
import {itCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
itCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
expect: -3,
},
{
it: 'handles 0',
inputs: [0, 0],
expect: 0,
},
{
it: 'adds',
inputs: [3, 5],
expect: 8,
},
]);
});
+Join a list of paths to the given parentDirPath. This is particularly useful for getting full
+
Join a list of paths to the given parentDirPath. This is particularly useful for getting full
paths from the output of
readdir.
Join elements into a string with commas separating each value. Add a conjunction before the final +
Join elements into a string with commas separating each value. Add a conjunction before the final item in the list. If the array has a length < 2, the conjunction is not added. If the list is only of length 2, then no commas are added.
Array of items to be converted into strings. Works best if these are simply strings to begin @@ -8,4 +8,4 @@
Creates a JSON compatible version of the value given. Under the hood this is actually the same as +
Converts a kebab-case string to CamelCase.
+Converts a kebab-case string to CamelCase.
Log the output of running a shell command. This is useful for quick debugging of shell commands.
+Log the output of running a shell command. This is useful for quick debugging of shell commands.
Maps all values of an enum as keys in an object where each value is the callback's output for +
Maps all values of an enum as keys in an object where each value is the callback's output for that key.
Maps an object. The callback must return a key and value.
+Maps an object. The callback must return a key and value.
import {mapObject} from '@augment-vir/common';
mapObject({a: 1, b: 2}, (key, value) => {
return {
key: `key-${key}`,
value: `value-${value}`,
};
});
// output is `{'key-a': 'value-1', 'key-b': 'value-2'}`
Creates a new object with the same keys as the input object, but with values set to the result of +
Creates a new object with the same keys as the input object, but with values set to the result of
mapCallback for each property. Automatically handles an async mapCallback.
Creates a new object with the same keys as the input object, but with values set to the result of +
Creates a new object with the same keys as the input object, but with values set to the result of
mapCallback for each property. This is the same as mapObjectValues except that this
preserves Promise values: it doesn't wrap them all in a single promise.
Capitalize the first letter of the input only if the given options specifies doing so.
+Capitalize the first letter of the input only if the given options specifies doing so.
Measures how long (in milliseconds) the given callback takes to run to completion. By default +
Measures how long (in milliseconds) the given callback takes to run to completion. By default this is synchronous, but it will automatically switch to async and await the callback if it returns a promise.
Accepts multiple objects and merges their key-value pairs recursively. Any values set to +
Accepts multiple objects and merges their key-value pairs recursively. Any values set to undefined will be removed.
Note that order matters! Each input object will overwrite the properties of the previous objects.
Merge all objects together but ignore any override values that are undefined or null or
+
Merge all objects together but ignore any override values that are undefined or null or
missing. This only merges objects at the top level, it is not a deep merge.
Merges all arrays by their property in the given objects.
+Same as the TypeScript built-in type Omit except that it works on actual runtime values.
Same as the TypeScript built-in type Omit except that it works on actual runtime values.
Requires defining an object of functions for all possible RuntimeEnv values and then only +
Requires defining an object of functions for all possible RuntimeEnv values and then only calls the function for the current runtime.
Same as the TypeScript built-in type Pick except that it works on actual runtime values.
Same as the TypeScript built-in type Pick except that it works on actual runtime values.
Get a list of all NPM workspaces in the given mono-repo directory using npm's CLI.
+Get a list of all NPM workspaces in the given mono-repo directory using npm's CLI.
Perform .querySelector()
+
Perform .querySelector()
on the given element with support for elements that contain an open Shadow Root.
Optionaloptions: { all?: false }Optionaloptions: PartialWithUndefined<{ all: boolean }>Optionaloptions: { all?: false }Optionaloptions: PartialWithUndefined<{ all: boolean }>Returns true at rate of the percentLikelyToBeTrue input. Inputs should be whole numbers which +
Returns true at rate of the percentLikelyToBeTrue input. Inputs should be whole numbers which will be treated like percents. Anything outside of 0-100 inclusively will be clamped. An input 0 will always return true. An input of 100 will always return true. Decimals on the input will be chopped off, use whole numbers.
@@ -7,4 +7,4 @@Creates a random integer (no decimal points are included) between the given min and max values +
Creates a random integer (no decimal points are included) between the given min and max values (inclusive).
This function uses cryptographically secure randomness.
Read all contents within a directory and store them in an object. Optionally recursive.
+Read all contents within a directory and store them in an object. Optionally recursive.
Reads all files within a single directory and filters them by the given extension or extensions.
+Reads all files within a single directory and filters them by the given extension or extensions.
That filtered list of paths.
Read a file and also parse its contents as JSON.
+Read a file and also parse its contents as JSON.
Finds the closest tsconfig.json file and parses it.
Finds the closest tsconfig.json file and parses it.
undefined if no tsconfig was found or if a found tsconfig fails to parse.
Removes ansi escape codes (such as terminal colors) within the given string.
+Removes duplicate characters from any number of strings.
+Removes duplicates from an array. Optionally provide a callback for calculating a unique id for +
Removes duplicates from an array. Optionally provide a callback for calculating a unique id for entries.
A new array (does not mutate).
import {removeDuplicates} from '@augment-vir/common';
const result = removeDuplicates([1, 1, 1, 1, 1, 2, 4]);
// result is `[1, 2, 4]`
const exampleEntry = {id: 5};
const result2 = removeDuplicates([
{id: 1},
// this entry will not get filtered out because it's a new object reference
{id: 1},
exampleEntry,
// this `exampleEntry` will get filtered out because it's the same reference as the one above
exampleEntry,
{id: 4},
]);
// result2 is `[{id: 1}, {id: 1}, exampleEntry, {id: 4}]`
@@ -8,4 +8,4 @@
Repeats an array. Constructs a new array with the entries from the original repeated the given +
Replaces whatever substring is at the given index in the original string with the new string. +
Replaces whatever substring is at the given index in the original string with the new string. Optionally, provide a length of the substring to get replaced.
Determines if the given number is so large that it requires scientific notation (e) when
+
Deletes and entire directory and resets it to the given contents.
+Deletes and entire directory and resets it to the given contents.
Determines the path that will be imported into the given startingPoint from the given
+
Determines the path that will be imported into the given startingPoint from the given
importPath. Resolves symlinks, tries to map .js extensions to .ts extensions when needed,
and tries to find the best node_modules import for package imports.
undefined if no matches are found.
Round a value to the given number of decimal digits. If no decimal value is present, no rounding +
Runs a script path as if it had been run directly, as much as possible.
+Runs a script path as if it had been run directly, as much as possible.
This should just be __filename (for CJS) or import.meta.filename (for ESM).
This should be the bin name of the package that is calling this function. Set to undefined
if there isn't one.
Runs a shell command and returns its output.
+Runs a shell command and returns its output.
Performs +
Performs
''.match
but falls back to an empty array if no match was found.
Same as +
Same as
''.split
but typed better: it always returns an array with at least one string.
The same as selectFrom except that the final output is collapsed until the first nested +
The same as selectFrom except that the final output is collapsed until the first nested value that has more than 1 key or that is not an object.
import {selectCollapsedFrom} from '@augment-vir/common';
selectCollapsedFrom(
[
{
child: {
grandChild: 'hi',
grandChild2: 3,
grandChild3: /something/,
},
},
{
child: {
grandChild: 'hi',
grandChild2: 4,
grandChild3: /something/,
},
},
],
{
child: {
grandChild2: true,
},
},
);
// output is `[3, 4]`
Performs a SQL-like nested selection on an object, extracting the selected values.
+Performs a SQL-like nested selection on an object, extracting the selected values.
import {selectFrom} from '@augment-vir/common';
selectFrom(
[
{
child: {
grandChild: 'hi',
grandChild2: 3,
grandChild3: /something/,
},
},
{
child: {
grandChild: 'hi',
grandChild2: 4,
grandChild3: /something/,
},
},
],
{
child: {
grandChild2: true,
},
},
);
// output is `[{child: {grandChild2: 3}}, {child: {grandChild2: 4}}]`
Creates a new RegExp by adding or removing the case insensitivity flag 'i', based on the given
+
Creates a new RegExp by adding or removing the case insensitivity flag 'i', based on the given
caseSensitive input. The first input can also be a string and it will be converted into a
RegExp.
import {setRegExpCaseSensitivity} from '@augment-vir/common';
setRegExpCaseSensitivity(/abc/i, {caseSensitive: true}); // output is `/abc/`
setRegExpCaseSensitivity(/abc/, {caseSensitive: false}); // output is `/abc/i`
setRegExpCaseSensitivity('abc', {caseSensitive: true}); // output is `/abc/i`
Creates a new RegExp with the given flags.
Shuffles the positions of an array's entries (without mutating the array).
+Shuffles the positions of an array's entries (without mutating the array).
A new array (does not mutate).
Similar to itCases but instead of defining expectation in each test case, each test case is a
+
Similar to itCases but instead of defining expectation in each test case, each test case is a
snapshot test.
In order to generate or update the snapshot files, run tests in update mode.
-import {snapshotCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
snapshotCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
},
{
it: 'handles 0',
inputs: [0, 0],
},
{
it: 'adds',
inputs: [3, 5],
},
]);
});
+import {snapshotCases, describe} from '@augment-vir/test';
function myFunctionToTest(a: number, b: number) {
return a + b;
}
describe(myFunctionToTest.name, () => {
snapshotCases(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
},
{
it: 'handles 0',
inputs: [0, 0],
},
{
it: 'adds',
inputs: [3, 5],
},
]);
});
Same as snapshotCases but passes the test context as the first parameter to the function under
+test.
In order to generate or update the snapshot files, run tests in update mode.
+import {
snapshotCasesWithContext,
RuntimeEnv,
describe,
UniversalTestContext,
assertTestContext,
} from '@augment-vir/test';
function myFunctionToTest(testContext: UniversalTestContext, a: number, b: number) {
assertTestContext(testContext, RuntimeEnv.Node);
return testContext.name;
}
describe(myFunctionToTest.name, () => {
snapshotCasesWithContext(myFunctionToTest, [
{
it: 'handles negative numbers',
inputs: [-1, -2],
},
{
it: 'handles 0',
inputs: [0, 0],
},
{
it: 'adds',
inputs: [3, 5],
},
]);
});
+Same as * +
Same as *
''.split
but includes the split delimiter in the output array.
Runs a shell command and returns a ShellTarget instance for directly hooking into shell +
Runs a shell command and returns a ShellTarget instance for directly hooking into shell events. This allows instant reactions to shell events but in a less convenient API compared to runShellCommand.
Optionalcwd: stringConverts log arguments into a single LogWriterParams.
+Converts log arguments into a single LogWriterParams.
Reduce an element down to its tag name or its element definition if it's a custom element defined +
Reduce an element down to its tag name or its element definition if it's a custom element defined by element-vir. Note that the types for this won't work in your project if you use custom element tag names that aren't generated via element-vir.
Truncates a number such that is will at a max have 6 (customizable) characters including suffix, +
Truncates a number such that is will at a max have 6 (customizable) characters including suffix, decimal point, or comma.
Default suffixes are in defaultTruncationSuffixes:
'k', // thousand
@@ -14,4 +14,4 @@
Performs +
Performs
[].map()
on an array but transfers the input tuple's size to the output type.
A new array (does not mutate).
@@ -6,4 +6,4 @@Create an object from an array of entries. This is the same as +
Create an object from an array of entries. This is the same as
Object.fromEntries
except that it has better TypeScript types.
An async pause for the given duration.
+An async pause for the given duration.
A group of guard methods that run the given callback multiple times until its return value +
A group of guard methods that run the given callback multiple times until its return value matches expectations. Callback interval and timeout can be customized with WaitUntilOptions.
This can also be called as a standalone wait until function which waits until the callback's @@ -9,7 +9,7 @@
AssertionError When the assertion fails.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe successful callback return value.
-Repeatedly calls a callback until its output string or array ends with the first input +
Repeatedly calls a callback until its output string or array ends with the first input child value. This uses reference equality when the parent is an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -128,7 +128,7 @@Repeatedly calls a callback until its output string or array does not end with the first +
Repeatedly calls a callback until its output string or array does not end with the first input child value. This uses reference equality when the parent is an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -141,7 +141,7 @@Repeatedly calls a callback until its output is deeply equal to the first input by +
Repeatedly calls a callback until its output is deeply equal to the first input by
checking only their top-level values for strict (non-deep, reference, using
===)
equality. Once the callback output passes, it is returned. If the attempts time out, an
@@ -156,7 +156,7 @@
Repeatedly calls a callback until its output is a parent value that has the first, key +
Repeatedly calls a callback until its output is a parent value that has the first, key input. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the parent value.
@@ -169,7 +169,7 @@Repeatedly calls a callback until its output is a parent value that has all of the first, +
Repeatedly calls a callback until its output is a parent value that has all of the first, keys input. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the parent value.
@@ -182,7 +182,7 @@Repeatedly calls a callback until its output is an object/array parent includes a child +
Repeatedly calls a callback until its output is an object/array parent includes a child value through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -195,7 +195,7 @@Repeatedly calls a callback until its output is an object/array parent includes all child +
Repeatedly calls a callback until its output is an object/array parent includes all child values through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -208,7 +208,7 @@Repeatedly calls a callback until its output is an instance of the given class +
Repeatedly calls a callback until its output is an instance of the given class constructor. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -220,7 +220,7 @@Repeatedly calls a callback until its output is a number that is above the expectation +
Repeatedly calls a callback until its output is a number that is above the expectation
(actual > expected). Once the callback output passes, it is returned. If the attempts
time out, an error is thrown.
Performs no type guarding.
@@ -233,7 +233,7 @@Repeatedly calls a callback until its output is a number that is within ±delta of the
+
Repeatedly calls a callback until its output is a number that is within ±delta of the
expectation. Once the callback output passes, it is returned. If the attempts time out,
an error is thrown.
Performs no type guarding.
@@ -245,7 +245,7 @@Repeatedly calls a callback until its output is an array. Once the callback output +
Repeatedly calls a callback until its output is an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isArray(() => []); // passes
await waitUntil.isArray(() => {
return {length: 4};
}); // throws an error
@@ -255,7 +255,7 @@
Repeatedly calls a callback until its output is a number that is at least the expectation +
Repeatedly calls a callback until its output is a number that is at least the expectation
(actual >= expected). Once the callback output passes, it is returned. If the attempts
time out, an error is thrown.
Performs no type guarding.
@@ -268,7 +268,7 @@Repeatedly calls a callback until its output is a number that is at most the expectation +
Repeatedly calls a callback until its output is a number that is at most the expectation
(actual <= expected). Once the callback output passes, it is returned. If the attempts
time out, an error is thrown.
Performs no type guarding.
@@ -281,7 +281,7 @@Repeatedly calls a callback until its output is a number that is below the expectation +
Repeatedly calls a callback until its output is a number that is below the expectation
(actual < expected). Once the callback output passes, it is returned. If the attempts
time out, an error is thrown.
Performs no type guarding.
@@ -294,7 +294,7 @@Repeatedly calls a callback until its output is a BigInt. Once the callback output +
Repeatedly calls a callback until its output is a BigInt. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isBigInt(() => 123n); // returns `123n`
await waitUntil.isBigInt(() => 123); // throws an error
@@ -304,7 +304,7 @@
Repeatedly calls a callback until its output is a boolean. Once the callback output +
Repeatedly calls a callback until its output is a boolean. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isBoolean(() => true); // returns `true`
await waitUntil.isBoolean(() => 'true'); // throws an error
@@ -314,7 +314,7 @@
Repeatedly calls a callback until its output is a value that is defined (not null and
+
Repeatedly calls a callback until its output is a value that is defined (not null and
not undefined). Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Type guards the value.
@@ -326,7 +326,7 @@Repeatedly calls a callback until its output is a value is empty. Supports strings, Maps, +
Repeatedly calls a callback until its output is a value is empty. Supports strings, Maps, Sets, objects, and arrays. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -338,7 +338,7 @@Repeatedly calls a callback until its output is an enum member. Once the callback output +
Repeatedly calls a callback until its output is an enum member. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -349,7 +349,7 @@Repeatedly calls a callback until is output is an instance of the built-in Error class
+
Repeatedly calls a callback until is output is an instance of the built-in Error class
and compares it to the given ErrorMatchOptions, if provided. Once the callback
output passes, that Error is returned. If the attempts time out, an error is thrown.
Type guards the input.
@@ -358,7 +358,7 @@AssertionError On timeout.
-Repeatedly calls a callback until its output is exactly false. Once the callback output
+
Repeatedly calls a callback until its output is exactly false. Once the callback output
passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -370,7 +370,7 @@Repeatedly calls a callback until its output is falsy. Once the callback output passes, +
Repeatedly calls a callback until its output is falsy. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -382,7 +382,7 @@Repeatedly calls a callback until its output is a number that is finite: meaning, not +
Repeatedly calls a callback until its output is a number that is finite: meaning, not
NaN and not Infinity or -Infinity. Once the callback output passes, it is returned.
If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -395,7 +395,7 @@Repeatedly calls a callback until its output is a function. Once the callback output +
Repeatedly calls a callback until its output is a function. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isFunction(() => () => {
return {};
}); // returns `{}`
await waitUntil.isFunction(() => {
return {};
}); // throws an error
@@ -405,7 +405,7 @@
Repeatedly calls a callback until its output is an HttpStatus. Once the callback +
Repeatedly calls a callback until its output is an HttpStatus. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -418,7 +418,7 @@Repeatedly calls a callback until its output is an HttpStatus within a specific +
Repeatedly calls a callback until its output is an HttpStatus within a specific HttpStatusCategory. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -432,7 +432,7 @@Repeatedly calls a callback until its output is child value is contained within a parent +
Repeatedly calls a callback until its output is child value is contained within a parent object, array, or string through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the child when possible.
@@ -444,7 +444,7 @@Repeatedly calls a callback until its output is a number is inside the provided min and +
Repeatedly calls a callback until its output is a number is inside the provided min and max bounds, inclusive. If the attempts time out, an error is thrown.
Performs no type guarding.
import {waitUntil} from '@augment-vir/assert';
waitUntil.isInBounds(5, {min: 1, max: 10}); // passes
waitUntil.isInBounds(10, {min: 1, max: 10}); // passes
waitUntil.isInBounds(11, {min: 1, max: 10}); // fails
waitUntil.isInBounds(0, {min: 1, max: 10}); // fails
@@ -454,7 +454,7 @@
Repeatedly calls a callback until its output is a number that is either Infinity or
+
Repeatedly calls a callback until its output is a number that is either Infinity or
-Infinity. Once the callback output passes, it is returned. If the attempts time out,
an error is thrown.
Performs no type guarding.
@@ -467,7 +467,7 @@Repeatedly calls a callback until its output is an integer. This has the same limitations +
Repeatedly calls a callback until its output is an integer. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger. If the attempts time out, an error is thrown.
@@ -479,7 +479,7 @@Repeatedly calls a callback until its output is a key that is contained within the first, +
Repeatedly calls a callback until its output is a key that is contained within the first, parent value. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the key.
@@ -491,7 +491,7 @@Repeatedly calls a callback until its output is an array or string that has at least the +
Repeatedly calls a callback until its output is an array or string that has at least the given length. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards an array into an AtLeastTuple. Performs no type guarding on a string.
@@ -503,7 +503,7 @@Repeatedly calls a callback until its output is an array or string that has exactly the +
Repeatedly calls a callback until its output is an array or string that has exactly the given length. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards an array into a Tuple. Performs no type guarding on a string.
@@ -515,7 +515,7 @@Repeatedly calls a callback until its output is a number that is +
Repeatedly calls a callback until its output is a number that is
NaN.
Once the callback output passes, it is returned. If the attempts time out, an error is
thrown.
Repeatedly calls a callback until its output is a number that is outside ±delta of the
+
Repeatedly calls a callback until its output is a number that is outside ±delta of the
expectation. Once the callback output passes, it is returned. If the attempts time out,
an error is thrown.
Performs no type guarding.
@@ -540,7 +540,7 @@Repeatedly calls a callback until its output is not an array. Once the callback output +
Repeatedly calls a callback until its output is not an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotArray(() => []); // throws an error
await waitUntil.isNotArray(() => {
return {length: 4};
}); // returns `{length: 4}`
@@ -550,7 +550,7 @@
Repeatedly calls a callback until its output is not a BigInt. Once the callback output +
Repeatedly calls a callback until its output is not a BigInt. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotBigInt(() => 123n); // throws an error
await waitUntil.isNotBigInt(() => 123); // returns `123`
@@ -560,7 +560,7 @@
Repeatedly calls a callback until its output is not a boolean. Once the callback output +
Repeatedly calls a callback until its output is not a boolean. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotBoolean(() => true); // throws an error
await waitUntil.isNotBoolean(() => 'true'); // returns `'true'`
@@ -570,7 +570,7 @@
Repeatedly calls a callback until its output is a value is not empty. Supports strings, +
Repeatedly calls a callback until its output is a value is not empty. Supports strings, Maps, Sets, objects, and arrays. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -582,7 +582,7 @@Repeatedly calls a callback until its output is not an enum member. Once the callback +
Repeatedly calls a callback until its output is not an enum member. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -593,7 +593,7 @@Repeatedly calls a callback until its output is not a function. Once the callback +
Repeatedly calls a callback until its output is not a function. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotFunction(() => () => {
return {};
}); // throws an error
await waitUntil.isNotFunction(() => {
return {};
}); // returns `{}`
@@ -603,7 +603,7 @@
Repeatedly calls a callback until its output is child value is not contained within a +
Repeatedly calls a callback until its output is child value is not contained within a parent object, array, or string through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the child when possible.
@@ -615,7 +615,7 @@Repeatedly calls a callback until its output is not an integer. This has the same +
Repeatedly calls a callback until its output is not an integer. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger. If the attempts time out, an error is thrown.
@@ -627,7 +627,7 @@Repeatedly calls a callback until its output is a key that is not contained within the +
Repeatedly calls a callback until its output is a key that is not contained within the first, parent value. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the key.
@@ -639,7 +639,7 @@Repeatedly calls a callback until its output is not exactly null. Once the callback
+
Repeatedly calls a callback until its output is not exactly null. Once the callback
output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Repeatedly calls a callback until its output is not a number. This includes NaN. Once
+
Repeatedly calls a callback until its output is not a number. This includes NaN. Once
the callback output passes, it is returned. If the attempts time out, an error is
thrown.
Type guards the value.
@@ -665,7 +665,7 @@Repeatedly calls a callback until its output is not an object. This includes arrays. +
Repeatedly calls a callback until its output is not an object. This includes arrays. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -676,7 +676,7 @@Repeatedly calls a callback until its output is a valid PropertyKey. PropertyKey is a
+
Repeatedly calls a callback until its output is a valid PropertyKey. PropertyKey is a
built-in TypeScript type which refers to all possible key types for a JavaScript object.
Once the callback output passes, it is returned. If the attempts time out, an error is
thrown.
Repeatedly calls a callback until its output is a not Promise instance. Once the
+
Repeatedly calls a callback until its output is a not Promise instance. Once the
callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -701,7 +701,7 @@Repeatedly calls a callback until its output is not a PromiseLike. Once the callback
+
Repeatedly calls a callback until its output is not a PromiseLike. Once the callback
output passes, it is returned. If the attempts time out, an error is thrown.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
@@ -716,7 +716,7 @@
Repeatedly calls a callback until its output is not a valid PropertyKey.
+
Repeatedly calls a callback until its output is not a valid PropertyKey.
PropertyKey is a built-in TypeScript type which refers to all possible key types for a
JavaScript object. Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Repeatedly calls a callback until its output is not a string. Once the callback output +
Repeatedly calls a callback until its output is not a string. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotString(() => ''); // throws an error
await waitUntil.isNotString(() => 5); // returns `5`
@@ -739,7 +739,7 @@
Repeatedly calls a callback until its output is not a symbol. Once the callback output +
Repeatedly calls a callback until its output is not a symbol. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotSymbol(() => Symbol('my-symbol')); // throws an error
await waitUntil.isNotSymbol(() => 'my-symbol'); // returns `'my-symbol'`
@@ -749,7 +749,7 @@
Repeatedly calls a callback until its output is not exactly undefined. Once the
+
Repeatedly calls a callback until its output is not exactly undefined. Once the
callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNotUndefined(() => undefined); // throws an error
await waitUntil.isNotUndefined(() => null); // returns `null`
@@ -759,7 +759,7 @@
Repeatedly calls a callback until its output is not a valid UUID. The nil or max UUIDs +
Repeatedly calls a callback until its output is not a valid UUID. The nil or max UUIDs are included as not valid. Returns the value if the assertion passes. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -771,7 +771,7 @@Repeatedly calls a callback until its output is exactly null. Once the callback output
+
Repeatedly calls a callback until its output is exactly null. Once the callback output
passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNull(() => null); // returns `null`
await waitUntil.isNull(() => undefined); // throws an error
@@ -781,7 +781,7 @@
Repeatedly calls a callback until its output is a value that is nullish (null or
+
Repeatedly calls a callback until its output is a value that is nullish (null or
undefined). Once the callback output passes, it is returned. If the attempts time out,
an error is thrown.
Type guards the value.
@@ -793,7 +793,7 @@Repeatedly calls a callback until its output is a number. This excludes NaN. Once the
+
Repeatedly calls a callback until its output is a number. This excludes NaN. Once the
callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isNumber(() => 123); // returns `123`
await waitUntil.isNumber(() => 123n); // throws an error
@@ -803,7 +803,7 @@
Repeatedly calls a callback until its output is an object. This excludes arrays. Once the +
Repeatedly calls a callback until its output is an object. This excludes arrays. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isObject(() => {
return {};
}); // returns `{}`
await waitUntil.isObject(() => []); // throws an error
@@ -813,7 +813,7 @@
Repeatedly calls a callback until its output is outside the provided min and max bounds, +
Repeatedly calls a callback until its output is outside the provided min and max bounds, exclusive. If the attempts time out, an error is thrown.
Performs no type guarding.
import {waitUntil} from '@augment-vir/assert';
waitUntil.isOutBounds(5, {min: 1, max: 10}); // fails
waitUntil.isOutBounds(10, {min: 1, max: 10}); // fails
waitUntil.isOutBounds(11, {min: 1, max: 10}); // passes
waitUntil.isOutBounds(0, {min: 1, max: 10}); // passes
@@ -823,7 +823,7 @@
Repeatedly calls a callback until its output is a JavaScript +
Repeatedly calls a callback until its output is a JavaScript primitive. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -835,7 +835,7 @@Repeatedly calls a callback until its output is a Promise instance. Once the callback
+
Repeatedly calls a callback until its output is a Promise instance. Once the callback
output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -847,7 +847,7 @@Repeatedly calls a callback until its output is a PromiseLike. Once the callback output
+
Repeatedly calls a callback until its output is a PromiseLike. Once the callback output
passes, it is returned. If the attempts time out, an error is thrown.
PromiseLike is TypeScript built-in type that has a .then method and thus behaves like
a promise. This is also referred to as a "thenable". This enables the use of third-party
@@ -862,7 +862,7 @@
Repeatedly calls a callback until its output is not a JavaScript +
Repeatedly calls a callback until its output is not a JavaScript primitive. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -874,7 +874,7 @@Repeatedly calls a callback until its output is a string. Once the callback output +
Repeatedly calls a callback until its output is a string. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isString(() => ''); // returns `''`
await waitUntil.isString(() => 5); // throws an error
@@ -884,7 +884,7 @@
Repeatedly calls a callback until its output is a symbol. Once the callback output +
Repeatedly calls a callback until its output is a symbol. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isSymbol(() => Symbol('my-symbol')); // returns the created symbol
await waitUntil.isSymbol(() => 'my-symbol'); // throws an error
@@ -894,7 +894,7 @@
Repeatedly calls a callback until its output is exactly true. Once the callback output
+
Repeatedly calls a callback until its output is exactly true. Once the callback output
passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -906,7 +906,7 @@Repeatedly calls a callback until its output is truthy. Once the callback output passes, +
Repeatedly calls a callback until its output is truthy. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
Optionaloptions: PartialWithUndefined<OptionalfailureMessage: stringThe callback output once it passes.
@@ -918,7 +918,7 @@Repeatedly calls a callback until its output is exactly undefined. Once the callback
+
Repeatedly calls a callback until its output is exactly undefined. Once the callback
output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
import {waitUntil} from '@augment-vir/assert';
await waitUntil.isUndefined(() => undefined); // returns `undefined`
await waitUntil.isUndefined(() => null); // throws an error
@@ -928,7 +928,7 @@
Repeatedly calls a callback until its output is a valid UUID. Does not accept the nil or +
Repeatedly calls a callback until its output is a valid UUID. Does not accept the nil or max UUIDs. Returns the value if the assertion passes. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -940,7 +940,7 @@Repeatedly calls a callback until its output is deeply equal to the first input when +
Repeatedly calls a callback until its output is deeply equal to the first input when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -955,7 +955,7 @@Repeatedly calls a callback until its output is a parent value that does not have the +
Repeatedly calls a callback until its output is a parent value that does not have the first, key input. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the parent value.
@@ -968,7 +968,7 @@Repeatedly calls a callback until its output is a parent value that does not have any of +
Repeatedly calls a callback until its output is a parent value that does not have any of the first, keys input. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the parent value.
@@ -981,7 +981,7 @@Repeatedly calls a callback until its output is an object/array parent does not include +
Repeatedly calls a callback until its output is an object/array parent does not include a child value through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -994,7 +994,7 @@Repeatedly calls a callback until its output is an object/array parent includes none of +
Repeatedly calls a callback until its output is an object/array parent includes none of the provided child values through reference equality. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -1007,7 +1007,7 @@Repeatedly calls a callback until its output loosely equals (using +
Repeatedly calls a callback until its output loosely equals (using
==)
the first input. Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Repeatedly calls a callback until its output is a string that matches a RegExp (first +
Repeatedly calls a callback until its output is a string that matches a RegExp (first
input, expected). Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Performs no type guarding.
@@ -1033,7 +1033,7 @@Repeatedly calls a callback until its output is a string that does not match a RegExp +
Repeatedly calls a callback until its output is a string that does not match a RegExp
(first input, expected). Once the callback output passes, it is returned. If the
attempts time out, an error is thrown.
Performs no type guarding.
@@ -1045,7 +1045,7 @@Repeatedly calls a callback until its output does not deeply equal (using the +
Repeatedly calls a callback until its output does not deeply equal (using the deep-eql package) the first input. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Note that this check may be expensive, depending on what values it is passed. Whenever @@ -1061,7 +1061,7 @@
Repeatedly calls a callback until its output is not deeply equal to the first input by +
Repeatedly calls a callback until its output is not deeply equal to the first input by
checking only their top-level values for strict (non-deep, reference, using
===)
equality. Once the callback output passes, it is returned. If the attempts time out, an
@@ -1077,7 +1077,7 @@
Repeatedly calls a callback until its output is not an instance of the given class +
Repeatedly calls a callback until its output is not an instance of the given class constructor. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Type guards the value.
@@ -1089,7 +1089,7 @@Repeatedly calls a callback until its output is not deeply equal to the first input +
Repeatedly calls a callback until its output is not deeply equal to the first input when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Once the callback output passes, it is returned. If the attempts time out, an error is @@ -1105,7 +1105,7 @@
Repeatedly calls a callback until its output does not loosely equal (using +
Repeatedly calls a callback until its output does not loosely equal (using
==)
the first input. Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Repeatedly calls a callback until its output does not strictly equal (using +
Repeatedly calls a callback until its output does not strictly equal (using
===)
the first input. Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Repeatedly calls a callback until its output deeply equals expectations. A custom +
Repeatedly calls a callback until its output deeply equals expectations. A custom asserter can optionally be provided as the first argument to change the expectation checking from the default "deeply equals" to whatever you want.
Performs no type guarding.
@@ -1141,7 +1141,7 @@AssertionError If the assertion fails.
-Repeatedly calls a callback until its output string or array starts with the first input +
Repeatedly calls a callback until its output string or array starts with the first input child value. This uses reference equality when the parent is an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
Performs no type guarding.
@@ -1154,7 +1154,7 @@Repeatedly calls a callback until its output string or array does not start with the +
Repeatedly calls a callback until its output string or array does not start with the first input child value. This uses reference equality when the parent is an array. Once the callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1168,7 +1168,7 @@Repeatedly calls a callback until its output strictly equals (using +
Repeatedly calls a callback until its output strictly equals (using
===)
the first input. Once the callback output passes, it is returned. If the attempts time
out, an error is thrown.
Repeatedly calls a callback until it throws an error, comparing the error with the given +
Repeatedly calls a callback until it throws an error, comparing the error with the given ErrorMatchOptions, if provided (as the first input). Once the callback throws an Error, that Error is returned. If the attempts time out, an error is thrown.
This assertion will automatically type itself as async vs async based on the input. (A @@ -1195,4 +1195,4 @@
AssertionError On timeout.
-An async pause for the given duration that then returns the given value.
An async pause for the given duration that then returns the given value.
Calls the callback and returns its output. If the callback throws an error, it is handled in the +
Calls the callback and returns its output. If the callback throws an error, it is handled in the following ways:
handleError function is provided in options, it is passed the thrown error. The output
@@ -10,4 +10,4 @@
Optionaloptions: { fallbackValue?: undefined; handleError?: undefined }Optionaloptions: { fallbackValue?: undefined; handleError?: undefined }Optionaloptions: PartialWithUndefined<Optionaloptions: PartialWithUndefined<Optionaloptions: { fallbackValue?: undefined; handleError?: undefined }Optionaloptions: { fallbackValue?: undefined; handleError?: undefined }Optionaloptions: PartialWithUndefined<Optionaloptions: PartialWithUndefined<If the given value is outside the given min/max bounds, instead of clamping the number (as the +
If the given value is outside the given min/max bounds, instead of clamping the number (as the
clamp function does), this function wraps the value around to the next bound (inclusive).
Wraps an already-created Promise in a timeout, causing a rejection if the original Promise isn't +
Wraps an already-created Promise in a timeout, causing a rejection if the original Promise isn't resolved by then.
OptionalfailureMessage: stringWraps a string in another string.
+Write DirContents to a directory.
+Write DirContents to a directory.
Writes to the given file path and always ensures that the path's parent directories are all +
Write to a file and stringify data as JSON before doing so.
Write to a file and stringify data as JSON before doing so.
Documentation and code for all the latest @augment-vir packages.
Documentation and code for all the latest @augment-vir packages.
@augment-vir/assert: A collection of assertions for test and production code alike. These main exports are the following:
Options for askQuestion.
+Options for askQuestion.
Base function under test type for all test cases that pass in the test context.
+Base Prisma client type that all PrismaClient instances should be able to match, with enough
+
Base Prisma client type that all PrismaClient instances should be able to match, with enough
data that it'll omit random accidental objects.
A base type for Prisma model payloads because Prisma doesn't give us one. This currently only +
A base type for Prisma model payloads because Prisma doesn't give us one. This currently only includes the properties that are used within this package.
Note: this omits the composites property because I don't have any examples of what those
actually are.
Base test case for itCases.
+Base test case for itCases.
All types that can be checked for emptiness. The empty variants of these types are represented in +
All types that can be checked for emptiness. The empty variants of these types are represented in Empty.
Requires every part of an object, even the indexed keys. This is needed because +
Requires every part of an object, even the indexed keys. This is needed because
Required<Partial<T>> doesn't fully remove | undefined from indexed keys when the
noUncheckedIndexedAccess TSConfig compiler option is enabled.
Test context by runtime env when Node.js's test runner is +
Test context by runtime env when Node.js's test runner is used for Node tests and web-test-runner is used for web tests.
Parameters for docker.container.copyTo.
A custom asserter for .output guards (assert.output, check.output, etc.). This is typically
+
A custom asserter for .output guards (assert.output, check.output, etc.). This is typically
not necessary, as the .output guards already perform deep equality checks by default.
The function type that your custom asserter will be run on.
OptionalfailureMessage: stringimport {assert, AssertionError, CustomOutputAsserter} from '@augment-vir/assert';
function myFunctionToTest(name: string) {
return `Hello there ${name}`;
}
const myCustomAsserter: CustomOutputAsserter<typeof myFunctionToTest> = (
actual,
expected,
failureMessage,
) => {
// Write your assertion in an `if`.
if (!actual.startsWith('hello there') || actual.endsWith(expected)) {
// Throw an `AssertionError` if the `if` fails.
throw new AssertionError('', failureMessage);
}
};
// Use your custom asserter as the first input to any `.output` guard.
assert.output(myCustomAsserter, myFunctionToTest, ['John'], 'John', 'Name insertion failed');
Properties on the output from docker.container.getInfo(). Not all these properties are filled
+
Properties on the output from docker.container.getInfo(). Not all these properties are filled
in all the way, particularly most of properties with nested objects.
Properties on DockerContainerInfo.State, retrieved from docker.container.getInfo().
Properties on DockerContainerInfo.State, retrieved from docker.container.getInfo().
A set of environment mappings for a docker container.
+A set of environment mappings for a docker container.
value property can be either the value that the env var should be set to or an existing
@@ -10,4 +10,4 @@
A mapping of a single docker volume for mounting host files to a container.
+A mapping of a single docker volume for mounting host files to a container.
Optionaltype?: DockerVolumeMappingTypeEmpty versions of CanBeEmpty. Note that there is no way to distinguish an empty Set or
+
Empty versions of CanBeEmpty. Note that there is no way to distinguish an empty Set or
Map from their non-empty counterparts in TypeScript (so you will get no emptiness type safety
for them.)
Creates an object that maps all values of an enum to the provided Values type.
Creates an object that maps all values of an enum to the provided Values type.
A type that represents possible error matching patterns. This is used by the .throws and
+
A type that represents possible error matching patterns. This is used by the .throws and
isError, guards in @augment-vir/assert as well as itCases in @augment-vir/test. Each
property is optional, and whichever properties are provided will be checked.
import {assert, type ErrorMatchOptions} from '@augment-vir/assert';
// define the options
const matchOptions: ErrorMatchOptions = {
matchConstructor: Error,
matchMessage: 'some error',
};
assert.throws(
() => {
throw new Error('some error');
},
// use the options
matchOptions,
); // this assertion will pass
Performs keyof on all keys within the OriginalObject that have values not matching the
+
Performs keyof on all keys within the OriginalObject that have values not matching the
given Matcher.
Expand a payload that might be inside of an array, keeping it inside of an array if it is.
+Expand a payload that might be inside of an array, keeping it inside of an array if it is.
Expand a Prisma payload into its scalars and recursive relations.
+Expand a Prisma payload into its scalars and recursive relations.
Performs keyof on all keys within the OriginalObject that have values matching the given
+
Performs keyof on all keys within the OriginalObject that have values matching the given
Matcher.
Narrows the given type parameter T to all its falsy sub-types.
All falsy values in JavaScript. This does not include NaN because there is no dedicated type
+
A function test case used for itCases.
+A function test case used for itCases.
Input for a function test that has multiple inputs.
+Input for a function test that has multiple inputs.
Input for a function test that only has a single input.
+Input for a function test that only has a single input.
A function test case used for itCasesWithContext.
+Input for a function test that has multiple inputs.
+Input for a test function with context that only has a single input.
+A generic selection set without specific keys. Useful for type parameter baselines.
+All possible HTTP status codes for the given HttpStatusCategory.
+All possible HTTP status codes for the given HttpStatusCategory.
A helper type that resolves to the given Yes type parameter if Actual === Expected.
+
A helper type that resolves to the given Yes type parameter if Actual extends Expected.
+
An object that only contains JSON compatible values.
+An object that only contains JSON compatible values.
All primitives that are allowed in JSON.
+Options for logShellOutput.
+Options for logShellOutput.
The final step in writing a log. This will actually perform the logging of text to the console. +
The final step in writing a log. This will actually perform the logging of text to the console. CSS will be applied if this is called within a browser.
Type for the log export.
Type for the log export.
Only logs if the given condition is true.
Options for a custom Logger.
+Options for a custom Logger.
Either an array of T or just T itself.
Either an array of T or just T itself.
Either a readonly array of T or just T itself.
Either a readonly array of T or just T itself.
Any Mocha context node inside MochaTestContext.
+The root context inside MochaTestContext.
+The root context inside MochaTestContext.
An individual test suite inside MochaTestContext.
+An individual test suite inside MochaTestContext.
An individual test context inside MochaTestContext.
+An individual test context inside MochaTestContext.
The current test callback.
Optionalroot?: undefinedThe current test name.
The test context for web-test-runner or +
The test context for web-test-runner or other Mocha-style test runners.
OptionalsnapshotCount?: { [TestName in string]: number }Added for use by assertSnapshot.
Narrows the given Expected type to the given Actual type as much as possible, or falls back
+
Narrows the given Expected type to the given Actual type as much as possible, or falls back
to just Expected itself.
Narrows the given Actual type to the given Expected type as much as possible, or falls back
+
Narrows the given Actual type to the given Expected type as much as possible, or falls back
to just Expected itself.
The test context for Node.js's test runner.
+The test context for Node.js's test runner.
OptionalsnapshotCount?: { [TestName in string]: number }Added for use by assertSnapshot.
An npm workspace object. This is the return type for queryNpmWorkspace.
+An npm workspace object. This is the return type for queryNpmWorkspace.
Allow T to be partial or have null or undefined as the value for any of its keys.
Allow T to be partial or have null or undefined as the value for any of its keys.
Allow T to be partial or have undefined as the value for any of its keys.
Allow T to be partial or have undefined as the value for any of its keys.
Collapses a selected value to the first part of the selection that contains more than 1 key or +
Collapses a selected value to the first part of the selection that contains more than 1 key or that is not an object. This produces the output type for selectCollapsedFrom.
Params for prisma.client.addData(). This is similar to PrismaAllModelsCreate but allows
+
Params for prisma.client.addData(). This is similar to PrismaAllModelsCreate but allows
an array of PrismaAllModelsCreate for sequential data creation.
import {PrismaAddModelData} from '@augment-vir/common';
import type {PrismaClient} from '@prisma/client';
const mockData: PrismaAddModelData<PrismaClient> = [
{
user: {
mockUser1: {
first_name: 'one',
id: 123,
// etc.
},
mockUser2: {
first_name: 'two',
id: 124,
authRole: 'user',
// etc.
},
},
},
{
region: [
{
id: 1,
name: 'North America',
// etc.
},
{
id: 2,
name: 'Europe',
// etc.
},
],
},
];
Basic model entries for all models in the database.
+Basic model entries for all models in the database.
Model create data stored by model name in either array or keyed form. Used in +
Model create data stored by model name in either array or keyed form. Used in
prisma.client.addData() from @augment-vir/node.
import {PrismaKeyedModelCreate} from '@augment-vir/common';
import type {PrismaClient} from '@prisma/client';
const mockData: ModelCreateData<PrismaClient> = {
user: {
mockUser1: {
first_name: 'one',
id: 123,
// etc.
},
mockUser2: {
first_name: 'two',
id: 124,
auth_role: 'user',
// etc.
},
},
region: [
{
id: 1,
name: 'North America',
// etc.
},
{
id: 2,
name: 'Europe',
// etc.
},
],
};
A basic model entry with only its immediate properties.
+A basic model entry with only its immediate properties.
A full model entry with all relations from the given Prisma type map and model name.
+A full model entry with all relations from the given Prisma type map and model name.
A type for creating multiple Prisma create mocks that are named for future reference.
+A type for creating multiple Prisma create mocks that are named for future reference.
import {PrismaKeyedModelCreate} from '@augment-vir/common';
import type {PrismaClient} from '@prisma/client';
const mockUsers = {
mockUser1: {
first_name: 'one',
id: 123,
// etc.
},
mockUser2: {
first_name: 'two',
id: 124,
auth_role: 'user',
// etc.
},
} as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
Extracts the creation data for a model from the given PrismaClient type.
Extracts the creation data for a model from the given PrismaClient type.
Extracts all model names from a generated PrismaClient.
Extracts all model names from a generated PrismaClient.
An individual item in a PromiseQueue instance.
+An individual item in a PromiseQueue instance.
The original queue item that was added.
A DeferredPromise instance with a promise that is resolved once this queue item has met its turn and has finished executing.
Data contained within an instance of PromiseQueueUpdateEvent.
+Data contained within an instance of PromiseQueueUpdateEvent.
Options for queryThroughShadow.
+Options for askQuestionUntilConditionMet.
+Options for askQuestionUntilConditionMet.
OptionaltryCountMax?: numberCallback to call with the user's response to verify if their response is valid.
Input for extractRelevantArgs.
+Input for extractRelevantArgs.
Executable bin name for your script. This should be the "bin" name in your package.json, or simply your package name if you have no custom bin name defined.
See https://docs.npmjs.com/cli/v10/configuring-npm/package-json#bin for details on the bin
@@ -9,4 +9,4 @@
always simply be __filename in CJS or import.meta.filename in ESM.
Raw arguments passed to the CLI. Typically this will simply be process.argv.
Require that the given NonVoid parameter is not void. If it is void, the ErrorType or an
+
Same as the Required<> built-in type helper but this requires that each property be present and +
Modified version of RequiredKeys from type-fest that does not require BaseType to extends
+
Parameters for docker.container.runCommand.
Parameters for docker.container.runCommand.
OptionaldockerFlags?: ReadonlyArray<string>OptionalenvMapping?: DockerEnvMapOptionalexecutionEnv?: Record<string, string>Optionaltty?: booleanCreates an interactive shell connection.
Parameters for docker.container.run.
Parameters for docker.container.run.
Optionalcommand?: stringOptionaldockerFlags?: ReadonlyArray<string>OptionalenvMapping?: DockerEnvMapOptionalexecutionEnv?: Record<string, string>Optionalplatform?: stringOptionalportMapping?: ReadonlyArray<DockerPortMap>OptionalremoveWhenDone?: booleanOptionaluseCurrentUser?: booleanOptionalvolumeMapping?: ReadonlyArray<DockerVolumeMap>Options for runShellCommand.
+Options for runShellCommand.
Optionalcwd?: stringOptionalenv?: NodeJS.ProcessEnvOptionalhookUpToConsole?: booleanAutomatically hook up stdout and stderr printing to the caller's console methods.
OptionalrejectOnError?: booleanOptionalshell?: stringOptionalstderrCallback?: (stderr: string, childProcess: ChildProcess) => MaybePromise<void> | undefinedCallback to call whenever the shell logs to stderr.
OptionalstdoutCallback?: (stdout: string, childProcess: ChildProcess) => MaybePromise<void> | undefinedCallback to call whenever the shell logs to stdout.
Performs a SQL-like nested selection on an object, extracting the selected values. This produces +
Performs a SQL-like nested selection on an object, extracting the selected values. This produces
the output type for selectFrom.
Defines a selection set for a given object type. This is used in SelectFrom.
+Defines a selection set for a given object type. This is used in SelectFrom.
Sets a key as optional but also nullable.
+Sets a key as optional but also nullable.
Require only a subset of object properties and require that they be not null. This is +
Require only a subset of object properties and require that they be not null. This is particularly useful in conjunction with the "exactOptionalPropertyTypes" tsconfig flag.
All output from runShellCommand.
+All output from runShellCommand.
Parameters for toLogString.
+Parameters for toLogString.
Narrows the given type parameter T to all its truthy sub-types.
Increments a TypeScript recursion depth tracker.
+Increments a TypeScript recursion depth tracker.
import type {
TsRecursionTracker,
TsRecursionStart,
TsRecurse,
TsTooMuchRecursion,
} from '@augment-vir/common';
export type SomeType<Depth extends TsRecursionTracker = TsRecursionStart> =
Depth extends TsTooMuchRecursion
? 'Error: recursive object depth is too deep.'
: SomeType<TsRecurse<Depth>>;
This is the default starting recursion depth needed to get the full tested allowed recursion +
This is the default starting recursion depth needed to get the full tested allowed recursion depth.
import type {
TsRecursionTracker,
TsRecursionStart,
TsRecurse,
TsTooMuchRecursion,
} from '@augment-vir/common';
export type SomeType<Depth extends TsRecursionTracker = TsRecursionStart> =
Depth extends TsTooMuchRecursion
? 'Error: recursive object depth is too deep.'
: SomeType<TsRecurse<Depth>>;
This is used as the baseline type for TypeScript recursion tracking indexes. Use this to manually +
This is used as the baseline type for TypeScript recursion tracking indexes. Use this to manually abort a type's recursion to prevent it from going too deep and throwing an error in TypeScript's language server.
import type {
TsRecursionTracker,
TsRecursionStart,
TsRecurse,
TsTooMuchRecursion,
} from '@augment-vir/common';
export type SomeType<Depth extends TsRecursionTracker = TsRecursionStart> =
Depth extends TsTooMuchRecursion
? 'Error: recursive object depth is too deep.'
: SomeType<TsRecurse<Depth>>;
Through experimentation on Typescript version 5.4.5, this is the maximum recursion depth we can +
Through experimentation on Typescript version 5.4.5, this is the maximum recursion depth we can go to before TypeScript will block recursive types. Use this as the limit to type recursion.
import type {
TsRecursionTracker,
TsRecursionStart,
TsRecurse,
TsTooMuchRecursion,
} from '@augment-vir/common';
export type SomeType<Depth extends TsRecursionTracker = TsRecursionStart> =
Depth extends TsTooMuchRecursion
? 'Error: recursive object depth is too deep.'
: SomeType<TsRecurse<Depth>>;
Accepts an "Arguments" and "Return" generic to quickly make a function type. If "Arguments" is an +
Accepts an "Arguments" and "Return" generic to quickly make a function type. If "Arguments" is an array, it is spread into the full function's Parameters list. If any argument should be an array, instead of a rest parameter, put it inside of a tuple. If no arguments should be possible, pass void to "Arguments". If you need an optional argument, pass it inside of a tuple.
@@ -6,4 +6,4 @@A minimal interface for describe. This is used in UniversalDescribe.
+A minimal interface for describe. This is used in UniversalDescribe.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
A minimal interface for it. This is used in UniversalIt.
+A minimal interface for it. This is used in UniversalIt.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
The type for describe.
+The type for describe.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
The type for it.
+The type for it.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
An interface for an it callback. Used in UniversalBareIt.
+An interface for an it callback. Used in UniversalBareIt.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
Test context provided by it's callback.
Test context provided by it's callback.
Compatible with both Node.js's test runner and web-test-runner or other Mocha-style test runners.
Gets the value within an object when all its keys are required.
+Gets the value within an object when all its keys are required.
Options for wrapInTry.
+Options for wrapInTry.
Options for writeJsonFile.
+ConstA map of file extensions to their known runners for runCliScript.
+ConstA map of file extensions to their known runners for runCliScript.
ConstAll letters allowed in randomString.
+ConstAll letters allowed in randomString.
ConstA RegExp that will match all ansi escape codes (such as terminal colors). Used in +
ConstA RegExp that will match all ansi escape codes (such as terminal colors). Used in removeAnsiEscapeCodes.
ConstThe current operating system type, as deduced from +
ConstThe current operating system type, as deduced from
process.platform.
ConstThe current RuntimeEnv.
+ConstDefault options for CasingOptions.
+ConstDefault implementation of LogColorConfig.
+ConstDefault implementation of LogWriters that is dependent on the current runtime environment.
+ConstDefault implementation of LogWriters that is dependent on the current runtime environment.
ConstDefault implementation of LoggerOptions.
+ConstThe default truncation prefixes for truncateNumber.
+ConstThe default truncation prefixes for truncateNumber.
ConstCentralized Docker API from @augment-vir/node.
ConstCentralized Docker API from @augment-vir/node.
Copy a file or directory to a container.
Run docker inspect on a container and return its output.
Get a container's logs.
@@ -26,4 +26,4 @@Manually create a string of volume mapping flags. This is automatically done already inside the run container methods.
ConstConstStatuses from DockerContainerStatus that indicate that a container has been exited in some +
ConstStatuses from DockerContainerStatus that indicate that a container has been exited in some way.
ConstAll standardized HTTP status codes grouped into their respective categories.
+ConstAll standardized HTTP status codes grouped into their respective categories.
ReadonlyclientError: readonly [Readonlyinformation: readonly [Continue, SwitchingProtocols, Processing, EarlyHints]Readonlyredirect: readonly [ReadonlyserverError: readonly [Readonlysuccess: readonly [ConstSuffix for addPercent and removePercent.
+ConstSuffix for addPercent and removePercent.
ConstCentralized Prisma API from @augment-vir/node.
ConstGet current migration status.
ConstUse this to define mock entries that shouldn't be saved to the database so that we can easily +
ConstUse this to define mock entries that shouldn't be saved to the database so that we can easily write tests for missing data.
import type {PrismaClient} from '@prisma/client';
import {prismaModelCreateExclude, PrismaKeyedModelCreate} from '@augment-vir/common';
export const mockUsers = {
user1: {
id: 1,
authRole: 'admin',
},
missingUser: {
id: -1,
authRole: 'user',
[prismaModelCreateExclude]: true,
},
} as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
ConstUse this to prevent the id property from being included when creating a mock record, allowing the +
ConstUse this to prevent the id property from being included when creating a mock record, allowing the database's internal auto-increment functionality to generate one. This is necessary when testing creation of new records because manually specified ids do not increment the auto incrementor.
import type {PrismaClient} from '@prisma/client';
import {prismaModelCreateOmitId, PrismaKeyedModelCreate} from '@augment-vir/common';
export const mockUsers = {
user1: {
id: 1,
authRole: 'admin',
[prismaModelCreateOmitId]: true,
},
user2: {
id: 2,
authRole: 'admin',
[prismaModelCreateOmitId]: true,
},
} as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
ConstConstConstA suite of web test helpers. This is only accessible within a browser runtime. If accessed +
ConstA suite of web test helpers. This is only accessible within a browser runtime. If accessed outside of a browser runtime, it'll be an Error instead of a collection of test helpers.
Cleans up all rendered test HTML by removing the actual wrapper nodes. Common use case is at the end of each test.
@@ -16,4 +16,4 @@Types the given string as if it were input by a keyboard. This doesn't try to type into any element in particular, it'll go wherever the current focus is, if any.
An error thrown by the
+@augment-vir/assertpackage when an assertion fails.- Preparing search index...
- The search index is not available
augment-vir - v31.5.0Class AssertionError
An error thrown by the
@augment-vir/assertpackage when an assertion fails.This requires both a
@@ -6,6 +6,6 @@baseMessage(the default "this thing failed" error message defined inside@augment-vir/assertfor each assert method), and a possibly-undefineduserCustomizedMessage(the optional user-defined failure message for any assertion).Package
-@augment-vir/assertHierarchy
Index
Constructors
Hierarchy
Index
Constructors
Properties
Constructors
constructor
baseMessage: string,
userCustomizedMessage: undefined | string,
): AssertionError
Parameters
Returns AssertionError
Properties
name
Settings
On This Page
Constructors
Properties