@openstax/ts-utils 1.33.1 → 1.34.0

package/dist/esm/middleware/apiErrorHandler.d.ts

@@ -1,24 +0,0 @@
-import { ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
-import type { ApiResponse } from '../routing';
-import type { Logger } from '../services/logger';
-export type DefaultErrors = {
-    InvalidRequestError: InvalidRequestError;
-    UnauthorizedError: UnauthorizedError;
-    ForbiddenError: ForbiddenError;
-    NotFoundError: NotFoundError;
-    ValidationError: ValidationError;
-    SessionExpiredError: SessionExpiredError;
-};
-export type Handlers<E> = {
-    [T in keyof E]?: (e: E[T], logger: Logger) => ApiResponse<number, any>;
-};
-export declare const defaultHandlers: Handlers<DefaultErrors>;
-/**
- * Creates an error handler. Provides default handlers for `UnauthorizedError`,
- * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
- * handlers can be added to these. If no handler is found, the error is logged and
- * a 500 text response is returned.
- *
- * @param inputHandlers a map of errors to handler functions
- */
-export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors>) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;

package/dist/esm/middleware/apiErrorHandler.js

@@ -1,38 +0,0 @@
-import { isAppError, } from '../errors';
-import { apiJsonResponse, apiTextResponse } from '../routing';
-import { Level } from '../services/logger';
-export const defaultHandlers = {
-    InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
-    UnauthorizedError: (e) => apiTextResponse(401, `401 ${e.message}`),
-    ForbiddenError: (e) => apiTextResponse(403, `403 ${e.message}`),
-    NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
-    ValidationError: (e) => apiJsonResponse(422, e.getData()),
-    SessionExpiredError: (e) => apiTextResponse(440, `440 ${e.message}`),
-};
-/**
- * Creates an error handler. Provides default handlers for `UnauthorizedError`,
- * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
- * handlers can be added to these. If no handler is found, the error is logged and
- * a 500 text response is returned.
- *
- * @param inputHandlers a map of errors to handler functions
- */
-export const createErrorHandler = (inputHandlers) => {
-    const handlers = { ...defaultHandlers, ...inputHandlers };
-    return async (e, logger) => {
-        const name = isAppError(e) ? e.constructor.TYPE : e.constructor.name;
-        const handler = handlers[name];
-        const logLevel = handler ? Level.Info : Level.Error;
-        logger.logEvent(logLevel, {
-            name: e.name,
-            message: e.message,
-            stack: e.stack,
-        });
-        if (handler) {
-            // convincing typescript that this error is the right kind for the handler
-            // we looked up based on the errors name is very annoying
-            return handler(e, logger);
-        }
-        return apiTextResponse(500, '500 Error');
-    };
-};

package/dist/esm/middleware/apiSlowResponseMiddleware.d.ts

@@ -1,23 +0,0 @@
-import type { ConfigProviderForConfig } from '../config';
-import type { ApiResponse } from '../routing';
-import type { Logger } from '../services/logger';
-type Config = {
-    logResponseSlowerThan: string;
-    timeoutResponseAfter: string;
-};
-/**
- * Creates response middleware that logs slow responses and times out responses that take too long. lambda functions have a timeout setting, but when a lambda times out there is no way to log anything helpful before it exists. this middleware allows the logger context to show up for timeout requests. just make sure that the `timeoutResponseAfter` is set to something slightly shorter than the lambda timeout so that it has time to run.
- *
- * @param config
- * @param config.logResponseSlowerThan the config that specifies the threshold for a slow response
- * @param config.timeoutResponseAfter the config that specifies the timeout for a response
- * @example
- * createSlowResponseMiddleware({
- *   logResponseSlowerThan: envConfig('LOG_SLOW_RESPONSE', 'runtime', '1000'),
- *   timeoutResponseAfter: envConfig('RESPONSE_TIMEOUT', 'runtime', '28000'),
- * });
- */
-export declare const createSlowResponseMiddleware: (config: ConfigProviderForConfig<Config>) => () => (response: Promise<ApiResponse<number, any>> | undefined, { logger }: {
-    logger: Logger;
-}) => Promise<ApiResponse<number, string>> | undefined;
-export {};

