@openstax/ts-utils 1.2.9 → 1.3.1

package/dist/cjs/types.d.ts

@@ -1,6 +1,27 @@
+/**
+ * Returns the literal type `'yes'` if the first generic tuple array is a prefix of the second,
+ * the `'no'` literal type otherwise. Can be used in conditional types, e.g.
+ *
+ * `type WillBeString = TupleExtends<[1,2], [1,2,3]> extends 'yes' ? string : number;`
+ *
+ * There may be a better way to do this; `T1 extends T2` doesn't work
+ */
 export declare type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
+/**
+ * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
+ * @deprecated use TypeScript builtin Awaited instead:
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements
+ */
 export declare type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
+/**
+ * turns `thing | thing2` into `thing & thing2`
+ * @see https://stackoverflow.com/a/50375286/14809536
+ */
 export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * make certain fields required
+ * @see https://stackoverflow.com/a/69328045/14809536
+ */
 export declare type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };

package/dist/esm/assertions.d.ts

@@ -1,10 +1,85 @@
 declare type AssertionFailed = string | Error | (() => never) | undefined;
+/**
+ * Asserts that the given value is true.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
+ * @returns the value that was asserted
+ */
 export declare const assertTrue: <X>(x: X, failed?: AssertionFailed) => X & true;
+/**
+ * Asserts that the given value is false.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
+ * @returns the value that was asserted
+ */
 export declare const assertFalse: <X>(x: X, failed?: AssertionFailed) => X & false;
+/**
+ * Asserts that the given value is defined.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
+ * @returns the value that was asserted, with a type that excludes undefined
+ */
 export declare const assertDefined: <X>(x: X, failed?: AssertionFailed) => Exclude<X, undefined>;
+/**
+ * Asserts that the given value is a string.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
+ * @returns the value that was asserted
+ */
 export declare const assertString: <X>(x: X, failed?: AssertionFailed) => string;
+/**
+ * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
+ *
+ * @param thing The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
+ * @returns the value that was asserted
+ */
 export declare const assertNotNaN: <T>(thing: T, failed?: AssertionFailed) => T;
+/**
+ * @deprecated use assertNotNaN instead
+ */
 export declare const notNaN: <T>(thing: T, failed?: AssertionFailed) => T;
+/**
+ * Asserts that the first argument is an instance of the second.
+ *
+ * @param thing The value to assert.
+ * @param constructable The class to check against.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
+ * @returns the value that was asserted
+ */
 export declare const assertInstanceOf: <T>(thing: any, constructable: Function & (new (...args: any[]) => T), failed?: AssertionFailed) => T;
+/**
+ * Asserts that the error in the first argument is an instance of the error given as the
+ * second argument
+ *
+ * @param thing The value to assert.
+ * @param constructable The error class to check against.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
+ * @returns the value that was asserted
+ * @throws the original error if the check fails
+ * @see assertInstanceOf
+ */
 export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & (new (...args: any[]) => T)) => T;
 export {};

package/dist/esm/assertions.js

