@openstax/ts-utils 1.33.1 → 1.34.0

package/dist/cjs/fetch/index.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stateHasError = exports.stateHasData = exports.fetchIdle = exports.fetchSuccess = exports.fetchError = exports.fetchLoading = exports.FetchStateType = void 0;
-/*
- * these are just helpers for formatting responses, they don't actually do any loading. especially in UI development they
- * help with continuity over loading, reloading, saving, and errors. this is pretty nice in typescript because you have to deal
- * with the possibility that the result state is in a loading or error state. if you avoid dealing with those states you need
- * to write very clear code to ignore them, which easily presents missing functionality like errors that are not being messaged
- * to the user.
- * */
-var FetchStateType;
-(function (FetchStateType) {
-    FetchStateType["SUCCESS"] = "success";
-    FetchStateType["ERROR"] = "error";
-    FetchStateType["LOADING"] = "loading";
-    FetchStateType["IDLE"] = "idle";
-})(FetchStateType || (exports.FetchStateType = FetchStateType = {}));
-/*
- * keeps existing data but sets the new status
- *
- * const state = fetchLoading(previousState)
- * */
-const fetchLoading = (previous) => ({ type: FetchStateType.LOADING, ...(previous && 'data' in previous ? { data: previous.data } : {}) });
-exports.fetchLoading = fetchLoading;
-/*
- * keeps existing data but sets the new status and error value
- *
- * const state = fetchError(error, previousState)
- * */
-const fetchError = (error, previous) => ({ ...previous, type: FetchStateType.ERROR, error });
-exports.fetchError = fetchError;
-/*
- * formats data with success type
- *
- * const state = fetchSuccess(newData)
- * */
-const fetchSuccess = (data) => ({ type: FetchStateType.SUCCESS, data });
-exports.fetchSuccess = fetchSuccess;
-/*
- * formats data with idle type
- *
- * const state = fetchIdle(newData)
- * */
-const fetchIdle = () => ({ type: FetchStateType.IDLE });
-exports.fetchIdle = fetchIdle;
-/*
- * guard for checking if the state has result data, it might be true for any state type.
- * */
-const stateHasData = (state) => 'data' in state;
-exports.stateHasData = stateHasData;
-/*
- * guard for checking if the state has an error, it might be true for error or loading states.
- * */
-const stateHasError = (state) => 'error' in state;
-exports.stateHasError = stateHasError;

package/dist/cjs/guards/index.d.ts

@@ -1,38 +0,0 @@
-/**
- * checks if a thing is defined. while often easy to do with a simple if statement, in certain
- * situations the guard is required and its nice to have one pre-defined. E.g. in the following
- * example, the result is `Array<string>`.
- *
- * `const result = (array as Array<string | undefined>).filter(isDefined);`
- */
-export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
-/**
- * checks if a thing is not null. while often easy to do with a simple if statement,
- * in certain situations the guard is required and its nice to have one pre-defined.
- * E.g. in the following example, the result is `Array<string>`.
- *
- * `const result = (array as Array<string | null>).filter(isNotNull);`
- */
-export declare const isNotNull: <X>(x: X) => x is Exclude<X, null>;
-/**
- * checks if a thing is a number. while often easy to do with a simple if statement, in certain
- * situations the guard is required and its nice to have one pre-defined. E.g. in the following
- * example, the result is `Array<number>`.
- *
- * `const result = (array as Array<number | undefined>).filter(isNumber);`
- */
-export declare const isNumber: (x: any) => x is number;
-/**
- * a guard for plain old javascript objects that are not based on some other prototype,
- * for example making them safe to JSON stringify and stuff
- */
-export declare const isPlainObject: (thing: any) => thing is {
-    [key: string]: any;
-};
-/**
- * if the first thing is defined it uses it, otherwise it returns the second thing. this isn't
- * really a guard its just a way to provide a default value without creating a coverage branch.
- *
- * @example const valueWithDefault = ifDefined(thing, 'default value')
- */
-export declare const ifDefined: <X, D>(x: X, d: D) => D | Exclude<X, undefined>;

package/dist/cjs/guards/index.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ifDefined = exports.isPlainObject = exports.isNumber = exports.isNotNull = exports.isDefined = void 0;
-/**
- * checks if a thing is defined. while often easy to do with a simple if statement, in certain
- * situations the guard is required and its nice to have one pre-defined. E.g. in the following
- * example, the result is `Array<string>`.
- *
- * `const result = (array as Array<string | undefined>).filter(isDefined);`
- */
-const isDefined = (x) => x !== undefined;
-exports.isDefined = isDefined;
-/**
- * checks if a thing is not null. while often easy to do with a simple if statement,
- * in certain situations the guard is required and its nice to have one pre-defined.
- * E.g. in the following example, the result is `Array<string>`.
- *
- * `const result = (array as Array<string | null>).filter(isNotNull);`
- */
-const isNotNull = (x) => x !== null;
-exports.isNotNull = isNotNull;
-/**
- * checks if a thing is a number. while often easy to do with a simple if statement, in certain
- * situations the guard is required and its nice to have one pre-defined. E.g. in the following
- * example, the result is `Array<number>`.
- *
- * `const result = (array as Array<number | undefined>).filter(isNumber);`
- */
-const isNumber = (x) => typeof x === 'number';
-exports.isNumber = isNumber;
-/**
- * a guard for plain old javascript objects that are not based on some other prototype,
- * for example making them safe to JSON stringify and stuff
- */
-const isPlainObject = (thing) => thing instanceof Object && thing.__proto__.constructor.name === 'Object';
-exports.isPlainObject = isPlainObject;
-/**
- * if the first thing is defined it uses it, otherwise it returns the second thing. this isn't
- * really a guard its just a way to provide a default value without creating a coverage branch.
- *
- * @example const valueWithDefault = ifDefined(thing, 'default value')
- */
-const ifDefined = (x, d) => (0, exports.isDefined)(x) ? x : d;
-exports.ifDefined = ifDefined;