package/dist/esm/middleware/apiSlowResponseMiddleware.js

@@ -1,50 +0,0 @@
-import { resolveConfigValue } from '../config/resolveConfigValue';
-import { once } from '../misc/helpers';
-import { apiTextResponse } from '../routing';
-import { Level } from '../services/logger';
-/**
- * Creates response middleware that logs slow responses and times out responses that take too long. lambda functions have a timeout setting, but when a lambda times out there is no way to log anything helpful before it exists. this middleware allows the logger context to show up for timeout requests. just make sure that the `timeoutResponseAfter` is set to something slightly shorter than the lambda timeout so that it has time to run.
- *
- * @param config
- * @param config.logResponseSlowerThan the config that specifies the threshold for a slow response
- * @param config.timeoutResponseAfter the config that specifies the timeout for a response
- * @example
- * createSlowResponseMiddleware({
- *   logResponseSlowerThan: envConfig('LOG_SLOW_RESPONSE', 'runtime', '1000'),
- *   timeoutResponseAfter: envConfig('RESPONSE_TIMEOUT', 'runtime', '28000'),
- * });
- */
-export const createSlowResponseMiddleware = (config) => {
-    const getSlowThreshold = once(() => resolveConfigValue(config.logResponseSlowerThan).then(result => parseInt(result, 10)));
-    const getTimeoutAfter = once(() => resolveConfigValue(config.timeoutResponseAfter).then(result => parseInt(result, 10)));
-    return () => (response, { logger }) => {
-        const start = Date.now();
-        if (!response) {
-            return response;
-        }
-        return Promise.all([getSlowThreshold(), getTimeoutAfter()]).then(([slowThreshold, timeoutAfter]) => {
-            let timeout = undefined;
-            const timeoutPromise = isNaN(timeoutAfter)
-                ? undefined
-                : new Promise(resolve => timeout = setTimeout(() => {
-                    logger.logEvent(Level.Error, {
-                        message: 'request processing timed out',
-                    });
-                    resolve(apiTextResponse(504, '504 Gateway Timeout'));
-                }, timeoutAfter));
-            const requestPromise = response.finally(() => {
-                const time = Date.now() - start;
-                if (timeout !== undefined) {
-                    clearTimeout(timeout);
-                }
-                if (time > slowThreshold) {
-                    logger.logEvent(Level.Warn, {
-                        message: 'slow response',
-                        time,
-                    });
-                }
-            });
-            return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
-        });
-    };
-};

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

