@openstax/ts-utils 1.2.8 → 1.3.0

package/dist/cjs/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/cjs/assertions.js

@@ -1,4 +1,17 @@
 "use strict";
+/*
+ * 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.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertErrorInstanceOf = exports.assertInstanceOf = exports.notNaN = exports.assertNotNaN = exports.assertString = exports.assertDefined = exports.assertFalse = exports.assertTrue = void 0;
 const doThrow = (failed) => {
@@ -13,10 +26,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
  */
 const assertTrue = (x, failed) => {
     if (typeof x !== 'boolean' || x !== true) {
@@ -25,10 +43,15 @@ const assertTrue = (x, failed) => {
     return x;
 };
 exports.assertTrue = assertTrue;
-/*
- * 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
  */
 const assertFalse = (x, failed) => {
     if (typeof x !== 'boolean' || x !== false) {
@@ -37,10 +60,15 @@ const assertFalse = (x, failed) => {
     return x;
 };
 exports.assertFalse = assertFalse;
-/*
- * 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
  */
 const assertDefined = (x, failed) => {
     if (x === undefined) {
@@ -49,10 +77,15 @@ const assertDefined = (x, failed) => {
     return x;
 };
 exports.assertDefined = assertDefined;
-/*
- * 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
  */
 const assertString = (x, failed) => {
     if (typeof x !== 'string') {
@@ -61,14 +94,15 @@ const assertString = (x, failed) => {
     return x;
 };
 exports.assertString = assertString;
-/*
- * 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
  */
 const assertNotNaN = (thing, failed) => {
     if (typeof thing === 'number' && isNaN(thing)) {
@@ -77,15 +111,20 @@ const assertNotNaN = (thing, failed) => {
     return thing;
 };
 exports.assertNotNaN = assertNotNaN;
-// deprecated function name
+/**
+ * @deprecated use assertNotNaN instead
+ */
 exports.notNaN = exports.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
  */
 const assertInstanceOf = (thing, constructable, failed) => {
     if (thing instanceof constructable) {
@@ -94,10 +133,16 @@ const assertInstanceOf = (thing, constructable, failed) => {
     return doThrow(failed);
 };
 exports.assertInstanceOf = assertInstanceOf;
-/*
- * 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
  */
 const assertErrorInstanceOf = (thing, constructable) => {
     if (thing instanceof Error) {

package/dist/cjs/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/cjs/aws/ssmService.js

@@ -3,4 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssmService = void 0;
 const client_ssm_1 = require("@aws-sdk/client-ssm");
 const __1 = require("..");
+/**
+ * A memoized instance of the AWS SSM client.
+ */
 exports.ssmService = (0, __1.once)(() => new client_ssm_1.SSM({ apiVersion: '2012-08-10' }));

package/dist/cjs/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/cjs/config/awsParameterConfig.js

@@ -5,6 +5,14 @@ const client_ssm_1 = require("@aws-sdk/client-ssm");
 const assertions_1 = require("../assertions");
 const ssmService_1 = require("../aws/ssmService");
 const resolveConfigValue_1 = require("./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
+ */
 const awsParameterConfig = (parameterName) => {
     return async () => {
         const command = new client_ssm_1.GetParameterCommand({ Name: await (0, resolveConfigValue_1.resolveConfigValue)(parameterName), WithDecryption: true });

package/dist/cjs/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/cjs/config/envConfig.js

@@ -3,22 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.envConfig = exports.ENV_BUILD_CONFIGS = void 0;
 const assertions_1 = require("../assertions");
 const guards_1 = require("../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.
+ */
+exports.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'),
- *   };
- * */
-exports.ENV_BUILD_CONFIGS = [];
+ * @example const config = { configValue: envConfig('environment_variable_name') };
+ */
 const envConfig = (name, type = 'build', defaultValue) => {
     if (type === 'build') {
         exports.ENV_BUILD_CONFIGS.push(name);

package/dist/cjs/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/cjs/config/index.js

@@ -21,15 +21,12 @@ __exportStar(require("./resolveConfigValue"), exports);
  * 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') };
+ */
 const stubConfig = (configValue) => configValue;
 exports.stubConfig = stubConfig;
 __exportStar(require("./envConfig"), exports);

package/dist/cjs/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/cjs/config/lambdaParameterConfig.js

@@ -11,8 +11,16 @@ const envConfig_1 = require("./envConfig");
 const _1 = require(".");
 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
+ */
 const lambdaParameterConfig = (parameterName) => async () => {
     const token = await (0, _1.resolveConfigValue)((0, envConfig_1.envConfig)('AWS_SESSION_TOKEN', 'runtime'));
     const name = await (0, _1.resolveConfigValue)(parameterName);

package/dist/cjs/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/cjs/config/replaceConfig.js

@@ -2,6 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replaceConfig = void 0;
 const resolveConfigValue_1 = require("./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
+ */
 const replaceConfig = (base, replacements) => {
     return async () => {
         const resolved = await Promise.all(Object.entries(replacements)

package/dist/cjs/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/cjs/config/resolveConfigValue.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveConfigValue = void 0;
-/*
+/**
  * resolves a config value into a string, to be used inside of things that are provided configurations
- * */
+ */
 const resolveConfigValue = async (provider) => {
     return typeof provider === 'function'
         ? await provider()

package/dist/cjs/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/cjs/errors.js

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = exports.isAppError = void 0;
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -13,11 +11,22 @@ exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError
  *   error instanceof InvalidRequestError
  *
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = exports.isAppError = void 0;
 const errorIsType = ({ TYPE }) => (e) => e instanceof Error
     && e.constructor.TYPE === TYPE;
+/**
+ * Returns true if the error is defined in this library
+ */
 const isAppError = (e) => e instanceof Error
     && typeof e.constructor.TYPE === 'string';
 exports.isAppError = isAppError;
+/**
+ * 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
+ */
 class InvalidRequestError extends Error {
     constructor(message) {
         super(message || InvalidRequestError.TYPE);
@@ -26,6 +35,12 @@ class InvalidRequestError extends Error {
 exports.InvalidRequestError = InvalidRequestError;
 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
+ */
 class UnauthorizedError extends Error {
     constructor(message) {
         super(message || UnauthorizedError.TYPE);
@@ -34,6 +49,12 @@ class UnauthorizedError extends Error {
 exports.UnauthorizedError = UnauthorizedError;
 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
+ */
 class NotFoundError extends Error {
     constructor(message) {
         super(message || NotFoundError.TYPE);
@@ -42,6 +63,12 @@ class NotFoundError extends Error {
 exports.NotFoundError = NotFoundError;
 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
+ */
 class SessionExpiredError extends Error {
     constructor(message) {
         super(message || SessionExpiredError.TYPE);