@@ -1,3 +1,16 @@
+/*
+ * all of these assertions take either a string, throw function, or nothing
+ * for the second argument. its STRONGLY encouraged to provide some error
+ * or message that explains the reason for the assertion
+ *
+ * eg:
+ *   assertDefined(user, new UnauthorizedException())
+ *   assertDefined(thing.otherThing, 'otherThing should be guaranteed to exist, but is missing')
+ *
+ * passing an Error instead of a string makes the first element of the resulting
+ * stack trace more useful, and allows you to use specific error types
+ * that might be handled differently.
+ */
 const doThrow = (failed) => {
     if (typeof failed === 'string') {
         throw new Error(failed);
@@ -10,10 +23,15 @@ const doThrow = (failed) => {
     }
     return failed();
 };
-/*
- * see note above about the failure case in the second argument
+/**
+ * Asserts that the given value is true.
  *
- * const definitelyTrue = assertTrue(randomThing);
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
+ * @returns the value that was asserted
  */
 export const assertTrue = (x, failed) => {
     if (typeof x !== 'boolean' || x !== true) {
@@ -21,10 +39,15 @@ export const assertTrue = (x, failed) => {
     }
     return x;
 };
-/*
- * see note above about the failure case in the second argument
+/**
+ * Asserts that the given value is false.
  *
- * const definitelyFalse = assertFalse(randomThing);
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
+ * @returns the value that was asserted
  */
 export const assertFalse = (x, failed) => {
     if (typeof x !== 'boolean' || x !== false) {
@@ -32,10 +55,15 @@ export const assertFalse = (x, failed) => {
     }
     return x;
 };
-/*
- * see note above about the failure case in the second argument
+/**
+ * Asserts that the given value is defined.
  *
- * const definitelyDefined = assertDefined(randomThing);
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
+ * @returns the value that was asserted, with a type that excludes undefined
  */
 export const assertDefined = (x, failed) => {
     if (x === undefined) {
@@ -43,10 +71,15 @@ export const assertDefined = (x, failed) => {
     }
     return x;
 };
-/*
- * see note above about the failure case in the second argument
+/**
+ * Asserts that the given value is a string.
  *
- * const definitelyAString = assertString(randomThing);
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
+ * @returns the value that was asserted
  */
 export const assertString = (x, failed) => {
     if (typeof x !== 'string') {
@@ -54,14 +87,15 @@ export const assertString = (x, failed) => {
     }
     return x;
 };
-/*
- * see note above about the failure case in the second argument
- *
- * this doesn't assert that the thing is a number, it just asserts that its not
- * the actual NaN value
+/**
+ * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
  *
- * eg:
- *   const definitelyNotNotANumber = assertNotNaN(randomThing);
+ * @param thing The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
+ * @returns the value that was asserted
  */
 export const assertNotNaN = (thing, failed) => {
     if (typeof thing === 'number' && isNaN(thing)) {
@@ -69,15 +103,20 @@ export const assertNotNaN = (thing, failed) => {
     }
     return thing;
 };
-// deprecated function name
+/**
+ * @deprecated use assertNotNaN instead
+ */
 export const notNaN = assertNotNaN;
-/*
- * unlike other guards, this one takes 2 arguments
- *
- * the second argument is the class that we are checking against
+/**
+ * Asserts that the first argument is an instance of the second.
  *
- * eg:
- *   const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
+ * @param thing The value to assert.
+ * @param constructable The class to check against.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
+ * @returns the value that was asserted
  */
 export const assertInstanceOf = (thing, constructable, failed) => {
     if (thing instanceof constructable) {
@@ -85,10 +124,16 @@ export const assertInstanceOf = (thing, constructable, failed) => {
     }
     return doThrow(failed);
 };
-/*
- * like assertInstanceOf but only for error classes
+/**
+ * Asserts that the error in the first argument is an instance of the error given as the
+ * second argument
  *
- * rethrows the original error if the check fails
+ * @param thing The value to assert.
+ * @param constructable The error class to check against.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
+ * @returns the value that was asserted
+ * @throws the original error if the check fails
+ * @see assertInstanceOf
  */
 export const assertErrorInstanceOf = (thing, constructable) => {
     if (thing instanceof Error) {

package/dist/esm/aws/ssmService.d.ts

@@ -1,2 +1,5 @@
 import { SSM } from '@aws-sdk/client-ssm';
+/**
+ * A memoized instance of the AWS SSM client.
+ */
 export declare const ssmService: () => SSM;

package/dist/esm/aws/ssmService.js

@@ -1,3 +1,6 @@
 import { SSM } from '@aws-sdk/client-ssm';
 import { once } from '..';
+/**
+ * A memoized instance of the AWS SSM client.
+ */
 export const ssmService = once(() => new SSM({ apiVersion: '2012-08-10' }));

package/dist/esm/config/awsParameterConfig.d.ts

@@ -1,2 +1,10 @@
 import { ConfigValueProvider } from '.';
+/**
+ * Returns a value from the AWS Parameter Store.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
 export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/awsParameterConfig.js

@@ -2,6 +2,14 @@ import { GetParameterCommand } from '@aws-sdk/client-ssm';
 import { assertDefined } from '../assertions';
 import { ssmService } from '../aws/ssmService';
 import { resolveConfigValue } from './resolveConfigValue';
+/**
+ * Returns a value from the AWS Parameter Store.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
 export const awsParameterConfig = (parameterName) => {
     return async () => {
         const command = new GetParameterCommand({ Name: await resolveConfigValue(parameterName), WithDecryption: true });

package/dist/esm/config/envConfig.d.ts

@@ -1,3 +1,24 @@
 import { ConfigValueProvider } from '.';
+/**
+ * A list of environment variables that were requested at build time. Used by webpack to
+ * capture build-time environment variables values.
+ */
 export declare const ENV_BUILD_CONFIGS: string[];
+/**
+ * Returns an environment variable from the process environment. Depending on the `type` in the
+ * call to get the variable, the variable's value may be what it was at build time, not at runtime.
+ * The return value is not the variable value itself, but rather a provider that has to be called
+ * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
+ * because someone else later needs to call the provider to get the value -- that call may explode,
+ * but this one won't).
+ *
+ * @param name The name of the environment variable to retrieve.
+ * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
+ * variable as it was set at build time (webpack is connected here to make this possible). This
+ * argument can also be `'runtime'` in which case the value at build time is ignored and the
+ * variable is pulled live from `process.env`.
+ * @param [defaultValue] The default value to use if the variable is not found.
+ *
+ * @example const config = { configValue: envConfig('environment_variable_name') };
+ */
 export declare const envConfig: (name: string, type?: 'build' | 'runtime', defaultValue?: string | undefined) => ConfigValueProvider<string>;

package/dist/esm/config/envConfig.js

@@ -1,21 +1,27 @@
 import { assertDefined } from '../assertions';
 import { ifDefined } from '../guards';
-/*
- * uses a config from the process environment.
- *
- * there are two modes for this, by default it expects the value to be provided at build time,
- * and there is access built in here for webpack to provide the configs. if you pass `runtime`
- * as the second argument it skips the build logic and will try to literally pull it from
- * `process.env` when the config is used at runtime
+/**
+ * A list of environment variables that were requested at build time. Used by webpack to
+ * capture build-time environment variables values.
+ */
+export const ENV_BUILD_CONFIGS = [];
+/**
+ * Returns an environment variable from the process environment. Depending on the `type` in the
+ * call to get the variable, the variable's value may be what it was at build time, not at runtime.
+ * The return value is not the variable value itself, but rather a provider that has to be called
+ * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
+ * because someone else later needs to call the provider to get the value -- that call may explode,
+ * but this one won't).
  *
- * the value is read from the environment when something tries to use it, not when `envConfig` is called.
+ * @param name The name of the environment variable to retrieve.
+ * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
+ * variable as it was set at build time (webpack is connected here to make this possible). This
+ * argument can also be `'runtime'` in which case the value at build time is ignored and the
+ * variable is pulled live from `process.env`.
+ * @param [defaultValue] The default value to use if the variable is not found.
  *
- * eg:
- *   const config = {
- *     configValue: envConfig('environment_variable_name'),
- *   };
- * */
-export const ENV_BUILD_CONFIGS = [];
+ * @example const config = { configValue: envConfig('environment_variable_name') };
+ */
 export const envConfig = (name, type = 'build', defaultValue) => {
     if (type === 'build') {
         ENV_BUILD_CONFIGS.push(name);

package/dist/esm/config/index.d.ts

@@ -1,18 +1,46 @@
+/**
+ * A simple type alias for a string that represents a configuration value. Currently only string values are supported to maintain compatibility with environment variables, but this type is future proofing against allowing other types like `number` as possible config values.
+ */
 export declare type ConfigValue = string;
+/**
+ * A configuration object that may contain nested configuration objects or configuration values.
+ */
 export declare type Config = {
     [key: string]: Config | ConfigValue;
 };
+/**
+ * Either a function that returns a `ConfigValue` or a `Promise` that resolves to a `ConfigValue`,
+ * or just a `ConfigValue`.
+ */
 export declare type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
+/**
+ * A configuration object that may contain nested configuration objects or configuration value providers.
+ */
 export declare type ConfigProvider = {
     [key: string]: ConfigProvider | ConfigValueProvider;
 };
+/**
+ * Conditional type that resolves to the type of configuration object for the given configuration
+ * provider. Also resolves to a config value type if the given type is a config value.
+ */
 export declare type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T extends ConfigProvider ? {
     [key in keyof T]: ConfigForConfigProvider<T[key]>;
 } : T extends ConfigValueProvider<infer R> ? R : never;
+/**
+ * Conditional type that resolves to the `ConfigProvider` type for the given configuration
+ * type (`ConfigValue` or `Config`). The resulting type is either a `ConfigValueProvider` or
+ * a `ConfigProvider`.
+ */
 export declare type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
     [key in keyof T]: ConfigProviderForConfig<T[key]>;
 } : never;
 export * from './resolveConfigValue';
+/**
+ * stub, mostly for testing. sometimes it helps please typescript to use this if you have
+ * two configs you want to have the same type but one is a fixed string and one is a complicated provider
+ *
+ * @example const config = { configValue: stubConfig('just-a-string') };
+ */
 export declare const stubConfig: <V extends string>(configValue: V) => ConfigValueProvider<V>;
 export * from './envConfig';
 export * from './replaceConfig';

package/dist/esm/config/index.js

@@ -4,15 +4,12 @@ export * from './resolveConfigValue';
  * re-usable config providers
  * ===========
  * */
-/*
+/**
  * stub, mostly for testing. sometimes it helps please typescript to use this if you have
  * two configs you want to have the same type but one is a fixed string and one is a complicated provider
  *
- * eg:
- *   const config = {
- *     configValue: stubConfig('just-a-string'),
- *   };
- * */
+ * @example const config = { configValue: stubConfig('just-a-string') };
+ */
 export const stubConfig = (configValue) => configValue;
 export * from './envConfig';
 export * from './replaceConfig';

package/dist/esm/config/lambdaParameterConfig.d.ts

@@ -1,2 +1,12 @@
 import { ConfigValueProvider } from '.';
+/**
+ * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
+ * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
+ * This extension has built-in caching for requested parameters.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
 export declare const lambdaParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/lambdaParameterConfig.js

@@ -5,8 +5,16 @@ import { envConfig } from './envConfig';
 import { resolveConfigValue } from '.';
 const lambdaExtensionUrl = 'http://localhost:2773';
 let lambdaExtensionReadyPromise;
-// NOTE: Can only be used during in AWS Lambda
-// The AWS Parameters and Secrets Lambda Extension Layer must be included in the Lambda function
+/**
+ * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
+ * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
+ * This extension has built-in caching for requested parameters.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
 export const lambdaParameterConfig = (parameterName) => async () => {
     const token = await resolveConfigValue(envConfig('AWS_SESSION_TOKEN', 'runtime'));
     const name = await resolveConfigValue(parameterName);

package/dist/esm/config/replaceConfig.d.ts

@@ -1,4 +1,14 @@
 import { ConfigValueProvider } from '.';
+/**
+ * Substitutes configuration values into a provided string.
+ * Performs a string substitution using configuration values
+ * @param base The string into which substitutions will be made; contains tokens that are
+ * referenced in the `replacements` argument.
+ * @param replacements A map of tokens to configuration value providers. The providers are
+ * resolved and the values are substituted into the `base` string, replacing the tokens.
+ * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
+ * @returns the string after substitution is complete
+ */
 export declare const replaceConfig: (base: ConfigValueProvider<string>, replacements: {
     [token: string]: ConfigValueProvider<string>;
 }) => ConfigValueProvider<string>;

package/dist/esm/config/replaceConfig.js

@@ -1,4 +1,14 @@
 import { resolveConfigValue } from './resolveConfigValue';
+/**
+ * Substitutes configuration values into a provided string.
+ * Performs a string substitution using configuration values
+ * @param base The string into which substitutions will be made; contains tokens that are
+ * referenced in the `replacements` argument.
+ * @param replacements A map of tokens to configuration value providers. The providers are
+ * resolved and the values are substituted into the `base` string, replacing the tokens.
+ * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
+ * @returns the string after substitution is complete
+ */
 export const replaceConfig = (base, replacements) => {
     return async () => {
         const resolved = await Promise.all(Object.entries(replacements)

package/dist/esm/config/resolveConfigValue.d.ts

@@ -1,2 +1,5 @@
 import { ConfigValueProvider } from '.';
+/**
+ * resolves a config value into a string, to be used inside of things that are provided configurations
+ */
 export declare const resolveConfigValue: <V extends string>(provider: ConfigValueProvider<V>) => Promise<V>;

package/dist/esm/config/resolveConfigValue.js

@@ -1,6 +1,6 @@
-/*
+/**
  * resolves a config value into a string, to be used inside of things that are provided configurations
- * */
+ */
 export const resolveConfigValue = async (provider) => {
     return typeof provider === 'function'
         ? await provider()

package/dist/esm/errors.d.ts

@@ -1,23 +1,50 @@
+/**
+ * Returns true if the error is defined in this library
+ */
 export declare const isAppError: (e: any) => e is Error & {
     constructor: {
         TYPE: string;
     };
 };
+/**
+ * Invalid request error
+ *
+ * `InvalidRequestError.matches(error)` is a reliable way to check if an error is an
+ * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export declare class InvalidRequestError extends Error {
     static readonly TYPE = "InvalidRequestError";
     static matches: (e: any) => e is typeof InvalidRequestError;
     constructor(message?: string);
 }
+/**
+ * Unauthorized error
+ *
+ * `UnauthorizedError.matches(error)` is a reliable way to check if an error is an
+ * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export declare class UnauthorizedError extends Error {
     static readonly TYPE = "UnauthorizedError";
     static matches: (e: any) => e is typeof UnauthorizedError;
     constructor(message?: string);
 }
+/**
+ * Not found error
+ *
+ * `NotFoundError.matches(error)` is a reliable way to check if an error is a
+ * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export declare class NotFoundError extends Error {
     static readonly TYPE = "NotFoundError";
     static matches: (e: any) => e is typeof NotFoundError;
     constructor(message?: string);
 }
+/**
+ * Session expired error
+ *
+ * `SessionExpiredError.matches(error)` is a reliable way to check if an error is a
+ * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export declare class SessionExpiredError extends Error {
     static readonly TYPE = "SessionExpiredError";
     static matches: (e: any) => e is typeof SessionExpiredError;

package/dist/esm/errors.js

@@ -12,8 +12,17 @@
  */
 const errorIsType = ({ TYPE }) => (e) => e instanceof Error
     && e.constructor.TYPE === TYPE;
+/**
+ * Returns true if the error is defined in this library
+ */
 export const isAppError = (e) => e instanceof Error
     && typeof e.constructor.TYPE === 'string';
+/**
+ * Invalid request error
+ *
+ * `InvalidRequestError.matches(error)` is a reliable way to check if an error is an
+ * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export class InvalidRequestError extends Error {
     constructor(message) {
         super(message || InvalidRequestError.TYPE);
@@ -21,6 +30,12 @@ export class InvalidRequestError extends Error {
 }
 InvalidRequestError.TYPE = 'InvalidRequestError';
 InvalidRequestError.matches = errorIsType(InvalidRequestError);
+/**
+ * Unauthorized error
+ *
+ * `UnauthorizedError.matches(error)` is a reliable way to check if an error is an
+ * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export class UnauthorizedError extends Error {
     constructor(message) {
         super(message || UnauthorizedError.TYPE);
@@ -28,6 +43,12 @@ export class UnauthorizedError extends Error {
 }
 UnauthorizedError.TYPE = 'UnauthorizedError';
 UnauthorizedError.matches = errorIsType(UnauthorizedError);
+/**
+ * Not found error
+ *
+ * `NotFoundError.matches(error)` is a reliable way to check if an error is a
+ * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export class NotFoundError extends Error {
     constructor(message) {
         super(message || NotFoundError.TYPE);
@@ -35,6 +56,12 @@ export class NotFoundError extends Error {
 }
 NotFoundError.TYPE = 'NotFoundError';
 NotFoundError.matches = errorIsType(NotFoundError);
+/**
+ * Session expired error
+ *
+ * `SessionExpiredError.matches(error)` is a reliable way to check if an error is a
+ * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
 export class SessionExpiredError extends Error {
     constructor(message) {
         super(message || SessionExpiredError.TYPE);