@@ -1,47 +0,0 @@
-import { TupleZip } from '../types';
-export type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa, appBinder?: ((app: Sa, provider: MiddlewareProvider<Sa, M, A, R>) => (middleware: M, ...args: A) => R)) => (middleware: M, ...args: A) => R;
-export type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
-export type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
-export type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? (Omit<R, keyof M> & M) extends R ? Omit<R, keyof M> & M : R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;
-export type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
-export type ServiceMiddlewareProviderChainResult<C, M> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderResult<M, S1> : ServiceMiddlewareProviderChainResult<S, ServiceMiddlewareProviderResult<M, S1>> : C extends unknown ? M : never;
-export type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleZip<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> : C extends unknown ? [] : never;
-/**
- * Creates a middleware composer for given AppServices and input value types. The composer accepts a list of middleware
- * that it assembles into a chain. The function returned by the composer takes a value of the given input value type,
- * passes that value through the chain, and returns the result of the last element in the chain. The ending value will
- * depend on the composed middleware.
- *
- * Examples:
- *
- * ```
- * export const composeServiceMiddleware =
- *   makeComposeMiddleware<AppServices, {request: ApiRouteRequest}>();
- * export const composeResponseMiddleware =
- *   makeComposeMiddleware<AppServices, Promise<ApiRouteResponse> | undefined>();
- *
- * // `requestServiceProvider` is a function that expects
- * //`{request: ApiRouteRequest}` (specified in the call to
- * //`makeComposeMiddleware`); for requestServiceProviders as part of routes in
- * // particular, the request responder calls this when it resolves the routes.
- *
- * const requestServiceProvider = composeServiceMiddleware(
- *   cookieAuthMiddleware, // expects `request` (from input), adds `authProvider`
- *   myDocumentStoreMiddleware, // expects authProvider, adds the document store
- *   myDocumentSearchMiddleware, // expects document store, adds search provider
- * ); // if you try to specify them in the wrong order it'll yell at you
- * ```
- *
- * WARNING: depending on how you use it, typescript _sometimes_ explodes on these recursive types. if you have problems in your build
- * with memory, you will have to specify the expected result type when calling the middleware reducer. this is a little annoying,
- * but it will still correctly error if the type you specify is wrong, so you've still got the type safety.
- *
- * ```
- * // this might work, or it might make your compiler run out of memory
- * eg: const myThing = makeComposeMiddleware()(...);
- *
- * // this helps typescript figure out what is going on
- * eg: const myThing: myType = makeComposeMiddleware()(...);
- * ```
- */
-export declare const makeComposeMiddleware: <Sa, M>() => <C extends any[]>(...chain: C) => MiddlewareProvider<Sa, M, ServiceMiddlewareProviderChainArgs<C>, ServiceMiddlewareProviderChainResult<C, M>>;

package/dist/esm/middleware/index.js

@@ -1,44 +0,0 @@
-/**
- * Creates a middleware composer for given AppServices and input value types. The composer accepts a list of middleware
- * that it assembles into a chain. The function returned by the composer takes a value of the given input value type,
- * passes that value through the chain, and returns the result of the last element in the chain. The ending value will
- * depend on the composed middleware.
- *
- * Examples:
- *
- * ```
- * export const composeServiceMiddleware =
- *   makeComposeMiddleware<AppServices, {request: ApiRouteRequest}>();
- * export const composeResponseMiddleware =
- *   makeComposeMiddleware<AppServices, Promise<ApiRouteResponse> | undefined>();
- *
- * // `requestServiceProvider` is a function that expects
- * //`{request: ApiRouteRequest}` (specified in the call to
- * //`makeComposeMiddleware`); for requestServiceProviders as part of routes in
- * // particular, the request responder calls this when it resolves the routes.
- *
- * const requestServiceProvider = composeServiceMiddleware(
- *   cookieAuthMiddleware, // expects `request` (from input), adds `authProvider`
- *   myDocumentStoreMiddleware, // expects authProvider, adds the document store
- *   myDocumentSearchMiddleware, // expects document store, adds search provider
- * ); // if you try to specify them in the wrong order it'll yell at you
- * ```
- *
- * WARNING: depending on how you use it, typescript _sometimes_ explodes on these recursive types. if you have problems in your build
- * with memory, you will have to specify the expected result type when calling the middleware reducer. this is a little annoying,
- * but it will still correctly error if the type you specify is wrong, so you've still got the type safety.
- *
- * ```
- * // this might work, or it might make your compiler run out of memory
- * eg: const myThing = makeComposeMiddleware()(...);
- *
- * // this helps typescript figure out what is going on
- * eg: const myThing: myType = makeComposeMiddleware()(...);
- * ```
- */
-export const makeComposeMiddleware = () => (...chain) => (app, appBinder) => {
-    const boundChain = chain.map(provider => appBinder ? appBinder(app, provider) : provider(app));
-    return (middleware, ...args) => {
-        return boundChain.reduce((result, provider) => provider(result, ...args), middleware);
-    };
-};

package/dist/esm/middleware/lambdaCorsResponseMiddleware.d.ts