package/dist/cjs/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./misc/partitionSequence"), exports);
-__exportStar(require("./misc/helpers"), exports);
-__exportStar(require("./misc/merge"), exports);
-__exportStar(require("./misc/hashValue"), exports);

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

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createErrorHandler = exports.defaultHandlers = void 0;
-const errors_1 = require("../errors");
-const routing_1 = require("../routing");
-const logger_1 = require("../services/logger");
-exports.defaultHandlers = {
-    InvalidRequestError: (e) => (0, routing_1.apiTextResponse)(400, `400 ${e.message}`),
-    UnauthorizedError: (e) => (0, routing_1.apiTextResponse)(401, `401 ${e.message}`),
-    ForbiddenError: (e) => (0, routing_1.apiTextResponse)(403, `403 ${e.message}`),
-    NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, `404 ${e.message}`),
-    ValidationError: (e) => (0, routing_1.apiJsonResponse)(422, e.getData()),
-    SessionExpiredError: (e) => (0, routing_1.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
- */
-const createErrorHandler = (inputHandlers) => {
-    const handlers = { ...exports.defaultHandlers, ...inputHandlers };
-    return async (e, logger) => {
-        const name = (0, errors_1.isAppError)(e) ? e.constructor.TYPE : e.constructor.name;
-        const handler = handlers[name];
-        const logLevel = handler ? logger_1.Level.Info : logger_1.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 (0, routing_1.apiTextResponse)(500, '500 Error');
-    };
-};
-exports.createErrorHandler = createErrorHandler;

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

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSlowResponseMiddleware = void 0;
-const resolveConfigValue_1 = require("../config/resolveConfigValue");
-const helpers_1 = require("../misc/helpers");
-const routing_1 = require("../routing");
-const logger_1 = require("../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'),
- * });
- */
-const createSlowResponseMiddleware = (config) => {
-    const getSlowThreshold = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.logResponseSlowerThan).then(result => parseInt(result, 10)));
-    const getTimeoutAfter = (0, helpers_1.once)(() => (0, resolveConfigValue_1.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(logger_1.Level.Error, {
-                        message: 'request processing timed out',
-                    });
-                    resolve((0, routing_1.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(logger_1.Level.Warn, {
-                        message: 'slow response',
-                        time,
-                    });
-                }
-            });
-            return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
-        });
-    };
-};
-exports.createSlowResponseMiddleware = createSlowResponseMiddleware;

package/dist/cjs/middleware/index.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeComposeMiddleware = void 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()(...);
- * ```
- */
-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);
-    };
-};
-exports.makeComposeMiddleware = makeComposeMiddleware;

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

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLambdaCorsResponseMiddleware = void 0;
-const resolveConfigValue_1 = require("../config/resolveConfigValue");
-const helpers_1 = require("../misc/helpers");
-const routing_1 = require("../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)$'
- * }),
- */
-const createLambdaCorsResponseMiddleware = (config) => () => (responsePromise, { request }) => {
-    const getAllowedHostRegex = (0, helpers_1.once)(() => (0, resolveConfigValue_1.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 => (0, routing_1.apiTextResponse)(200, '', headers));
-    }
-    return responsePromise;
-};
-exports.createLambdaCorsResponseMiddleware = createLambdaCorsResponseMiddleware;

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createThrowNotFoundMiddleware = void 0;
-const errors_1 = require("../errors");
-/**
- * Creates response middleware that throws a `NotFoundError` if the response is undefined.
- */
-const createThrowNotFoundMiddleware = () => () => (response) => {
-    if (!response) {
-        throw new errors_1.NotFoundError('not found');
-    }
-    return response;
-};
-exports.createThrowNotFoundMiddleware = createThrowNotFoundMiddleware;

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashValue = void 0;
-const crypto_1 = require("crypto");
-/**
- * creates a string hash of lots of different kinds of things.
- *
- * @example hashValue({someKey: 'someValue'})
- */
-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 (0, crypto_1.createHash)('sha1').update(strValue).digest('hex');
-};
-exports.hashValue = hashValue;

package/dist/cjs/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 {};