@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/cjs/middleware/apiErrorHandler.js

@@ -0,0 +1,42 @@
+"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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,54 @@
+"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/{packages/utils/src/middleware/index.ts → dist/cjs/middleware/index.d.ts}

@@ -1,51 +1,11 @@
 import { TupleZip } from '../types';
-
-// this is a more standard flow provider that takes input and produces an unrelated output
-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;
-
-// this detects generics that forward the input to the output while modifying or adding properties
+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 // if R includes any keys from M, the M keys are more specific, use M
-        : R extends M
-          ? R // R is a more specific version of M, use R
-          : Omit<M, keyof R> & R // R overwrites some type from M, use R
-      : S extends MiddlewareProvider<any, M, any, infer R>
-        ? R
-        : never
-      : 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
-;
-
+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,
@@ -84,12 +44,4 @@ export type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infe
  * eg: const myThing: myType = makeComposeMiddleware()(...);
  * ```
  */
-export const makeComposeMiddleware = <Sa, M>() => <C extends any[]>(
-  ...chain: C
-): MiddlewareProvider<Sa, M, ServiceMiddlewareProviderChainArgs<C>, ServiceMiddlewareProviderChainResult<C, M>> => (app, appBinder) => {
-  const boundChain = chain.map(provider => appBinder ? appBinder(app, provider) : provider(app));
-
-  return (middleware: M, ...args) => {
-    return boundChain.reduce((result, provider) => provider(result, ...args), middleware);
-  };
-};
+export declare const makeComposeMiddleware: <Sa, M>() => <C extends any[]>(...chain: C) => MiddlewareProvider<Sa, M, ServiceMiddlewareProviderChainArgs<C>, ServiceMiddlewareProviderChainResult<C, M>>;

package/dist/cjs/middleware/index.js

@@ -0,0 +1,48 @@
+"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,44 @@
+"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

@@ -0,0 +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

@@ -0,0 +1,14 @@
+"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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1,124 @@
+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 {};