@openstax/ts-utils 1.2.9 → 1.3.1

package/dist/cjs/guards.d.ts

@@ -1,6 +1,30 @@
+/**
+ * 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 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.js

@@ -1,36 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ifDefined = exports.isPlainObject = exports.isNumber = exports.isDefined = void 0;
-/*
- * checks if a thing is defined. this is often easy to do with a simple if statement, but in certain
- * situations the guard is required and its nice to have one pre-defined.
+/**
+ * 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>`.
  *
- * eg this filters the array but doesn't fix the array type:
- *   const result = (array as Array<string | undefined>).filter(thing => !!thing);
- *
- * eg this does the right thing:
- *   const result = (array as Array<string | undefined>).filter(isDefined);
- *
- * eg because writing this is annoying:
- *   const result = (array as Array<string | undefined>).filter(<X>(x: X): x is Exclude<X, undefined> => x !== undefined);
+ * `const result = (array as Array<string | undefined>).filter(isDefined);`
  */
 const isDefined = (x) => x !== undefined;
 exports.isDefined = isDefined;
+/**
+ * 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;
-/*
- * this isn't really a guard its just a way to provide a default value without creating a coverage branch.
- *
- * if the first thing is defined it uses it, otherwise it returns the second thing.
+/**
+ * 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.
  *
- * eg:
- *   const valueWithDefault = ifDefined(thing, 'default value')
+ * @example const valueWithDefault = ifDefined(thing, 'default value')
  */
 const ifDefined = (x, d) => (0, exports.isDefined)(x) ? x : d;
 exports.ifDefined = ifDefined;

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

@@ -3,5 +3,13 @@ import type { Logger } from '../services/logger';
 declare type Handlers = {
     [key: string]: (e: Error, logger: Logger) => ApiResponse<number, any>;
 };