@@ -1,20 +0,0 @@
-import { APIGatewayProxyEventV2 } from 'aws-lambda';
-import { ConfigProviderForConfig } from '../config';
-import { ApiResponse } from '../routing';
-type Config = {
-    corsAllowedHostRegex: string;
-};
-/**
- * Creates response middleware that adds CORS headers to responses from approved hosts.
- *
- * @param config the config object
- * @param config.corsAllowedHostRegex the config that specifies the regex for allowed hosts
- * @example
- * createLambdaCorsResponseMiddleware({
- *   corsAllowedHostRegex: '(openstax.org|herokuapp.com)$'
- * }),
- */
-export declare const createLambdaCorsResponseMiddleware: (config: ConfigProviderForConfig<Config>) => () => (responsePromise: Promise<ApiResponse<number, any>> | undefined, { request }: {
-    request: APIGatewayProxyEventV2;
-}) => Promise<ApiResponse<number, any>> | undefined;
-export {};

package/dist/esm/middleware/lambdaCorsResponseMiddleware.js

@@ -1,40 +0,0 @@
-import { resolveConfigValue } from '../config/resolveConfigValue';
-import { once } from '../misc/helpers';
-import { apiTextResponse } from '../routing';
-/**
- * Creates response middleware that adds CORS headers to responses from approved hosts.
- *
- * @param config the config object
- * @param config.corsAllowedHostRegex the config that specifies the regex for allowed hosts
- * @example
- * createLambdaCorsResponseMiddleware({
- *   corsAllowedHostRegex: '(openstax.org|herokuapp.com)$'
- * }),
- */
-export const createLambdaCorsResponseMiddleware = (config) => () => (responsePromise, { request }) => {
-    const getAllowedHostRegex = once(() => resolveConfigValue(config.corsAllowedHostRegex));
-    const cors = async () => {
-        const allowedHost = await getAllowedHostRegex();
-        if (request.headers.origin && request.headers.origin !== 'null' && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {
-            return {
-                'Access-Control-Allow-Origin': request.headers.origin,
-                'Access-Control-Allow-Credentials': 'true',
-                'Access-Control-Allow-Headers': 'content-type, x-request-id',
-                'Access-Control-Allow-Methods': 'POST, GET, PUT, PATCH, DELETE, OPTIONS',
-            };
-        }
-    };
-    if (responsePromise) {
-        return responsePromise.then(async (response) => {
-            response.headers = {
-                ...await cors(),
-                ...response.headers
-            };
-            return response;
-        });
-    }
-    if (request.requestContext.http.method === 'OPTIONS') {
-        return cors().then(headers => apiTextResponse(200, '', headers));
-    }
-    return responsePromise;
-};

package/dist/esm/middleware/throwNotFoundMiddleware.d.ts

@@ -1,4 +0,0 @@
-/**
- * Creates response middleware that throws a `NotFoundError` if the response is undefined.
- */
-export declare const createThrowNotFoundMiddleware: <Ro>() => () => (response: Promise<Ro> | undefined) => Promise<Ro>;

package/dist/esm/middleware/throwNotFoundMiddleware.js

@@ -1,10 +0,0 @@
-import { NotFoundError } from '../errors';
-/**
- * Creates response middleware that throws a `NotFoundError` if the response is undefined.
- */
-export const createThrowNotFoundMiddleware = () => () => (response) => {
-    if (!response) {
-        throw new NotFoundError('not found');
-    }
-    return response;
-};

package/dist/esm/misc/hashValue.d.ts

@@ -1,10 +0,0 @@
-export type HashValue = string | number | boolean | null | HashCompoundValue;
-export type HashCompoundValue = Array<HashValue> | {
-    [key: string]: HashValue;
-};
-/**
- * creates a string hash of lots of different kinds of things.
- *
- * @example hashValue({someKey: 'someValue'})
- */
-export declare const hashValue: (value: HashValue) => string;

package/dist/esm/misc/hashValue.js

@@ -1,13 +0,0 @@
-import { createHash } from 'crypto';
-/**
- * creates a string hash of lots of different kinds of things.
- *
- * @example hashValue({someKey: 'someValue'})
- */
-export const hashValue = (value) => {
-    // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
-    const allKeys = new Set();
-    JSON.stringify(value, (k, v) => (allKeys.add(k), v));
-    const strValue = JSON.stringify(value, Array.from(allKeys).sort());
-    return createHash('sha1').update(strValue).digest('hex');
-};

package/dist/esm/misc/helpers.d.ts

@@ -1,124 +0,0 @@
-import type { Logger } from '../services/logger';
-/**
- * Returns a function that gets the value of the given key from an object
- *
- * @param key
- * @example
- * const getAuthor = getKeyValue('author');
- * const author = getAuthor(book);
- */
-export declare const getKeyValue: <K extends string>(key: K) => <O extends { [_key in K]?: any; }>(obj: O) => O[K];
-/**
- * Returns a function that gets the value of the given key from an object, or the given default
- * value if the key is not present.
- *
- * @param key
- * @param defaultValue a default value matching the type of the value at the given key
- * @example
- * const getAuthorOrNope = getKeyValueOr('author', 'nope');
- * const authorOrNope = getAuthorOrNope(book);
- */
-export declare const getKeyValueOr: <K extends string, V, Od extends { [_key in K]?: any; } = { [_key in K]?: any; }>(key: K, defaultValue: V) => <O extends (Od extends undefined ? { [_key in K]?: any; } : Od)>(obj: O) => NonNullable<O[K]> | V;
-/**
- * Returns a function that sets the value of the given key on an object.
- *
- * @param key
- * @example
- * const putAuthor = putKeyValue('author');
- * const newBook = putAuthor(book, 'tom');
- */
-export declare const putKeyValue: <K extends string>(key: K) => <O extends { [_key in K]?: any; }>(obj: O, value: O[K]) => O;
-/**
- * Coerces a value into an array. If the value is already an array, it is returned as-is.
- * If the value is undefined, an empty array is returned.
- *
- * @param thing the value
- * @returns an array
- */
-export declare const coerceArray: <T>(thing: undefined | T | T[]) => T[];
-type FlowFn<A, R> = (...args: [A]) => R;
-type AnyFlowFn = FlowFn<any, any>;
-type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
-type FlowResult<C, A> = C extends [infer F1, ...infer Cr] ? F1 extends AnyFlowFn ? Cr extends never[] ? FlowFnResult<F1, A> : FlowResult<Cr, FlowFnResult<F1, A>> : never : never;
-type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends FlowFn<infer A, any> ? A : never : never;
-/**
- * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
- */
-export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
-export type RetryOptions = {
-    logger?: Logger;
-    wait?: number;
-    splay?: number;
-    retries?: number;
-    n?: number;
-};
-/**
- * Retries a function with a delay between retries.
- * @param fn The function to retry
- * @param [options] retry options
- * @param [options.wait=100] base wait of first retry (number), further retries are: t=n*wait,
- * default: 100
- * @param [options.splay=0.5] percentage to modify t by. 0.5 is 50%, which would make
- * t=n*wait+rand(wait*splay*-1, wait*splay), default: 0.5
- * @param [options.retries=2] number of times to retry. (2 retries means it'll try a max of 3 times),
- * default: 2
- * @param [options.n=0] the starting retry index. probably don't set this. unless you really want a very steep
- *  initial wait cliff with incremental increases, then maybe you'd set this. default: 0
- * @returns A promise that resolves with the result of the function, or rejects with the last error.
- */
-export declare const retryWithDelay: <R>(fn: (abort?: (e: Error) => never) => Promise<R>, options?: RetryOptions) => Promise<R>;
-/**
- * a shameful helper to avoid needing to test code coverage of branches
- */
-export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
-/**
- * maps the array and returns the first result that matches the predicate
- * avoids processing extra elements that would happen with .map().find() or .reduce
- *
- * eg the third element of the array is never processed:
- *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
- */
-export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
-/**
- * returns a function that will only ever call the given function once, returning the first result for every subsequent call
- *
- * does not cache rejected promises, to avoid cache poisoning on failed async requests
- *
- * eg:
- *   const heavyFunction = () => 'hello';
- *   const butOnlyOnce = once(() => 'hello');
- *
- *   heavyFunction() // returns `hello`;
- *   butOnlyOnce() // returns `hello`;
- */
-export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
-/**
- * memoizes a function with any number of arguments
- *
- * does not cache rejected promises, to avoid cache poisoning on failed async requests
- */
-export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
-/**
- * rounds number to given number of places
- *
- * eg:
- *  roundToPrecision(1234.123, 2); // returns 1200
- *  roundToPrecision(1234.123, -2); // returns 1234.12
- *  roundToPrecision(1234.125, -2); // returns 1234.13
- */
-export declare const roundToPrecision: (num: number, places: number) => number;
-/**
- * a silly utility to help typescript realize an array is a tuple
- *
- * eg:
- *  const a = [5, 'string'] // type is `Array<string | number>`
- *  const t = tuple(5, 'string') type is `[5, 'string']`
- *
- * both have the same javascript value, but one is forced to be a tuple, which
- * is nice if its structure is important. examples are like the React.useState
- * pattern where there are two return values in a tuple, or if you're feeding
- * Object.fromEntries
- *
- */
-export declare const tuple: <A extends any[]>(...args: A) => A;
-export {};

package/dist/esm/misc/helpers.js

@@ -1,199 +0,0 @@
-/*
- * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
- * these do more validation that the second function gets a compatible object.
- */
-/**
- * Returns a function that gets the value of the given key from an object
- *
- * @param key
- * @example
- * const getAuthor = getKeyValue('author');
- * const author = getAuthor(book);
- */
-export const getKeyValue = (key) => (obj) => obj[key];
-/**
- * Returns a function that gets the value of the given key from an object, or the given default
- * value if the key is not present.
- *
- * @param key
- * @param defaultValue a default value matching the type of the value at the given key
- * @example
- * const getAuthorOrNope = getKeyValueOr('author', 'nope');
- * const authorOrNope = getAuthorOrNope(book);
- */
-export const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
-/**
- * Returns a function that sets the value of the given key on an object.
- *
- * @param key
- * @example
- * const putAuthor = putKeyValue('author');
- * const newBook = putAuthor(book, 'tom');
- */
-export const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
-/**
- * Coerces a value into an array. If the value is already an array, it is returned as-is.
- * If the value is undefined, an empty array is returned.
- *
- * @param thing the value
- * @returns an array
- */
-export const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
-/**
- * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
- */
-export const flow = (...chain) => (param) => {
-    let result = param;
-    for (const fn of chain) {
-        result = fn(result);
-    }
-    return result;
-};
-/**
- * Retries a function with a delay between retries.
- * @param fn The function to retry
- * @param [options] retry options
- * @param [options.wait=100] base wait of first retry (number), further retries are: t=n*wait,
- * default: 100
- * @param [options.splay=0.5] percentage to modify t by. 0.5 is 50%, which would make
- * t=n*wait+rand(wait*splay*-1, wait*splay), default: 0.5
- * @param [options.retries=2] number of times to retry. (2 retries means it'll try a max of 3 times),
- * default: 2
- * @param [options.n=0] the starting retry index. probably don't set this. unless you really want a very steep
- *  initial wait cliff with incremental increases, then maybe you'd set this. default: 0
- * @returns A promise that resolves with the result of the function, or rejects with the last error.
- */
-export const retryWithDelay = (fn, options) => {
-    const { wait, splay, retries, n } = { wait: 100, splay: 0.5, retries: 2, n: 0, ...options };
-    if (n >= retries) {
-        return fn();
-    }
-    let aborted = false;
-    const timeout = (n + 1) * wait + (Math.random() * 2 - 1) * splay * wait;
-    const retry = (e) => new Promise((resolve, reject) => {
-        var _a;
-        if (aborted) {
-            reject(e);
-        }
-        else {
-            (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.log(`failed try ${n + 1} of ${retries}. ${e.message}`);
-            setTimeout(() => retryWithDelay(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
-        }
-    });
-    const abort = (e) => {
-        aborted = true;
-        throw e;
-    };
-    return fn(abort).catch(retry);
-};
-/**
- * a shameful helper to avoid needing to test code coverage of branches
- */
-export const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
-/**
- * maps the array and returns the first result that matches the predicate
- * avoids processing extra elements that would happen with .map().find() or .reduce
- *
- * eg the third element of the array is never processed:
- *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
- */
-export const mapFind = (array, mapper, predicate = (r) => !!r) => {
-    for (const item of array) {
-        const mapped = mapper(item);
-        if (predicate(mapped)) {
-            return mapped;
-        }
-    }
-};
-/**
- * returns a function that will only ever call the given function once, returning the first result for every subsequent call
- *
- * does not cache rejected promises, to avoid cache poisoning on failed async requests
- *
- * eg:
- *   const heavyFunction = () => 'hello';
- *   const butOnlyOnce = once(() => 'hello');
- *
- *   heavyFunction() // returns `hello`;
- *   butOnlyOnce() // returns `hello`;
- */
-export const once = (fn) => {
-    const initialValue = {};
-    let result = initialValue;
-    return ((...args) => {
-        if (result !== initialValue) {
-            return result;
-        }
-        result = fn(...args);
-        if (typeof result === 'object' && result instanceof Promise) {
-            // Clear the result when possible but do not return a Promise that resolves to the initialValue
-            result.catch(() => result = initialValue);
-        }
-        // If this is a rejected Promise, it should be returned before catch() actually overwrites it
-        return result;
-    });
-};
-/**
- * memoizes a function with any number of arguments
- *
- * does not cache rejected promises, to avoid cache poisoning on failed async requests
- */
-export const memoize = (fn) => {
-    const cache = {};
-    const resolveCache = (cacheLayer, [first, ...rest]) => {
-        if (!first) {
-            return cacheLayer;
-        }
-        const layers = first instanceof Object
-            ? (cacheLayer.weakLayers = (cacheLayer.weakLayers || (typeof WeakMap === 'undefined' ? undefined : new WeakMap())))
-            : (cacheLayer.strongLayers = (cacheLayer.strongLayers || new Map()));
-        // argument is an object and WeakMap is not supported
-        if (!layers) {
-            return {};
-        }
-        const layer = layers.get(first) || {};
-        if (!layers.has(first)) {
-            layers.set(first, layer);
-        }
-        return resolveCache(layer, rest);
-    };
-    return ((...args) => {
-        const thisCache = resolveCache(cache, args);
-        if ('result' in thisCache) {
-            return thisCache.result;
-        }
-        thisCache.result = fn(...args);
-        if (typeof thisCache.result === 'object' && thisCache.result instanceof Promise) {
-            // Clear the result when possible but do not return a Promise that resolves to the initialValue
-            thisCache.result.catch(() => delete thisCache.result);
-        }
-        return thisCache.result;
-    });
-};
-/**
- * rounds number to given number of places
- *
- * eg:
- *  roundToPrecision(1234.123, 2); // returns 1200
- *  roundToPrecision(1234.123, -2); // returns 1234.12
- *  roundToPrecision(1234.125, -2); // returns 1234.13
- */
-export const roundToPrecision = (num, places) => {
-    const multiplier = Math.pow(10, -1 * places);
-    // https://stackoverflow.com/a/11832950/14809536
-    return Math.round((num + Number.EPSILON) * multiplier) / multiplier;
-};
-/**
- * a silly utility to help typescript realize an array is a tuple
- *
- * eg:
- *  const a = [5, 'string'] // type is `Array<string | number>`
- *  const t = tuple(5, 'string') type is `[5, 'string']`
- *
- * both have the same javascript value, but one is forced to be a tuple, which
- * is nice if its structure is important. examples are like the React.useState
- * pattern where there are two return values in a tuple, or if you're feeding
- * Object.fromEntries
- *
- */
-export const tuple = (...args) => args;