+/**
+ * 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: (inputHandlers?: Handlers | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;
 export {};

package/dist/cjs/middleware/apiErrorHandler.js

@@ -10,6 +10,14 @@ const defaultHandlers = {
     NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, `404 ${e.message}`),
     InvalidRequestError: (e) => (0, routing_1.apiTextResponse)(400, `400 ${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 = { ...defaultHandlers, ...inputHandlers };
     return async (e, logger) => {

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

@@ -5,6 +5,18 @@ declare 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;

package/dist/cjs/middleware/apiSlowResponseMiddleware.js

@@ -5,6 +5,18 @@ 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)));

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

@@ -4,7 +4,17 @@ import { ApiResponse } from '../routing';
 declare type Config = {
     corsAllowedHostRegex: string;
 };
-export declare const createLambdaCorsResponseMiddleware: (config: ConfigProviderForConfig<Config>) => (responsePromise: Promise<ApiResponse<number, any>> | undefined, { request }: {
+/**
+ * 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

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLambdaCorsResponseMiddleware = void 0;
 const resolveConfigValue_1 = require("../config/resolveConfigValue");
 const routing_1 = require("../routing");
-const createLambdaCorsResponseMiddleware = (config) => (responsePromise, { request }) => {
+/**
+ * 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 cors = async () => {
         const allowedHost = await (0, resolveConfigValue_1.resolveConfigValue)(config.corsAllowedHostRegex);
         if (request.headers.origin && request.headers.origin !== 'null' && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {

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

@@ -1 +1,4 @@
+/**
+ * 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

@@ -2,6 +2,9 @@
 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');

package/dist/cjs/middleware.d.ts

@@ -6,4 +6,42 @@ export declare type ServiceMiddlewareProviderResult<M, S> = [M] extends [never]
 export declare type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
 export declare 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 declare type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleExtends<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> extends 'yes' ? ServiceMiddlewareProviderChainArgs<S> : TupleExtends<ServiceMiddlewareProviderArgs<S1>, ServiceMiddlewareProviderChainArgs<S>> extends 'yes' ? ServiceMiddlewareProviderArgs<S1> : never : 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/cjs/middleware.js

@@ -1,34 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeComposeMiddleware = void 0;
-/*
- * this function creates a middleware composer for the given AppServices and starting value. the ending
- * value will depend on the composed values. after composing the values, the composer returns a function that
- * expects the given input value and returns the result of the last element of the middleware chain.
+/**
+ * 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.
  *
- * eg:
- *   export const composeServiceMiddleware = makeComposeMiddleware<AppServices, {request: ApiRouteRequest}>();
- *   export const composeResponseMiddleware = makeComposeMiddleware<AppServices, Promise<ApiRouteResponse> | undefined>();
+ * Examples:
  *
- * eg:
- *   // `requestServiceProvider` is a function that expects `{request: ApiRouteResponse}` (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, // this one just depends on `request`, which is in the input, and returns that plus the authProvider
- *     myDocumentStoreMiddleware, // this one expects the authProvider, and adds the document store
- *     myDocumentSearchMiddleware, // this one expects the document store, and adds the search provider
- *   ); // if you try to specify them in the wrong order it'll yell at you
+ * ```
+ * 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) => {

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

@@ -2,5 +2,10 @@ declare type HashValue = string | number | boolean | null | HashCompoundValue;
 declare 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;
 export {};

package/dist/cjs/misc/hashValue.js

@@ -2,12 +2,11 @@
 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.
  *
- * eg:
- *   hashValue({someKey: 'someValue'})
- * */
+ * @example hashValue({someKey: 'someValue'})
+ */
 const hashValue = (value) => {
     // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
     const allKeys = new Set();

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

@@ -1,12 +1,48 @@
+/**
+ * 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_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
+/**
+ * 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: T | T[] | undefined) => T[];
 declare type FlowFn<A, R> = (...args: [A]) => R;
 declare type AnyFlowFn = FlowFn<any, any>;
 declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
 declare 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;
 declare 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>>;
 declare type RetryOptions = {
     wait?: number;
@@ -14,11 +50,69 @@ declare type RetryOptions = {
     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: () => Promise<R>, options?: RetryOptions | undefined) => 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
+ *
+ * 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
+ */
 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/cjs/misc/helpers.js

@@ -1,28 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = exports.roundToPrecision = exports.memoize = exports.once = exports.mapFind = exports.fnIf = exports.retryWithDelay = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tuple = exports.roundToPrecision = exports.memoize = exports.once = exports.mapFind = exports.fnIf = exports.retryWithDelay = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+/**
+ * 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);
+ */
+const getKeyValue = (key) => (obj) => obj[key];
+exports.getKeyValue = getKeyValue;
+/**
+ * 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);
+ */
+const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
+exports.getKeyValueOr = getKeyValueOr;
+/**
+ * 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');
- * */
-const getKeyValue = (key) => (obj) => obj[key];
-exports.getKeyValue = getKeyValue;
-const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
-exports.getKeyValueOr = getKeyValueOr;
+ */
 const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
 exports.putKeyValue = putKeyValue;
+/**
+ * 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
+ */
 const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
 exports.coerceArray = coerceArray;
-/*
+/**
  * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
  */
 const flow = (...chain) => (param) => {
@@ -33,6 +57,20 @@ const flow = (...chain) => (param) => {
     return result;
 };
 exports.flow = flow;
+/**
+ * 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.
+ */
 const retryWithDelay = (fn, options) => {
     const { wait, splay, retries, n } = { wait: 100, splay: 0.5, retries: 2, n: 0, ...options };
     if (n >= retries) {
@@ -45,12 +83,12 @@ const retryWithDelay = (fn, options) => {
     return fn().catch(retry);
 };
 exports.retryWithDelay = retryWithDelay;
-/*
+/**
  * a shameful helper to avoid needing to test code coverage of branches
  */
 const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
 exports.fnIf = fnIf;
-/*
+/**
  * maps the array and returns the first result that matches the predicate
  * avoids processing extra elements that would happen with .map().find() or .reduce
  *
@@ -66,7 +104,7 @@ const mapFind = (array, mapper, predicate = (r) => !!r) => {
     }
 };
 exports.mapFind = mapFind;
-/*
+/**
  * returns a function that will only ever call the given function once, returning the first result for every subsequent call
  *
  * eg:
@@ -82,7 +120,7 @@ const once = (fn) => {
     return ((...args) => result === initialValue ? (result = fn(...args)) : result);
 };
 exports.once = once;
-/*
+/**
  * memoizes a function with any number of arguments
  */
 const memoize = (fn) => {
@@ -110,7 +148,7 @@ const memoize = (fn) => {
     });
 };
 exports.memoize = memoize;
-/*
+/**
  * rounds number to given number of places
  *
  * eg:
@@ -124,7 +162,7 @@ const roundToPrecision = (num, places) => {
     return Math.round((num + Number.EPSILON) * multiplier) / multiplier;
 };
 exports.roundToPrecision = roundToPrecision;
-/*
+/**
  * a silly utility to help typescript realize an array is a tuple
  *
  * eg:

package/dist/cjs/misc/merge.d.ts

@@ -1,3 +1,21 @@
 import type { UnionToIntersection } from '../types';
+/**
+ * Takes two objects and returns an array of the keys that are common to both, with a type
+ * limited to those keys.
+ *
+ * @param thing1 some object
+ * @param thing2 another object
+ * @returns an array of keys, type-limited to those keys
+ */
 export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
+/**
+ * recursive merge properties of inputs. values are merged if they are
+ * plain objects or arrays, otherwise if the same property exists in both
+ * objects the value from the second argument will win.
+ *
+ * unlike lodash merge, this will not change object references for values that
+ * exist only in one parameter.
+ *
+ * @example merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ */
 export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

package/dist/cjs/misc/merge.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.merge = exports.getCommonProperties = void 0;
 const guards_1 = require("../guards");
+/**
+ * Takes two objects and returns an array of the keys that are common to both, with a type
+ * limited to those keys.
+ *
+ * @param thing1 some object
+ * @param thing2 another object
+ * @returns an array of keys, type-limited to those keys
+ */
 const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
 exports.getCommonProperties = getCommonProperties;
-/*
+/**
  * recursive merge properties of inputs. values are merged if they are
  * plain objects or arrays, otherwise if the same property exists in both
  * objects the value from the second argument will win.
@@ -12,8 +20,7 @@ exports.getCommonProperties = getCommonProperties;
  * unlike lodash merge, this will not change object references for values that
  * exist only in one parameter.
  *
- * eg:
- *   merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ * @example merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
  */
 const merge = (...[thing1, ...tail]) => {
     const mergedTail = tail.length > 0